函数模板与类模板

c++ 函数模板与类模板

（1）为什么需要函数模板与类模板？实现机理？

解决因参数类型不同导致，重复定义相似的函数或者类。

函数模板并不是定义一个函数，使其可以兼容各种类型，而是通过两次编译的方式，根据不同参数调用生成多个不同数据类型的函数或者是类；可以通过查看汇编代码验证；

模板的本质是数据类型参数化。

（2）模板函数与普通函数发生重载；

模板函数遵循严格的参数类型匹配，普通函数支持隐式类型转换；如果普通函数均能够完全匹配则优先调用普通函数。

（3）static 关键字与类模板

类模板不同的参数类型具现化后，属于不同的函数；比如int 与float具现化两个不同的函数，对应static 的变量当然没有什么关系；如果具现化后为同一个类 ，则static为同一变量。

(4) 基本语法

具体注意细节看如下代码的注释

//Test.h
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

template<typename T>
class Point
{
	friend ostream& operator<< <T> (ostream& out, Point<T>& p1); //注意此处语法，
                                                                 //声明时多了个<T>
                                                                 //一般输入输出用友元函数
public:
	Point(T x, T y);
	~Point();
	Point<T> operator+(const Point<T>& p1);
	

	T m_x;
	T m_y;
};

#include "Test.h"
template<typename T>
Point<T>::Point(T x, T y)
{
	m_x = x;
	m_y = y;
}

template<typename T>
Point<T>::~Point() {}

//注意3个地方加上<T> 即：参数，返回值，名称
template<typename T>
Point<T> Point<T>::operator+(const Point<T>& p1)
{
	//下面函数内部Point<T>可以不写<T>
	//Point<T> temp(this->m_x + p1.m_x, this->m_y + p1.m_y);
	Point temp(this->m_x + p1.m_x, this->m_y + p1.m_y);
	return temp;
}

template<typename T>
ostream& operator<< (ostream& out, Point<T>& p1) //友元函数为全局函数无需加类作用符号
{
	out << "Point.m_x=" << p1.m_x << "   Point.m_y=" << p1.m_y << endl;
	return out;
}

#include <iostream>
#include <vector>
//#include "Test.cpp"  此处必须包含cpp才可以正常调用，所以一般都将.h文件与.cpp 合二为一.hpp
#include"Test.h"
using namespace std;


int main()
{
	Point<int> p1 = Point<int>(1, 2);

	Point<int> p2 = Point<int>(3, 4);

	Point<int> p3 = p1 + p2;
	cout << p3;
	system("pause");
	return 0;

}

//Test.hpp
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

template<typename T>
class Point
{
	friend ostream& operator<< <T> (ostream& out, Point<T>& p1);
public:
	Point(T x, T y);
	~Point();
	Point<T> operator+(const Point<T>& p1);
	

	T m_x;
	T m_y;
};


template<typename T>
Point<T>::Point(T x, T y)
{
	m_x = x;
	m_y = y;
}

template<typename T>
Point<T>::~Point() {}

//注意3个地方加上<T> 即：参数，返回值，名称
template<typename T>
Point<T> Point<T>::operator+(const Point<T>& p1)
{
	//下面函数内部Point<T>可以不写<T>
	//Point<T> temp(this->m_x + p1.m_x, this->m_y + p1.m_y);
	Point temp(this->m_x + p1.m_x, this->m_y + p1.m_y);
	return temp;
}

template<typename T>
ostream& operator<< (ostream& out, Point<T>& p1)
{
	out << "Point.m_x=" << p1.m_x << "   Point.m_y=" << p1.m_y << endl;
	return out;
}