C++函数模板与类模板实例解析

最新推荐文章于 2023-07-27 11:34:14 发布

weixin_33882443

最新推荐文章于 2023-07-27 11:34:14 发布

阅读量64

点赞数

文章标签： c/c++ python

原文链接：https://my.oschina.net/ray1421/blog/686345

版权

2019独角兽企业重金招聘Python工程师标准>>>

这篇文章主要介绍了C++函数模板与类模板,需要的朋友可以参考下

本文针对C++函数模板与类模板进行了较为详尽的实例解析，有助于帮助读者加深对C++函数模板与类模板的理解。具体内容如下：

泛型编程（Generic Programming）是一种编程范式，通过将类型参数化来实现在同一份代码上操作多种数据类型，泛型是一般化并可重复使用的意思。泛型编程最初诞生于C++中，目的是为了实现C++的STL（标准模板库）。

模板（template）是泛型编程的基础，一个模板就是一个创建类或函数的蓝图或公式。例如，当使用一个vector这样的泛型类型或者find这样的泛型函数时，我们提供足够的信息，将蓝图转换为特定的类或函数。

一、函数模板

一个通用的函数模板（function template）就是一个公式，可用来生成针对特定类型或特定值的函数版本。模板定义以关键字template开始，后面跟一个模板参数列表，列表中的多个模板参数（template parameter）以逗号分隔。模板参数表示在类或函数定义中用到的类型或值。

1、类型参数

一个模板类型参数（type parameter）表示的是一种类型。我们可以将类型参数看作类型说明符，就像内置类型或类类型说明符一样使用。类型参数前必须使用关键字class 或typename：

template <typename T> // typename和class一样的 
T function(T* p) 
{ 
  T tmp = *p;  // 临时变量类型为T 
  //... 
  return tmp;  // 返回值类型为T 
}

关键字typename和class是一样的作用，但显然typename比class更为直观，它更清楚地指出随后的名字是一个类型名。

编译器用模板类型实参为我们实例化（instantiate）特定版本的函数，一个版本称做模板的一个实例（instantiation）。当我们调用一个函数模板时，编译器通常用函数实参来为我们推断模板实参。当然如果函数没有模板类型的参数，则我们需要特别指出来：

注：要注意template函数模板参数并不一定会出现在函数的参数列表中，但一般会在函数中使用。这里说“如果函数没有模板类型的参数”,指出模板类型参数的方式则为在函数名后加<类型名>.如下面第三行语句所示。

int a = 10; 
cout << function(&a) << endl;   // 编译器根据函数实参推断模板实参 
 
cout <<  << endl;  // <int>指出模板参数为int

2、非类型参数

在模板中还可以定义非类型参数（nontype parameter），一个非类型参数表示一个值而非一个类型。我们通过一个特定的类型名而非关键字class或typename来指定非类型参数，即在模板参数表中指定函数中可能会用到的一些变量：

// 整形模板 
template<unsigned M, unsigned N>    //下面有提到”
void add() 
{ 
  cout<< M+N << endl; 
} 
 
// 指针 
template<const char* C>       //这里并不介绍以某种指针类型作为模板参数，而是以一个指针变量作为模板非类型参数，那为何不直接将其作为参数放在参数列表中。
void func1(const char* str) 
{ 
  cout << C << " " << str << endl;    //通过这条语句可以充分说明C是一个变量，而不是一个类型
} 
 
// 引用 
template<char (&R)[9]> 
void func2(const char* str) 
{ 
  cout << R << " " << str << endl; 
}

//函数指针的所谓类型没有什么意义：通常一个函数指针变量可以指向满足该函数指针要求的返回值类型和参数个数及类型的所有函数，一个函数指针作用于一类函数。
// 函数指针  
template<void (*f)(const char*)>   //函数通常都具有静态的生存期，这里的函数指针是一个实实在在的变量，而不是一个类型。
void func3(const char* c) 
{ 
  f(c); 
} 
 
void print(const char* c) { cout << c << endl;} 
 
char arr[9] = "template";  // 全局变量，具有静态生存期 
 
int main() 
{ 
  add<10, 20>(); 
  func1<arr>("pointer"); 
  func2<arr>("reference"); 
  func3<print>("template function pointer"); 
  return 0; 
}

当实例化时，非类型参数被一个用户提供的或编译器推断出的值所替代。一个非类型参数可以是一个整型，或者是一个指向对象或函数的指针或引用：绑定到整形（非类型参数）的实参必须是一个常量表达式，绑定到指针或引用（非类型参数）的实参必须具有静态的生存期（比如全局变量），不能把普通局部变量或动态对象绑定到指针或引用的非类型形参。

二、类模板

相应的，类模板（class template）是用来生成类的蓝图。与函数模板的不同之处是，编译器不能为类模板推断模板参数类型，所以我们必须显式的提供模板实参。与函数模板一样，类模板参数可以是类型参数，也可以是非类型参数，这里就不再赘述了。

template<typename T> 
class Array { 
public: 
  Array(T arr[], int s); 
  void print(); 
private: 
  T *ptr; 
  int size; 
}; 
 
// 类模板外部定义成员函数 
template<typename T> 
Array<T>::Array(T arr[], int s) 
{ 
  ptr = new T[s]; 
  size = s; 
  for(int i=0; i<size; ++i) 
    ptr[i]=arr[i]; 
} 
 
template<typename T> 
void Array<T>::print() 
{ 
  for(int i=0; i<size; ++i) 
    cout << " " << *(ptr+i); 
  cout << endl; 
} 
 
int main() 
{ 
  char a[5] = {'J','a','m','e','s'}; 
  Array<char> charArr(a, 5); 
  charArr.print(); 
 
  int b[5] = { 1, 2, 3, 4, 5}; 
  Array<int> intArr(b, 5); 
  intArr.print(); 
 
  return 0; 
}

类模板的成员函数

与其他类一样，我们既可以在类模板内部，也可以在类模板外部定义其成员函数。定义在类模板之外的成员函数必须以关键字template开始，后接类模板参数列表。

template <typename T> 
return_type class_name<T>::member_name(parm-list) { }

默认情况下，对于一个实例化了的类模板，其成员函数只有在使用时才被实例化。如果一个成员函数没有被使用，则它不会被实例化。

注：这里的意思是一个类模板的实例化，并不是一下子将整个类的所有数据成员，成员函数进行实例化，至少对于成员函数是在使用的时候才进行实例化。

类模板和友元

当一个类包含一个友元声明时，类与友元各自是否是模板是相互无关的。

如果一个类模板包含一个非模板的友元，则友元被授权可以访问所有模板的实例。//这也是没有办法的事情，你没有办法在定义友元时就指定该友元类可以访问类模板的哪些实例，毕竟太多了。

如果友元自身是模板，类可以授权给所有友元模板的实例，也可以只授权给特定实例。

// 前置声明，在将模板的一个特定实例声明为友元时要用到 
template<typename T> class Pal;    //一个类里面只要有出现“类型参数”都必须在类定义开始前用template声明，这里的类型参数的声明是和友元类的模板声明放在了一起。 
 
// 普通类 
class C {

//这里的class关键字是将一个类型声明为另一个类的友元时必须有的关键字。参见本段代码后的参考资料。 
  friend class Pal<C>; // 用类C（所在的这个类本身）实例化的Pal是C的一个友元

template<typename T> friend class Pal2; //Pal2所有实例都是C的友元;无须前置声明 
}; 
 
// 模板类 
template<typename T>

class C2 { 
  // C2的每个实例将用相同类型实例化的Pal声明为友元,一对一关系 
  friend class Pal<T>; 
  // Pal2的所有实例都是C2的每个实例的友元，不需要前置声明 
  template<typename X> friend class Pal2;  
  // Pal3是普通非模板类，它是C2所有实例的友元 
  friend class Pal3; 
};

参考资料

友元函数和友元类 - 执迷不悟~ - 博客园
http://www.cnblogs.com/staring-hxs/p/3432161.html

类模板的static成员

类模板可以声明static成员。类模板的每一个实例都有其自己独有的static成员对象，对于给定的类型X，所有class_name<X>类型的对象共享相同的一份static成员实例。

template<typename T> 
class Foo { 
public: 
  void print(); 
  //...其他操作 
private: 
  static int i; 
}; 
 
template<typename T> 
void Foo<T>::print() 
{ 
  cout << ++i << endl; 
} 

template<typename T> 
int Foo<T>::i = 10; // 初始化为10  相关声明中的规则与普通类中差别 不大，不需要再出现static关键字。
 
int main() 
{ 
  Foo<int> f1; 
  Foo<int> f2; 
  Foo<float> f3; 
  f1.print();  // 输出11 
  f2.print();  // 输出12 
  f3.print();  // 输出11 
  return 0; 
}

我们可以通过类类型对象来访问一个类模板的static对象，也可以使用作用域运算符（::）直接访问静态成员。类似模板类的其他成员函数，一个static成员函数也只有在使用时才会实例化。（应该是考虑效率的结果吧！）

转载于:https://my.oschina.net/ray1421/blog/686345