c++中类模板中的函数第二种情形：所有函数都在类的外部，但是都在一个cpp文件中

心已赠人 2023-07-12 05:11 8阅读 0赞

针对于所有的函数都在类的外部，但是都在一个cpp文件中的这种情形，只有友元函数的存在是比较特殊和难处理的。

（1） 类中只有成员函数的情况

代码如下，注意代码的书写规则：

#include <iostream>
    using namespace std;
    
    template <typename T>
    class Complex
    {
    public:
    	Complex(T a, T b);
    	void printCom();
    	Complex operator+ (Complex& c2);
    
    private:
    	T	a;
    	T	b;
    };
    
    //构造函数的实现 写在了类的外部
    template <typename T>
    Complex<T>::Complex(T a, T b)
    {
    	this->a = a;
    	this->b = b;
    }
    
    template <typename T>
    void Complex<T>::printCom()
    {
    	cout << "a:" << a << " b: " << b << endl;
    }
    
    //本质是 : 模板是两次 编译生成的 第一次生成的函数头 和第二次生成的函数头 不一样
    //成员函数 实现 +运算符重载
    template <typename T>
    Complex<T>  Complex<T>::operator+ (Complex<T>& c2)
    {
    	Complex tmp(a + c2.a, b + c2.b);
    	return tmp;
    }
    
    
    void main()
    {
    	//需要把模板类 进行具体化以后  才能定义对象  C++编译器要分配内存
    	Complex<int>	c1(1, 2);
    	Complex<int>	c2(3, 4);
    
    	Complex<int> c3 = c1 + c2;
    	c3.printCom();
    		
    	cout << "hello..." << endl;
    	system("pause");
    	return;
    }

（2） 类中不只有成员函数，还存在运算符<<重载的情况

相比于上一段代码，这段代码多了一个函数，即：friend ostream& operator<< <T> (ostream& out, Complex& c3);

（注意，运算符重载中，<<,>>只能重载为全局函数，即友元函数，因为运算符<<,>>操作需要两个操作数，第一个操作数其类型使ostream或者instream, 无法通过this指针隐式传递，而如果重载为成员函数时，第一个操作数是通过this指针隐式传递的）

先看代码：

#include <iostream>
    using namespace std;
    
    template <typename T>
    class Complex
    {
    	friend ostream& operator<< <T> (ostream& out, Complex& c3);  //必须要加<T>,否则编译不通过
    public:
    	Complex(T a, T b);
    	void printCom();
    	Complex operator+ (Complex& c2);
    
    private:
    	T	a;
    	T	b;
    };
    
    //构造函数的实现 写在了类的外部
    template <typename T>
    Complex<T>::Complex(T a, T b)
    {
    	this->a = a;
    	this->b = b;
    }
    
    template <typename T>
    void Complex<T>::printCom()
    {
    	cout << "a:" << a << " b: " << b << endl;
    }
    
    //本质是 : 模板是两次 编译生成的 第一次生成的函数头 和第二次生成的函数头 不一样
    //成员函数 实现 +运算符重载
    template <typename T>
    Complex<T>  Complex<T>::operator+ (Complex<T>& c2)
    {
    	Complex tmp(a + c2.a, b + c2.b);
    	return tmp;
    }
    
    
    template <typename T>
    ostream& operator<<(ostream& out, Complex<T>& c3)
    {
    	out << c3.a << " + " << c3.b << "i" << endl;
    	return out;
    }
    
    void main()
    {
    	//需要把模板类 进行具体化以后  才能定义对象  C++编译器要分配内存
    	Complex<int>	c1(1, 2);
    	Complex<int>	c2(3, 4);
    	Complex<int> c3 = c1 + c2;
    	cout << c3 << endl;	
    	cout << "hello..." << endl;
    	system("pause");
    	return;
    }

c++编译器对类模板中的函数模板进行编译时，会进行两次编译，对于友元函数（不是类的成员）来说，特别容易出现第一次编译时生成的函数头和第二次生成的函数头不一样的情况。对于函数

friend ostream& operator<< <T> (ostream& out, Complex& c3);  来说，加了<T>才能使第一次编译生成的函数头和第二次生成的函数头是一样的。

（3） 相比于上一段代码，这段代码多了一个友元函数，即多了MySub这个普通友元函数，然后就使得代码变得很复杂：

具体看如下代码：

#include <iostream>
    using namespace std;
    
    template <typename T>
    class Complex; //类的前置声明
    template <typename T>
    Complex<T> MySub(Complex<T>& c1, Complex<T>& c2);
    
    
    template <typename T>
    class Complex
    {
    	friend Complex<T> MySub<T>(Complex<T>& c1, Complex<T>& c2);
    	friend ostream& operator<< <T> (ostream& out, Complex& c3);
    
    public:
    	Complex(T a, T b);
    	void printCom();
    	Complex operator+ (Complex& c2);
    
    private:
    	T	a;
    	T	b;
    };
    
    //构造函数的实现 写在了类的外部
    template <typename T>
    Complex<T>::Complex(T a, T b)
    {
    	this->a = a;
    	this->b = b;
    }
    
    template <typename T>
    void Complex<T>::printCom()
    {
    	cout << "a:" << a << " b: " << b << endl;
    }
    
    //本质是 : 模板是两次 编译生成的 第一次生成的函数头 和第二次生成的函数头 不一样
    //成员函数 实现 +运算符重载
    template <typename T>
    Complex<T>  Complex<T>::operator+ (Complex<T>& c2)
    {
    	Complex tmp(a + c2.a, b + c2.b);
    	return tmp;
    }
    
    //友元函数 实现 << 运算符重载
    template <typename T>
    ostream& operator<<(ostream& out, Complex<T>& c3)
    {
    	out << c3.a << " + " << c3.b << "i" << endl;
    	return out;
    }
    
    //滥用 友元函数
    template <typename T>
    Complex<T> MySub(Complex<T>& c1, Complex<T>& c2)
    {
    	Complex<T> tmp(c1.a - c2.a, c1.b - c2.b);
    	return tmp;
    }
    
    
    void main()
    {
    	//需要把模板类 进行具体化以后  才能定义对象  C++编译器要分配内存
    	Complex<int>	c1(1, 2);
    	Complex<int>	c2(3, 4);
    
    	Complex<int> c3 = c1 + c2;
    	cout << c3 << endl;
    
    	//滥用友元函数
    	{
    		Complex<int> c4 = MySub<int>(c1, c2);
    		cout << c4 << endl;
    	}
    	cout << "hello..." << endl;
    	system("pause");
    	return;
    }

总结：

不要滥用友元函数，特别式在类模板(泛型)中。在操作符重载中，应该只将运算符重载为<<,>>重载为友元函数，而将其它运算符重载为成员函数，避免不必要的麻烦。