C++模板初阶 -- 懒人必备神器

目录

一、泛型编程

二、模板

1、函数模板 

2、类模板

---

想要偷懒的快到我的碗里来了

一、泛型编程

★ 百度：泛型程序设计（generic programming）是程序设计语言的一种风格或范式。泛型允许程序员在强类型程序设计语言中编写代码时使用一些以后才指定的类型，在实例化时作为参数指明这些类型。

★ 笔者理解：泛型编程是程序设计语言的一种方式，其通过利用一些语法规则、通用模板来简化编写步骤相似的冗余代码，提高代码的复用率，同时也加强了代码的可维护性。(能力有限，仅供参考)

二、模板

★ 泛型程序设计在C++当中被称作模板，下面我们将通过实例来对其进行深入学习理解。

★ 在这之前，如果我们想要实现不同内置类型的操作（比如交换两个变量），我们需要写出不同数据类型所对应的接口来实现，也就是函数重载的方式，代码如下：

void Swap(int& left, int& right)
{
    int temp = left;
    left = right;
    right = temp;
}

void Swap(double& left, double& right)
{
    double temp = left;
    left = right;
    right = temp;
}

void Swap(char& left, char& right)
{
    char temp = left;
    left = right;
    right = temp;
}

既然有了函数重载的方式，那么为什么还要提出泛型编程、模板的概念呢？是否有这样的必要呢？ 答案是肯定的。函数重载虽然可以实现，但它有它的不足：

1) 重载的函数仅仅只是类型不同，代码的复用率比较低，只要有新类型出现时，就需要增加对应的函数。

2) 代码的可维护性比较低，一个出错可能所有的重载均出错。

1、函数模板 

★ 定义

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

★ 函数模板格式

template或者是

template

★ 函数模板的原理

函数模板的出现本质上是为了节省时间，避免开发人员去做重复的复写代码。可以说其本身并不是一个函数，而是一个蓝图，是编译器用使用一定方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。

在编译器编译阶段，对于函数模板的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。

★ 函数模板实例化

上述<>中的 T1、T2...Tn 表示的是与函数实现对应参数的类型，这样说有点抽象，接下来我们通过实例来观察，代码如下：

template
void swap(const T& x, const T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int a = 10, b = 20;
	double i = 10.2, j = 20.3;
	char m = 'A', n = 'B';
	swap(a, b);
	swap(i, j);
	swap(m, n);
	return 0;
}

上诉代码调试结果：

 由此可以看出，我们只是用到了一个模板函数就实现了多种不同类型数据的交换。

我们还可以实现一个基本运算的函数：

template
T1 add(const T1& x, const T2& y)
{
	return x + y;
}

int main()
{
	int a = 10, b = 20;
	double i = 10.2, j = 20.3;
	cout << add(a, b) << endl;
	cout << add(i, j) << endl;
	cout << add(a, i) << endl;
	return 0;
}

代码结果如下：

可能有人会对第三个结果有所疑惑，是的这里我们引用参数的类型并不一样，但为什么还可以呢？

因为这里存在着一个隐士类型的转化，在此函数的情景下会根据返回的类型发生相应的变化。

★ 模板参数的匹配原则

★  一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。
★  对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板。
 

2、类模板

★ 类模板定义格式

template
class 类模板名
{
        // 类内成员定义
};

这里我们举例我们所众知的数据结构栈，在之前对栈的认知当中，一个栈只能存储一种数据类型，虽然我们可以通过 typedef  int  DateType 的方式来简化对存储不同类型数据时的修改内容，但我们如果想要创建多种不同类型的栈时仍需要写出不同的栈的类名结构。代码如下：

typedef int STDataType;
class StackInt
{
public:
	StackInt(int capacity = 4)
		:_top(0)
		, _capacity(capacity)
	{
		_a = new STDataType[capacity];
	}

	~StackInt()
	{
		delete[] _a;
		_a = nullptr;
		_capacity = _top = 0;
	}

private:
	STDataType* _a;
	int _top;
	int _capacity;
};
//
typedef double STDataType;
class StackDouble
{
	...
};

看其中的两个不同类型的栈，是不是发现很容易会造成代码冗余，但有了类模板后，这样的囧囧囧就没了，爽到起飞..........

注意：Stack不是具体的类，是编译器根据被实例化的类型生成具体类的模具

★ 类模板的实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

template
class Stack
{
public:
	Stack(int capacity = 4)
		:_top(0)
		, _capacity(capacity)
	{
		_a = new T[capacity];
	}

	~Stack()
	{
		delete[] _a;
		_a = nullptr;
		_capacity = _top = 0;
	}

	void Push(const T& x);

private:
	T* _a;
	int _top;
	int _capacity;
};

// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template  //不可省略,必须存在
void Stack::Push(const T& x)
{
	cout << "hello world" << endl; // 为了方便调试，没有实现入数据
}

int main()
{
	Stack s1;  // 注意实例化对象时需要声明类型
    Stack s2; 
	s1.Push(1);
	return 0;
}

注意：注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

★★★★★ 感谢阅读！！！