C++:20---类模板(template)

一、类模板与模板类

• 类模板：一个模板（是模板）
• 模板类：调用类模板生成的类对象（是类实体），也称为类模板的实例化

类模板的定义：

• 与函数模板的定义是一样的

1. template <typename T>
2. class Blob
3. {
4. public:
5. Blob();
6. Blob(std::initializer_list<T> i);
7. };

模板类的使用：

• 在定义类时，使用到类名的地方都需要显示的给出模板类的类型，格式为<>

1. int main()
2. {
3. Blob<int> ia;
4. Blob<int> ia2 = { 1,2,3 };
5. Blob<double>* ia4 = new Blob<double>{ 1.1,3.14 };
6. Blob<string> ia3 = { "Hello","World" };
7. 
   
8. return 0;
9. }

二、模板类的成员函数

• 如果模板类的成员函数在类内声明，而在类外定义，需要遵循以下规则：在函数前也在加上模板列表，且类名限定符后面给出<>

1. template <typename T>
2. class Blob
3. {
4. public:
5. Blob();
6. Blob(std::initializer_list<T> i);
7. T func(T const &str);//在类内声明
8. };
9. 
   
10. //类外定义
11. template <typename T>
12. T Blob<T>::func(T const &str)
13. {
15. }

类模板中使用其它模板类型

1. template <typename T> class Blob{
2. template <typename It> Blob(It b, It e);//构造函数的参数使用其它模板类型
3. };
4. 
   
5. template <typename T>
6. template <typename It>
7. Blob<T>::Blob(It b, It e):data(std::make_shared<std::vector<T>>(b,e))
8. {
9. 
   
10. }
11. int main()
12. {
13. vector<long> vi = { 0,1,2 };
14. list<const char*> w = { "Hello","World" };
15. 
    
16. Blob<int> a1(vi.begin(), vi.end());
17. Blob<string> a2(w.begin(), w.end());
18. return 0;
19. }

三、友元：类模板中的友元

• 一个类模板中也可以拥有友元（友元类/友元函数）
• 下面只有当与Blob类型相同的BlobPtr类和operator==函数才可以成为Blob模板类的友元

1. template <typename T> class BlobPtr;
2. template <typename T> class Blob;
3. template <typename T>
4. bool operator==(const Blob<T>&, const Blob<T>&)
5. {
6. 
   
7. }
8. 
   
9. template <typename T> class Blob
10. {
11. friend class BlobPtr<T>; //使BlobPtr模板类成为Blob模板类的友元
12. friend bool operator==(const Blob<T>&, const Blob<T>&);//使operator函数成为Blob模板类的友元
13. };
14. 
    
15. template <typename T> class BlobPtr
16. {
17. };

四、友元：通用和特定的模板友元关系

• 模板有需要复杂的关系，下面列出两个实例

1. template <typename T> class Pal;
2. 
   
3. class C
4. {
5. friend class Pal<C>; //用类C实例化的Pal是C的友元
6. 
   
7. template <typename T> friend class Pal2; //Pal2的所有实例都是C的友元
8. };
9. template <typename T> class C2
10. {
11. friend class Pal<T>; //与C2相同类型的实例化Pal才是C2的友元
12. 
    
13. template <typename X> friend class Pal2;//任何类型实例化的Pal2对象都是C2的友元，因为模板参数列表不同
14. 
    
15. friend class Pal3;//Pal3是一个非模板类，它是所有类型C2实例化的友元
16. };

五、类模板的static成员

• 与任何其他类一样，类模板可以声明static成员
• 例如：下面Foo类模板中定义了一个static函数和static变量

1. template <typename T> class Foo
2. {
3. public:
4. static std : size_t count() { return ctr; }
5. private:
6. static std::size_t ctr;
7. };

• 因为类的static成员变量只可在类内定义，在类外初始化。所以模板来的static变量也要在类外初始化，初始化时需要加上模板参数列表，例如下面代码，当一个特定的模板实例化Foo时，其ctr被初始化为0

8. template <typename T>
9. std::size_t Foo<T>::ctr = 0; //定义并初始化

• 静态成员的调用

10. Foo<int> fi; //实例化Foo<int>类和static数据成员ctr
11. auto ct=Foo<int>::count();//实例化Foo<int>::count
12. ct=fi.count(); //使用Foo<int>::count，与上面的意义是相同
13. ct=Foo::count(); //错误，Foo没有指出使用哪个模板实例化

• 类模板的static成员的特点：当一个类给出模板实例化之后，与这个类实例化类型相同的类共享一样的静态成员

Foo<int> f1,f2,f3; //f1,f2,f3共享Foo<int>::count()和Foo<int>::str

六、使用类的类型成员（::符号）

引入：

• 当我们通过作用域符访问的名字是类型还是static成员，编译器会自动识别，例如：

string::size_type //编译器知道我们要访问string类中的size_type数据类型

• 但是对于模板就不能使用这种方法了，例如：

1. //编译器不知道size_type是一个static数据成员还是一种数据类型，因此产生二义性
2. T::size_type * p;

• 默认情况下，C++语言假定通过作用域运算符访问的名字不是数据类型，而是数据成员。所以如果我们希望使用一个模板类型参数的类型成员，就必须显式地告诉编译器改名字是一个类型。需要通过typename来实现这一点
• 例如下面的top函数：

1. template<typename T>
2. typename T::value_type top(const T&c)
3. {
4. if (!c.empty())
5. return c.back();
6. else
7. return typename T::value_type();
8. }

七、成员模板

• 一个类可以包含模板类型的成员函数，这种成员称为“成员模板”
• 注意：成员模板不能为虚函数

①普通（非模板）类的成员模板

• 概念：我们可以在一个非模板类中定义一个成员模板

演示案例

• 默认的情况下，unique_ptr会调用元素的析构函数来删除元素。下面我们定义了一个删除器，删除器使用operator()接收一个元素指针，并将该元素进行delete

1. //函数对象类，对给定指针执行delete
2. class DebugDelete
3. {
4. public:
5. DebugDelete(std::ostream &s=std::cerr):os(s){} //构造函数
7. //根据传入的参数进行delete
8. template <typename T>
9. void operator()(T* p)const //成员模板
10. {
11. os << "deleting unique_ptr" << endl;
12. delete p;
13. }
14. private:
15. std::ostream &os;
16. };

• 下面是基本的使用格式：

1. int main()
2. {
3. double *p = new double;
4. DebugDelete d;
5. d(p); //调用DebugDelete::operator()(double*)释放p
6. 
   
7. int *ip = new int;
8. DebugDelete()(ip); //在一个临时DebugDelete对象上调用operator()(int*)
9. 
   
10. return 0;
11. }

• 下面我们将这个类作为unique_ptr的删除器来使用

1. int main()
2. {
3. //一个类型为int的unique_ptr对象，DebugDelete作为其删除器
4. unique_ptr<int, DebugDelete> p(new int, DebugDelete());
5. 
   
6. //一个类型为string的unique_ptr对象，DebugDelete作为其删除器
7. unique_ptr<std::string, DebugDelete> sp(new std::string, DebugDelete());
8. 
   
9. return 0;
10. }

②类模板的成员模板

• 概念：对于类模板，我们也可以为其定义成员模板。在此情况下，类和成员各自有自己的、独立的模板参数

演示案例

• 例如下面Blob是一个类模板，模板类型为T数据成员vector的类型也为T。另外其构造函数也是一个模板，其接受的模板类型为It

1. template<typename T>
2. class Blob {
3. public:
4. template<typename It>
5. Blob(It b, It e); //构造函数接受一个迭代器区间，用来初始化data
6. private:
7. std::vector<T> data;
8. };

• 现在我们在类的外部定义构造函数，由于类模板与成员函数都是模板，因此在外部定义时需要分别同时给出这两个模板的模板参数列表
• 实例化成员模板：为了实例化一个类模板的成员模板，我们必须同时提供类和函数模板的实参。见下面的演示案例，其中：

• a1：Blob的类型为int，构造函数的类型为int*
• a2：Blob的类型为int，构造函数的类型为vector<long>::iterator
• a3：Blob的类型为string，构造函数的类型为list<const char*>::iterator