c++模板

一，泛型编程

先来看一个问题：
写一个通用的加法函数，适用任何类型？
看到这个问题，我们首先想到的是函数重载；

int ADD(int a, int b)
{
	return a + b;
}

double ADD(double a, double b)
{
	return a + b;
}

char ADD(char a, char b)
{
	return a + b;
}

int main()
{
	ADD(1, 2);
	ADD(1.0, 2.0);
	ADD('a', 'b');
	system("pause");
	return 0;

}

结论：函数重载可以实现通用,但是有以下的缺点
1,代码的复用率低,只要有不同的类型出现,就必须提供相应的函数
2.不容易维护,一个地方出错可能所有的重载函数都要改
所以函数重载在这里不适合解决这个问题，这就引出了c++中的模板。
泛型编程：编写一个与类型无关的代码，代码复用的一种方式。

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

1.函数模板

	template<class T>
	T ADD(T a, T b)
	{
		return a + b;
	}
	int main()
{
	 ADD(1 , 2);
	 ADD(1.0, 2.0);
	 ADD(1, (int)2.0);
	cout<< ADD<int>(1.0, 3.0)<<endl;//显示实例化
	system("pause");
	return 0;
}

函数模板处理过程：
1.编译器根据实参推演出相应类型的函数
2.调用函数
注意：函数模板不是真正的函数，是编译器生成代码的规则。

2.模板函数的匹配规则：

1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。
   函数模板还可以被实例化为这个非模板函数，两个函数共同存在的原因：
   普通函数 ：int ADD(int a, int b)
   由函数模板实例化的函数：int < int >ADD(int a, int b)

int ADD(int a, int b)
{
	return a + b;
}

template< class T >
T ADD(T a, T b)
{
	return a + b;
}

int main()
{
	ADD(1.0, 2.0);
	system("pause");
	return 0;
}

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

int ADD(int a, int b)
{
	return a + b;
}

template<class T1,class T2>
T1 ADD(T1 a, T2 b)
{
	return a + b;
}
int main()
{
	cout<<ADD(1, 2.0)<<endl;//编译器会选择函数模板
	ADD(1.0, 2.0);
	system("pause");
	return 0;
}

3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

int ADD(int a, int b)
{
	return a + b;
}

template< class T >
T ADD(T a, T b)
{
	return a + b;
}

int main()
{
	cout<<ADD(1, 2.0)<<endl;//不能自动类型转化
	ADD(1.0, 2.0);
	system("pause");
	return 0;
}

2.类模板

	template<class T>

class SeqList
{
public:
	SeqList(int capacity=10)
		:_array(new T[capacity]),
		 _capacity(capacity),
		 _size(0)
	{}
	~SeqList()
	{
		if (_array)
		{
			delete[] _array;
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
	void PushBack(T data);
	void PopBack();
	void checkCapacity()
	{
		if (_size == _capacity)
		{
			//申请新空间
			size_t newcapacity = _capacity * 2;
			T* str = new T[newcapacity];
			//拷贝原空间的内容到新空间中
			memcpy(str, _array, sizeof(T)*_size);
			//释放原空间，并将原空间指向新空间地址
			delete[] _array;
			_array = nullptr;
			_array = str;
			//更新容量为新容量
			_capacity = newcapacity;
		}
	}

	T& operator[](size_t data)
	{
		assert(data < _size);
		return _array[data];
	}
	//左边const修饰函数返回值,表明函数返回值不可被修改
	//右边const修饰的是该成员函数内隐含的this指针,表明在该成员函数内不能对类的任何成员进行修改
	const T& operator[](size_t data) const
	{
		assert(data < _size);
		return _array[data];
	}
	size_t Size()
	{
		return _size;
	}
private:
	T* _array;
	size_t _capacity;
	size_t _size;
};

template<class T>
void SeqList<T>::PushBack(T data)
{
	checkCapacity();
	_array[_size++] = data;
}
template<class T>
void SeqList<T>::PopBack()
{
	_size--;
}
int main()
{
	SeqList<int> s;
	s.PushBack(1);
	s.PushBack(2);
	s.PushBack(3);
	s.PushBack(4);
	cout << s[1] << endl;
	s[1] = 20;
	cout << s[1] << endl;
	cout << s.Size() << endl;
	s.PopBack();
	s.PopBack();
	cout << s.Size() << endl;
	system("pause");
	return 0;
}