C++ —— 模板类与函数

模板类可以用于函数的参数和返回值，有三种形式：

• 普通函数，参数和返回值是模板类的实例化版本。
• 函数模板，参数和返回值是某种的模板类。
• 函数模板，参数和返回值是任意类型（支持普通类和模板类和其它类型）。

示例代码如下：

#include <iostream>
using namespace std;

template <class T1, class T2>
class AA {
public:
    T1 m_x;
    T2 m_y;
    AA(const T1 x, const T2 y): m_x(x), m_y(y) {}
    void show() {cout << "show() m_x = " << m_x << ", m_y = " << m_y << endl;}
};

AA<int, string> func(AA<int, string>& aa) {
    aa.show();
    cout << "调用 func(AA<int, string>& aa)" << endl;
    return aa;
}

int main() {
    AA<int, string> aa(10, "hello");
    func(aa);

    return 0;
}

运行结果如下：

show() m_x = 10, m_y = hello
调用 func(AA<int, string>& aa)

注意事项：

• 不要把AA<int, string>当成模板类，AA<int, string>是一个具体类的类型。
• 类的名字是AA<int, string>，可以传值，也可以传引用。一般传引用。
• func()这个函数，只能处理模板类AA多种数据类型中的一种。

如果想让func()函数支持模板类AA，必须把func()函数变成函数模板。修改后的代码如下：

#include <iostream>
using namespace std;

template <class T1, class T2>
class AA {
public:
    T1 m_x;
    T2 m_y;
    AA(const T1 x, const T2 y): m_x(x), m_y(y) {}
    void show() {cout << "show() m_x = " << m_x << ", m_y = " << m_y << endl;}
};

AA<int, string> func(AA<int, string>& aa) {
    aa.show();
    cout << "调用普通函数版本 func(AA<int, string>& aa)" << endl;
    return aa;
}

// 模板类AA有2个通用类型参数，模板函数也用2个通用类型参数。
// 再把函数中具体的数据类型用T1和T2替换即可
template <typename T1, typename T2>
AA<T1, T2> func(AA<T1, T2>& aa) {
    aa.show();
    cout << "调用模板函数版本 func(AA<T1, T2>& aa)" << endl;
    return aa;
}

int main() {
    AA<int, string> aa(123, "你好！");
    func(aa);
    // AA<string, string> aa("qwer", "hello");
    // func(aa);

    return 0;
}

当普通版本跟模板函数版本都可与实参匹配上时，将优先使用普通函数，运行结果如下：

show() m_x = 123, m_y = 你好！
调用普通函数版本 func(AA<int, string>& aa)

main()函数改成这样，则使用模板函数版本，代码如下：

int main() {
    // AA<int, string> aa(123, "你好！");
    // func(aa);
    AA<string, string> aa("qwer", "hello");
    func(aa);

    return 0;
}

运行结果如下：

show() m_x = qwer, m_y = hello
调用模板函数版本 func(AA<T1, T2>& aa)

在函数中，如果要发挥模板类通用性的特点，必须结合模板函数。再修改一下代码：

#include <iostream>
using namespace std;

template <class T1, class T2>
class AA {
public:
    T1 m_x;
    T2 m_y;
    AA(const T1 x, const T2 y): m_x(x), m_y(y) {}
    void show() {cout << "show() m_x = " << m_x << ", m_y = " << m_y << endl;}
};

template <typename T>
T func(T& aa) {
    aa.show();
    cout << "调用模板函数版本 func(T& aa)" << endl;
    return aa;
}

int main() {
    AA<string, string> aa("qwer", "hello");
    func(aa);

    return 0;
}

运行结果如下：

show() m_x = qwer, m_y = hello
调用模板函数版本 func(T& aa)

T func(T& aa) 这种才是正规的写法，因为这种方法支持任意模板类型，普通类也支持。在函数中用到了对象的show()方法，那么只要对象有show()方法，它都支持。而AA<T1, T2> func(AA<T1, T2>& aa)这个版本只支持AA这一种模板类。
示例代码1：

#include <iostream>
using namespace std;

template <class T1, class T2>
class AA {
public:
    T1 m_x;
    T2 m_y;
    AA(const T1 x, const T2 y): m_x(x), m_y(y) {}
    void show() {cout << "show() m_x = " << m_x << ", m_y = " << m_y << endl;}
};

class BB {
public:
    void show() {cout << "调用BB::show()函数" << endl;}
};

template <typename T1, typename T2>
AA<T1, T2> func(AA<T1, T2>& aa) {
    aa.show();
    cout << "调用模板函数版本 func(AA<T1, T2>& aa)" << endl;
    return aa;
}

template <typename T>
T func(T& aa) {
    aa.show();
    cout << "调用模板函数版本 func(T& aa)" << endl;
    return aa;
}

int main() {
    BB bb;
    func(bb);   

    return 0;
}

运行结果如下：

调用BB::show()函数
调用模板函数版本 func(T& aa)

示例代码2：

#include <iostream>
using namespace std;

void show() {
    cout << "调用普通函数 show()" << endl;
}

class CC {
public:
    void operator() () {
        cout << "调用CC类的仿函数" << endl;
    }
};

template <typename T>
void func(T t) {
    t(); // 调用函数
}

int main() {
    CC cc;
    func(cc); // 在func()函数中，将调用CC类的仿函数

    return 0;
}

运行结果如下：

调用CC类的仿函数

如果func()函数的实参不传bb，用show()函数的函数名，也就是函数指针，代码如下：

int main() {
    func(show); // 在func()函数中，将调用普通函数 show()

    return 0;
}

运行结果如下：

调用普通函数 show()

func()是函数模板，支持任意类型，不管传进去的是什么，只要适应函数中的代码即可。把cc传给func()函数的时候，实参的数据类型是类；传函数名show进去的时候，实参是函数指针。

感谢浏览，一起学习！