C++面向对象（OOP）编程-模板

本文主要讲解C++的模板，其中包括模板的分类，函数模板和类模板，以及类模板与友元函数关系引起的几种关系。强调提供代码来搞懂C++模板这一泛型编程手段。

1 C++模板

2 模板的本质

3 模板分类

4 函数模板

4.1 函数模板定义格式

4.2 函数模板的实例化

4.3 函数模板和一般函数的对比

4.4 函数模板使用规则

5 类模板

5.1 类模板定义格式

5.2 类模板的实例化

5.3 类模板使用规则

5.4 类模板与友元函数

5.4.1 非模板友元函数

5.4.2 约束模板友元函数

5.4.3 非约束模板友元函数

5.4.4 三种类模板与友元函数

1 C++模板

C++模板是一种泛型编程技术，它允许程序员编写通用的代码，可以处理不同类型的数据。模板的主要目的是实现代码重用和类型安全。

函数、类以及类继承为程序的代码复用提供了基本手段，还有一种代码复用途径——类属类型（泛型），类型作为参数实现代码的复用。

2 模板的本质

模板是为实现代码复用的一种手段，程序处理的数据有两个基本的特征：值和类型。常规的函数等将值作为参数来进行传递，实现了不同值的改变。由此引入的问题是：是否可以将类型作为参数来传入？这是模板解决的问题。因此，模板的本质是数据类型的参数化。

需要注意的是：一个模板并非一个实实在在的类或函数，仅仅是一个类或函数的描述。

3 模板分类

模板分为函数模板和类模板。

（1）函数模板：函数模板是一个通用的函数，它可以处理不同类型的参数。要定义一个函数模板，需要在函数名后面加上尖括号<>，并在其中放置模板参数。

简单的函数模板的例子：

template <typename T>
void swap(T &a, T &b) {
    T temp = a;
    a = b;
    b = temp;
}

上述例子定义一个模板函数，可以交换不同类型的两个数据。

（2）类模板：类模板是一个通用的类，它可以处理不同类型的数据成员和成员函数。要定义一个类模板，需要在类名后面加上尖括号<>，并在其中放置模板参数。

一个简答的类模板的例子：

template <typename T>
class Stack {
public:
    void push(const T &value);
    T pop();
    T top() const;
    bool empty() const;
private:
    std::vector<T> data;
};

上述例子定义一个Stack类，类中成员和函数的变量的类型是可变的。

4 函数模板

4.1 函数模板定义格式

template <typename 形参名, typename 形参名...>     //模板头（模板说明）

返回值类型函数名（参数列表）                   //函数定义

{

        函数体;

}

（1） template是声明模板的关键字，告诉编译器开始泛型编程。

（2）尖括号<>中的typename是定义形参的关键字，用来说明其后的形参名为类型参数,（模板形参）。Typename（建议用）可以用class关键字代替，两者没有区别。

（3）模板形参（类属参数）不能为空（俗成约定用一个大写英文字母表示），且在函数定义部分的参数列表中至少出现一次。与函数形参类似，可以用在函数定义的各个位置：返回值、形参列表和函数体。

（4）函数定义部分：与普通函数定义方式相同，只是参数列表中的数据类型要使用尖括,号<>中的模板形参名来说明。当然也可以使用一般的类型参数。

template <typename T>
T add(T a, T b)
{
    return (a+b);
}

函数模板的调用使用实参来推演进行

cout << "a+b: " << add(15,34) << endl; // 这是行的，都按照int类型输入

cout << "a+b: " << add(12.3,34.0) << endl; // 这是可行的，都按照double或者float类型输入

cout << "a+b: " << add(12,34.4) << endl;//这是不可行的，两个实参的类型不一样，无法判断

4.2 函数模板的实例化

（1）隐式实例化

形如 add(15,34) 这种就是隐式实例化，根据输入的15和34来推断类型，将模板实例化成一个int类型的函数，然后将实参传入，不能为同一个模板指定两种类型。

代码如下：

#include <iostream>
using namespace std;

/*
    C++模板：
        (1) 函数模板
        (2) 类模板
*/

template <typename T>
T add(T a, T b)
{
    return (a+b);
}

int main (int argc, char *argv[])
{
    cout << "a+b: " << add(12.3,34.0) << endl;
    return 0;
}

运行结果：

（2）显示实例化

形如add<float>(12,34.4) 会指定模板的参数的类型为float，将模板实例化成一个float类型的函数，然后将12 和34.4以float类型输入，可以为同一个模板指定两种不同的类型。

代码如下：

#include <iostream>
using namespace std;

/*
    C++模板：
        (1) 函数模板
        (2) 类模板
*/

template <typename T>
T add(T a, T b)
{
    return (a+b);
}

int main (int argc, char *argv[])
{
    cout << "a+b: " << add<float>(12,34.4) << endl;
    return 0;
}

运行结果：

注意：函数模板仍然支持函数重载，仅仅只是数据类型不确定。

4.3 函数模板和一般函数的对比

两者的区别：函数模板不允许自动类型转化，普通函数则能进行自动类型转换

函数模板和普通函数在一起时的调用规则：

函数模板可以像普通函数一样被重载

C++编译器优先考虑普通函数

如果函数模板可以产生一个更好的匹配，那么选择模板

可以通过空模板实参列表的语法限定编译器只通过模板匹配

4.4 函数模板使用规则

（1）函数模板中的每一个类型参数在函数参数表中必须至少使用一次。

（2）在全局域中声明的与模板参数同名的对象、函数或类型，在函数模板中将被隐藏。即同名的变量在模板中，优先确定为适配模板类型的变量与全局变量没有任何关系。

（3）函数模板中定义声明的对象或类型不能与模板参数同名。

（4）模板参数名在同一模板参数表中只能使用一次，但可在多个函数模板声明或定义之间重复使用。如下：

template <typename T, typename T> //错误，在同一个模板中重复定义模板参数

void fun1(T t1, T t2) { }

template<typename T>

void fun2(T t1) { }

template <typename T> //在不同函数模板中可重复使用相同模板参数名

void fun3(T t3) { }

（5）模板的定义和多处声明所使用的模板参数名不一定要必须相同。如下：

//模板的前向声明

template <typename T>

void func1(T t1,T t2,T t3);

//模板的定义

template <typename U>

void func1(U t1, U t2, U t3)

{

//……

}

（6）函数模板如果有多个模板参数，则每个模板类型前都必须使用关键字typename 或class修饰。例如：

template <typename T, class U> //两个关键字可以混用

void func(T t, U u) { }

template <typename T,U> //错误，每一个模板参数前都要有关键字修饰

void func(T t, U u) { }

5 类模板

5.1 类模板定义格式

template<typename 形参名,typename 形参名…>

class 类名

{

………

}

（1）template类模板中的关键字含义与函数模板相同。

（2）类模板中的类型参数可用在类声明和类实现中。

（3）类模板的模板形参（类型参数）不能为空，一旦声明了类模板就可以用类模板的形参名声明类中的成员变量和成员函数，即在类中使用内置数据类型的地方都可以使用模板形参名来代替。

5.2 类模板的实例化

类模板包含参数，是类的抽象，类模板是类的抽象，类是对象的抽象。

类模板的实例化必须指明数据类型，不支持隐式实例化。

一个例子：

#include <iostream>
#include <string>
using namespace std;

template < class T,class U>
class A
{
    private:
        T t1;
        T t2;
        U name;
    public:
        A(T a, T b): t1(a), t2(b) {cout << "有参构造函数" << endl;}
        T add()
        {
            return (t1+t2);
        }
        T sub();

        void print(U str)
        {
            cout << str << endl;
        }

};

// 类模板成员函数外部定义
template < class T,class U>
T A<T,U>::sub()
{
    return (A<T,U>::t1 - A<T,U>::t2);
}


int main(int argc, char *argv[])
{

    {
        A<int,string> a1(23,45);
        A<int,string> a2(23,45.9);
        cout << "a1->a+b: " << a1.add() << endl;
        cout << "a1->a-b: " << a1.sub() << endl;
        cout << "a2->a+b: " << a2.add() << endl;

        a1.print("Hello Gui Yang Yang!");
         
    }

    return 0;
}

由上述代码可以看到类模板的实例化必须要指明类型参数，并且由于类模板会指定类中成员变量和成员函数的类型，因此，对于调用其中的成员函数时，已经被指定了类型，是显示的调用，不存在类型的推导。

对于类模板外部定义的成员函数，注意要加上类的参数类型。如上述代码中sub()函数

运行结果：

5.3 类模板使用规则

模板的声明或定义只能在全局、命名空间或类范围内进行，不能在局部范围、函数内进行，不能在普通函数或者main函数中声明。声明或定义一个模板还有以下几点需注意：

（1）如果在全局域中声明了与模板参数同名的变量，则该变量被隐藏，优先考虑模板内部。

（2）模板参数名不能被当作类模板定义中类成员的名字。

（3）同一个模板参数名在模板参数表中只能出现一次。

（4）在不同的类模板声明或定义中，模板参数名可以被重复使用。

5.4 类模板与友元函数

5.4.1 非模板友元函数

非模板友元就是在类模板中声明普通的友元函数和友元类。声明的友元函数是一个普通的函数，类型本身不是模板，但是可以传递模板类的参数。

一个例子：

#include <iostream>
using namespace std;
template<typename T>
class Person
{
	T x;
public:
	Person(const T& t)
	{
		x = t;
	}
	friend void log(const Person<T>& a);//有参友元函数
};
void log(const Person<int>& a)//模板形参为int类型（显示具体化）
{
	cout << "int:" << a.x << endl;
}
void log(const Person<double>& a)//模板形参为double类型（显示具体化）
{
	cout << "double:" << a.x << endl;
}
int main()
{
	Person<int> a(10);//创建int类型对象
	log(a);
	Person<double> b(12.5);//创建double类型对象
	log(b);
	return 0;
}

运行结果：

5.4.2 约束模板友元函数

这种友元函数本身就是一个函数模板，但其实例化类型取决于类被实例化时的类型（被约束）。每个类的实例化都会产生一个与之匹配的具体化的友元函数。关键是友元函数本身是模板，类型是与类的类型一致。

一个例子：

#include <iostream>
using namespace std;
//（1）函数模板声明
template<typename T>
void func();
template<typename T>
void show(T& t);
//类模板定义
template <typename U>
class A
{
private:
	U item;
	static int count;
public:
	A(const U& u) :item(u) { count++; }
	~A() { count--; }
	//（2）在类模板中将函数模板声明为类的友元函数
	friend void func<U>();   //友元函数模板
	friend void show<>(A<U>& a);   //友元函数模板
};
template<typename T>
int A<T>::count = 0;     //类A的T类型对象的个数
//（3）友元函数模板的定义
template<typename T>
void func()
{
	cout << "template size: " << sizeof(A<T>) << ";";
	cout << " template func(): " << A<T>::count << endl;
}
template<typename T>
void show(T& t)
{
	cout << t.item << endl;
}
int main()
{
	func<int>();    //调用int类型的函数模板实例，int类型，其大小为	4字节
	A<int> a(10);   //定义类对象
	A<int> b(20);
	A<double> c(1.2);
	show(a);   //调用show()函数，输出类对象的数据成员值
	show(b);
	show(c);
	cout << "func<int> output:\n";
	func<int>();    //运行到此，已经创建了两个int类型对象
	cout << "func<double>() output:\n";
	func<double>();
	return 0;
}

运行结果：

上述代码将func()与show()函数定义成了模板并声明为类的友元，在定义函数模板时是在类外定义的，当调用函数时，func()函数后带有<>说明函数的实例化类型，而show()是直接调用的。

5.4.3 非约束模板友元函数

在类内部声明友元函数模板，友元函数的模板形参与类模板的形参没有联系，此时友元函数为类模板的非约束模板友元函数。就是单独给友元函数定义了新的模板与类的模板的参数没有任何的关系。

一个例子：

#include <iostream>
using namespace std;
template<typename T>
class Person
{
private:
	T item;
public:
	Person(const T& t) :item(t) {}
	template<typename U, typename V>  //在类内部声明函数模板
	friend void show(U& u, V& v);
};
template<typename U, typename V>
void show(U& u, V& v)
{
	cout << u.item << "," << v.item << endl;
}
int main()
{
	Person<int> a(10);
	Person<int> b(20);
	Person<double> c(1.2);
	cout << "a,b: ";
	show(a, b);
	cout << "a,c: ";
	show(a, c);
	return 0;
}

运行结果：