C++模板（上）

1、函数模板

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

例如下面这段代码：

template<typename T>  // 模板参数 -- 类型
void Swap(T& x1, T& x2)
{
	T tmp = x1;
	x1 = x2;
	x2 = tmp;
}

int main()
{
	int a = 0, b = 1;
	double c = 1.1, d = 2.2;
	Swap(a, b);
	Swap(c, d);

	//Date d1(2023,5,12), d2(2023, 1, 1);
	return 0;
}

注意：

        函数模板实例化生成具体函数；

        函数模板根据调用，自己推导模板参数的类型，实例化出对应的函数；

template<class T>
T Add(const T& left, const T& right)
{
    return left + right;
}

template<class T>
T* Alloc(int n)
{
    return new T[n];
}

int main()
{
    int a1 = 10, a2 = 20;
    double d1 = 10.1, d2 = 20.2;
    // 实参传递的类型，推演T的类型
    cout << Add(a1, a2) << endl;
    cout << Add(d1, d2) << endl;
    cout << Add(a1, (int)d1) << endl;
    cout << Add((double)a1, d1) << endl;

    // 显示实例化，用指定类型实例化
    cout << Add<int>(a1, d1) << endl;
    cout << Add<double>(a1, d1) << endl;

    // 有些函数无法自动推，只能显示实例化
    double* p1 = Alloc<double>(10);

    return 0;
}

2、类模板

template<class T>
class Stack
{
public:
	Stack(size_t capacity = 3);

	void Push(const T& data);

	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}

private:
	T* _array;
	int _capacity;
	int _size;
};


template<class T>
Stack<T>::Stack(size_t capacity)
{
	/*_array = (T*)malloc(sizeof(T) * capacity);
	if (NULL == _array)
	{
		perror("malloc申请空间失败!!!");
		return;
	}*/
	_array = new T[capacity];

	_capacity = capacity;
	_size = 0;
}

template<class T>
void Stack<T>::Push(const T& data)
{
	// CheckCapacity();
	_array[_size] = data;
	_size++;
}

注意：

        普通类，类名和类型是一样；

        类模板，类名和类型不一样；

         类名：Stack；

         类型：Stack<T>；

3、非类型模板参数

// 静态栈
// 非类型模板参数
// 1、常量
// 2、必须是整形
template<class T, size_t N>
class Stack
{
public:
	void func()
	{
		// 常量，不能修改
		N = 0;
	}
private:
	T _a[N];
	int _top;
};

//template<class T, double N>
//class BB
//{};

int main()
{
	Stack<int, 10> st1; // 10
	Stack<int, 100> st2; // 100

	// 按需实例化(调用了才会实例化)
	//st1.func();

	return 0;
}