Table of content#

• Template
  • Define template class
  • Use template class
• STL
  • Identify STL
  • Use standard list
  • Identify iterator
  • Know some STLs
• Smart pointer
  • Identify and use unique_ptr
  • Identify shared_ptr

Introduction#

• Templates
  • Enable programmers to specify an entire range of related functions and related classes
  • 使程序员能够指定一系列相关的函数和相关类
    • Called function-template specializations and class-template specializations, respectively
    • 分别称为函数模板特化和类模板特化
  • Generic programming
  • 泛型编程
  • Analogy: templates are like stencils, template specializations are like separate tracings
  • 类比：模板就像模板，模板特化就像单独的描图
    • All tracings have the same shape, but they could have different colors
    • 所有描图形状相同，但它们可能有不同的颜色

The generics problem#

1
class PairOfUint16s {
2
public:
3
    uint16_t getMember(uint8_t x);
4
    void setMember(uint8_t x, uint16_t newValue);
5
    PairOfUint16s(uint16_t first, uint16_t second);
6
protected:
7
    uint16_t items[2];
8
};

• If we want to define many similar classes
• 如果我们想定义许多相似的类 class PairOfUint8s {. . .
class PairOfUint32s {. . .
class PairOfInt32s {. . .
class PairOfInt16s {. . .
class PairOfInt8s {. . .
• Since the basic functionality of a “pair” is the same, the function and code of this class remains almost identical, no matter what type was stored inside the pair.
• 由于“pair”的基本功能相同，无论存储在“pair”中的是什么类型，这个类的函数和代码几乎都是相同的。

• However, we can’t normally just write one class for a pair of “anything” because we have to declare parameter and return types.
• 然而，我们通常不能只为“anything”的pair编写一个类，因为我们必须声明参数和返回类型。
• We could work around this by using subclassing (if we were using objects, but “int” types aren’t objects) or by using void pointers (which are generally horrible)
• 我们可以通过使用子类化（如果我们使用对象，但“int”类型不是对象）或使用空指针（这通常很糟糕）来解决这个问题。

Defining a template class#

1
template <typename T> class Pair {
2
public:
3
    T getMember(uint8_t x);
4
    void setMember(uint8_t x, T newValue);
5
    Pair(T first, T second);
6
protected:
7
    T items[2];
8
};

Defining template methods#

1
template <typename T> T Pair<T>::getMember(uint8_t x){
2
    return items[x];
3
}

• Template method

1
template <typename T> void Pair<T>::setMember(uint8_t x, T newValue) {
2
    items[x] = newValue;
3
}

• Template constructor

1
template <typename T> Pair<T>::Pair(T first, T second) {
2
    items[0] = first;
3
    items[1] = second;
4
}

Using a template class#

<……> tell compiler which exact type we use for this object
<……> 告诉编译器我们为这个对象使用哪种确切类型

1
int main() {
2
    Pair<uint16_t> test(4,5);
3
    cout << test.getMember(0);
4
    Pair<std::string> stest("Hello", "SEKAI");
5
    cout << stest.getMember(0);
6
}

彩蛋：点击播放《Hello, SEKAI》

• test(4,5) and stest("Hello", "SEKAI") are two objects of class Pair
• test(4,5) 和 stest("Hello", "SEKAI") 是类 Pair 的两个对象
• These two object use different parameters, but they do same work;
• 这两个对象使用不同的参数，但执行相同的工作；

Templates#

• Templates allow a section of code to be declared with parameters that are assigned at compile time.
• 模板允许在编译时声明带有参数的代码段。
• When a template class is used, the compiler builds a new version of that class based on the parameters given and inserts that into the program source code.
• 当使用模板类时，编译器会根据给定的参数构建该类的新版本，并将其插入到程序源代码中。
• This is usually only useful when it is impossible, or substantially improves performance, to adapt the code at run time – as in the case of multiple types.
• 这通常只在无法在运行时适应代码，或者显著提高性能时才有用——例如在多种类型的情况下。

1
template <typename T> T twice(T x) {
2
    return (x * (T)2); // (T) cast integer 2 into the type T
3
}
4
cout << twice(123);
5
cout << twice(123.1);

1
cout << twice(“moose”);

1
template <typename T> T twice(T x) {
2
    static_assert(std::is_arithmetic<T>::value,"Can't double non arithmetic value");
3
    return (x * (T)2);
4
}

STL: Lists#

这里的List应该翻译为链表

1
array<type, size>

represents an array list. Behaves just like a C array except that it is an object and has the STL list methods.
表示数组列表。行为类似于 C 数组，除了它是一个对象并且具有 STL 列表方法。

1
array<int,10> a1,a2,a3;

↓

1
#include <array>
2
……
3
cout<<a1[0]<<endl;
4
cout<<a2[2]<<endl;
5
cout<<a1.begin()<<endl;
6
cout<<a1.end()<<endl;
7
cout<<a2.size()<<endl;

See example
Use as int type array
Use as object too

1
list<type>

represents a doubly linked list, which can increase size as necessary and easily insert options in any position. But cannot support random access to elements; you can only step forwards or backwards to reach the element you want.
表示一个双向链表，可以根据需要增加大小，并可以轻松地在任何位置插入选项。但是不支持随机访问元素；您只能向前或向后移动以到达您想要的元素。

1
std::list<Room*> Room::rooms;

1
forward_list<type>

represents a singly linked list, which is slightly smaller and faster than a doubly linked list, but you can only step forward.
表示一个单链表，比双向链表略小且更快，但只能向前移动。

1
deque<type>

represents a “double ended queue”. A variable length list with random access, but adding items in the middle is slow; they can be quickly added only at the start or the end.
表示一个“双端队列”。一个具有随机访问的变长列表，但向中间添加项目较慢；它们只能快速添加到开始或结束。

• A deque is not physically contiguous in memory, but logical contiguously
• 双端队列在内存中不是物理连续的，但逻辑上是连续的

deque: double-ended queue

矢量容器，自带索引
普通数组 (arr) 不能作为迭代对象 (iterator)

1
vector<type>

represents a dynamically managed away, which has variable length and random access, but can only quickly add items at the end.
表示一种动态管理的数据结构，具有可变长度和随机访问，但只能快速在末尾添加项目。

• Unlike a deque, a vector is stored contiguously in memory, which means accessing it is faster – but when it expands, it has to be reallocated and moved, which can be slow.
• 与 deque 不同，向量在内存中连续存储，这意味着访问它更快——但当它扩展时，它必须重新分配并移动，这可能会很慢。

1
#include <vector>
2
#include <iostream>
3
#include <string>
4
int main() {
5
    std::vector<std::string> names;
6
    names.resize(4);
7
    names[0] = "Bob"; names[1] = "Sid";
8
    names[2] = "Jane"; names[3] = "Andrea";
9
    auto iter = names.begin();
10
// "auto" represent iter can be any object type, Not know the type until begin()
11
return something
12
    std::cout << (*iter);
13
    iter+=2;
14
    std::cout << (*iter);
15
    return 0;
16
}

1
#include <iostream>
2
#include <list>
3
#include <string>
4
int main() {
5
    std::list<std::string> names;
6
    names.clear();
7
    names.push_back("Bob");
8
    names.push_back("Sid");
9
    names.push_back("Jane");
10
    names.push_back("Andrea");
11
    // Constantly inserting elements at the end of the list
12
    auto iter = names.begin();
13
    std::cout << (*iter);
14
    iter++;
15
    iter++;
16
    std::cout << (*iter);
17
    return 0;
18
}

1
set<type>

1
multiset<type>

1
map<type, type>

1
multimap<type, type>

1
for(int *x: names) {
2
    cout << *x;
3
}

Smart pointers#

• Another templated feature provided in modern C++ is smart pointers.
• 现代 C++提供的另一个模板化特性是智能指针。
• Smart pointers attempt to solve the problem of accidental memory leaks by automatically destroying the object pointed to when no pointer to it is held.
• 智能指针试图通过在没有任何指针持有该对象时自动销毁指向的对象来解决意外内存泄漏的问题。

Burn after reading 阅后即焚

• However, without Java-style reflection this process is not completely transparent.
• 然而，没有 Java 风格的反射，这个过程并不完全透明。

1
#include <iostream>
2
class Test {
3
public:
4
    Test();
5
    void DoSomething();
6
    ~Test();
7
};
8
Test::Test() {
9
    std::cout << "Created." << std::endl;
10
}
11
Test::~Test() {
12
    std::cout << "Destroyed." << std::endl;
13
}
14
void Test::DoSomething(){
15
    std::cout << "Doing something." << std::endl;
16
}
17
void DoSomething(Test *t){
18
    t->DoSomething();
19
}
20
int main() {
21
    Test *t = new Test();
22
    DoSomething(t);
23
    return 0;
24
}

1
Created.
2
Doing something.

1
int main() {
2
    std::unique_ptr<Test> t(new Test());
3
}

1
#include <iostream>
2
#include <memory>
3
class Test {
4
public:
5
    Test();
6
    void DoSomething();
7
    ~Test();
8
};
9
Test::Test() {
10
    std::cout << "Created." << std::endl;
11
}
12
Test::~Test() {
13
    std::cout << "Destroyed." << std::endl;
14
}
15
void Test::DoSomething(){
16
    std::cout << "Doing something." << std::endl;
17
}
18
void DoSomething(Test *t){
19
    t->DoSomething();
20
}
21
int main() {
22
    std::unique_ptr<Test> t(new Test());
23
    DoSomething(t.get());
24
    return 0;
25
}

1
Created.
2
Doing something.
3
Destroyed.

How unique_ptr works#

• When you create an object by reference, instead of storing the address in a pointer, you store it inside a unique_ptr object which is created by value. (A unique_ptr object is the same size as a regular pointer, so there is no overhead in storing it by value.)
• 当你通过引用创建一个对象时，不是将地址存储在指针中，而是将其存储在通过值创建的 unique_ptr 对象内部。（unique_ptr 对象的大小与常规指针相同，因此通过值存储时没有开销。）
• Because the unique_ptr is created by value, the compiler automatically deletes it when it goes out of scope, which runs its destructor.
• 由于 unique_ptr 是通过值创建的，当它超出作用域时，编译器会自动删除它，这会调用其析构函数。
• The unique_ptr’s destructor deletes the object it points to.
• unique_ptr 的析构函数会删除它所指向的对象。
• This means that an object referred to by a unique_ptr can be passed around by address in the usual way, but will also be automatically deleted when the pointer goes out of scope.
• 这意味着可以通过地址以通常的方式传递由 unique_ptr 指向的对象，但指针超出作用域时，对象也会自动被删除。

Managing a unique_ptr#

• As the name implies, a unique_ptr must be unique. You must not copy a unique_ptr nor construct any other unique_ptr to the same object.
• 正如其名所示，unique_ptr 必须是唯一的。您不能复制 unique_ptr，也不能为同一对象构造任何其他 unique_ptr。
• If you do, the object will be destroyed as soon as either unique_ptr goes out of scope.
• 如果这样做，对象将在任一 unique_ptr 超出作用域时立即被销毁。
• Calling the get method on a unique_ptr will retrieve a regular pointer to the same object. You can pass this to functions, etc, which accept transput parameters.
• 调用 unique_ptr 的 get 方法将检索到同一对象的普通指针。您可以将其传递给接受 transput 参数的函数等。
• However, if you store that pointer (eg, by putting it in a global list or object) then you must be aware that the pointer could become invalid if the original unique_ptr goes out of scope.
• 然而，如果您将那个指针存储起来（例如，将其放入全局列表或对象中），那么您必须意识到，如果原始 unique_ptr 超出作用域，该指针可能会变得无效。

Shared_ptr#

1
auto sp = std::make_shared<Test>(); //safe way
2
shared_ptr<Test> sp1(new Test()); //unsafe way

• This will create a smart pointer of type shared_ptr. This form of smart pointer can identify when it is copied, and will keep track of how many copies are made and destroy the target object only when all copies are removed.
• 这将创建一个类型为 shared_ptr 的智能指针。这种智能指针可以识别何时被复制，并跟踪复制了多少次，只有当所有副本都被移除时才会销毁目标对象。
• However, doing this does create a performance overhead. Also, you must take care to only make copies of a shared pointer once you have created it, not to create another shared pointer for the same resource.
• 然而，这样做确实会产生性能开销。此外，您必须注意，一旦创建了共享指针，就只应复制一次，不要为同一资源创建另一个共享指针。
• It may be better to use manual memory management for more complex cases where shared_ptr’s internal management is not necessary.
• 对于共享_ptr 内部管理不必要且更复杂的场景，可能更适合使用手动内存管理。

Example: Shared_ptr