标签：函数 int void 编程 C++ Swap template 泛型模板

1. 函数模板

假设我们设计一个交换两个整型变量的值的函数，代码如下：

// 交换两个整型变量的值的Swap函数：
void Swap(int & x,int & y)
{
    int tmp = x;
    x = y;
    y = tmp;
}

如果是浮点类型的变量的值交换，则替换 int 类型为 double 即可，代码如下：

// 交换两个double型变量的值的Swap函数:
void Swap(double & x,double & y)
{
    double tmp = x;
    x = y;
    y = tmp;
}

那如果是其他变量类型的值交换，那不是每次都要重新写一次 Swap 函数？是不是很繁琐？且代码后面会越来越冗余。

能否只写一个 Swap 函数，就能交换各种类型的变量？

答案是肯定有的，就是用「函数模板」来解决，「函数模板」的形式：

template <class 类型参数1，class 类型参数2，...>
返回值类型 模板名 (形参表)
{
    函数体
};

具体 Swap 「函数模板」代码如下：

template 就是模板定义的关键词，T 代表的是任意变量的类型。

template <class T>
void Swap(T & x,T & y)
{
    T tmp = x;
    x = y;
    y = tmp;
}

那么定义好「函数模板」后，在编译的时候，编译器会根据传入 Swap 函数的参数变量类型，自动生成对应参数变量类型的 Swap 函数：

int main()
{
    int n = 1,m = 2;
    Swap(n,m); //编译器自动生成 void Swap(int & ,int & )函数

    double f = 1.2,g = 2.3;
    Swap(f,g); //编译器自动生成 void Swap(double & ,double & )函数

    return 0;
}

上面的实例化函数模板的例子，是让编译器自己来判断传入的变量类型，那么我们也可以自己指定函数模板的变量类型，具体代码如下：

int main()
{
    int n = 1,m = 2;
    Swap<int>(n,m);     // 指定模板函数的变量类型为int

    double f = 1.2,g = 2.3;
    Swap<double>(f,g);  // 指定模板函数的变量类型为double

    return 0;
}

2. 多个类型参数模板函数

函数模板中，可以不止一个类型的参数：

template <class T1, class T2>
T2 MyFun(T1 arg1, T2 arg2)
{
    cout<< arg1 << " "<< arg2<<endl;
    return arg2;
}

T1 是传入的第一种任意变量类型，T2 是传入的第二种任意变量类型。

3. 函数模板的重载

函数模板可以重载，只要它们的形参表或类型参数表不同即可。

// 模板函数 1
template<class T1, class T2>
void print(T1 arg1, T2 arg2) 
{
    cout<< arg1 << " "<< arg2<<endl;
}

// 模板函数 2
template<class T>
void print(T arg1, T arg2) 
{
    cout<< arg1 << " "<< arg2<<endl;
}

// 模板函数 3
template<class T,class T2>
void print(T arg1, T arg2) 
{
    cout<< arg1 << " "<< arg2<<endl;
}

上面都是 print(参数1, 参数2) 模板函数的重载，因为「形参表」或「类型参数表」名字不同。

4. 函数模板的调用次序

在有多个函数和函数模板名字相同的情况下，编译器如下规则处理一条函数调用语句：

先找参数完全匹配的普通函数（非由模板实例化而得的函数）；
再找参数完全匹配的模板函数；
再找实参数经过自动类型转换后能够匹配的普通函数；
上面的都找不到，则报错。

5. 类模板

为了多快好省地定义出一批相似的类,可以定义「类模板」，然后由类模板生成不同的类。

类模板的定义形式如下：

template <class 类型参数1，class 类型参数2，...> //类型参数表
class 类模板名
{
   成员函数和成员变量
};

用类模板定义对象的写法：

类模板名<真实类型参数表> 对象名(构造函数实参表);

pair类模板实例：

// 类模板
template <class T1, class T2>
class Pair
{
public:
    Pair(T1 k, T2 v):m_key(k),m_value(v) {};
    bool operator < (const Pair<T1,T2> & p) const;
private:
    T1 m_key;
    T2 m_value;
};

// 类模板里成员函数的写法
template <class T1, class T2>
bool Pair<T1,T2>::operator < (const Pair<T1,T2> &p) const
{
    return m_value < p.m_value;
}

int main()
{
    Pair<string,int> Astudent("Jay",20); 
    Pair<string,int> Bstudent("Tom",21);

    cout << (Astudent < Bstudent) << endl;

    return 0;
}

类模板中可以定义静态成员，那么从该类模板实例化得到的所有类，都包含同样的静态成员。
类模板在使用的时候，没有自动类型推导的方式(函数模板有)。
类模板在模板参数列表中可以有默认参数类型，函数模板也可以（只不过全特化成立函数重载）。

类模板成员函数创建时机：

普通类中的成员函数，在一可以就可以创建；
类模板中的成员函数，在函数调用时才创建；

当类模板碰到继承时：

当子类继承的父类是一个类模板时，子类在声明时要指定父类 T 的类型；
如果不指定，编译器就无法给子类分配内存；

要想灵活指定父类中 T 的类型，子类也必须为类模板；

template<class T1 , class T2>
class 子类：继承方式 父类<T2>
{
	//T1 通用类型留给子类自己用
}

类模板成员函数的类外实现：

类内声明，类外写函数定义
类外写函数时，作用域需要加上模板参数列表

template<class T>

返回值类型 作用域<T>::成员函数()
//作用域要加上模板参数列表<T>，不管传参和函数内部有没有用到 T ，<T> 都要写出来
{

}

6. 函数模板作为类模板成员

当函数模板作为类模板的成员函数时，是可以单独写成函数模板的形式，成员函数模板在使用的时候，编译器才会把函数模板根据传入的函数参数进行实例化，例子如下：

// 类模板
template <class T>
class A
{
public:
    template<class T2>
    void Func(T2 t) { cout << t; } // 成员函数模板
};

int main()
{
    A<int> a;
    a.Func('K');     //成员函数模板 Func被实例化
    a.Func("hello"); //成员函数模板 Func再次被实例化

    return 0;
}

7. 类模板与非类型参数

类模板的“<类型参数表>”中可以出现非类型参数：

template <class T, int size>
class CArray
{
public:
    void Print( )
    {
        for( int i = 0;i < size; ++i)
        cout << array[i] << endl;
    }
private:
    T array[size];
};

CArray<double,40> a2;
CArray<int,50> a3; //a2和a3属于不同的类

8. 函数模板做类模板友元

// 类模板
template <class T1,class T2>
class Pair
{
private:
    T1 key;   //关键字
    T2 value; //值
public:
    Pair(T1 k,T2 v):key(k),value(v) { };

    // 友元函数模板
    template <class T3,class T4>
    friend ostream & operator<< (ostream & o, const Pair<T3,T4> & p);
};

// 函数模板
template <class T3,class T4>
ostream & operator<< (ostream & o, const Pair<T3,T4> & p)
{
    o << "(" << p.key << "," << p.value << ")" ;
    return o;
}

int main()
{
    Pair<string,int> student("Tom",29);
    Pair<int,double> obj(12,3.14);

    cout << student << " " << obj;
    return 0;
}

9. 函数模板做类的友元

// 普通类
class A
{
private:
    int v;
public:
    A(int n):v(n) { }

    template <class T>
    friend void Print(const T & p); // 函数模板
};

// 函数模板
template <class T>
void Print(const T & p)
{
    cout << p.v;
}

int main() 
{
    A a(4);
    Print(a);
    return 0;
}

10. 类模板作为类模板的友元

// 类模板
template <class T>
class B 
{
private:
    T v;
public:
    B(T n):v(n) { }

    template <class T2>
    friend class A; // 友元类模板
};

// 类模板
template <class T>
class A 
{
public:
    void Func( )  
    {
        B<int> o(10); // 实例化B模板类
        cout << o.v << endl;
    }
};

int main()
{
    A<double> a;
    a.Func ();
    return 0;
}

标签：函数,int,void,编程,C++,Swap,template,泛型,模板
From： https://www.cnblogs.com/love-9/p/18084706

C++ 泛型编程