关于友元函数在模板类中使用出现的问题的解决办法及模板的机制

模板类中使用出现的问题的解决办法及模板的机制"/>

关于友元函数在模板类中使用出现的问题的解决办法及模板的机制

模板两大难点：

一、写在用一个文件，但不放在类中

1.友元函数写在类中

template <typename T>
class Complex
{
    friend ostream& operator << (ostream& out, Complex &c)
    {
        out << c.a << "+" << c.b << "i" << endl;
        return out;
    }

}；

2.按照一般改写，如下：

template <typename T>
class Complex
{
    friend ostream& operator << (ostream& out, Complex &c);

}；

template <typename T>
ostream& operator << (ostream& out, Complex<T> &c)
{
    out << c.a << "+" << c.b << "i" << endl;
    return out;
}

错误    1    error LNK2019: 无法解析的外部符号 "class std::basic_ostream<char,struct std::char_traits<char> > & __cdecl operator<<(class std::basic_ostream<char,struct std::char_traits<char> > &,class Complex<int> &)" (??6@YAAAV?$basic_ostream@DU?$char_traits@D@std@@@std@@AAV01@AAV?$Complex@H@@@Z)，该符号在函数 _main 中被引用    D:\C++study\eight\Complex\Complex\dm02.obj    Complex

3.解决办法：由友元函数类中改成成类外，但是在同一个文件中

template <typename T>
class Complex
{
    friend ostream& operator << <T>(ostream& out, Complex &c);

}；

template <typename T>
ostream& operator << (ostream& out, Complex<T> &c)
{
    out << c.a << "+" << c.b << "i" << endl;
    return out;
}

只要在类中声明过程中添加<T>

4.原因：

模板的机制：模板会有二次编译，第一次编译检查类模板或函数模板是否有词法语法等错误，在使用模板函数，编译器会根据实际类型不同生成不同的函数，然后就能找到相应类型的函数体。在实际运用中，模板函数可以利用编译器自动推断类型，可以显式或隐式使用函数模板，类模板必须显式使用，告诉编译器模板类的类型。

原因：第一次编译的函数头和第二次编译的函数头不同，
      friend ostream& operator << (ostream& out, Complex &c);
      ostream& operator << (ostream& out, Complex<T> &c)

导致找不到函数体，出现错误。

二、写在不同的文件中（.cpp和.h）

main.cpp引用时，#include"complex.cpp" 而不是#include"complex.h"

实例：

complex.h

#pragma once
#include <iostream>
using namespace std;
template <typename T>
class Complex
{
    friend ostream& operator << <T>(ostream& out, Complex &c);
    /*
    friend Complex Sub(Complex &c1, Complex &c2)
    {
    Complex tmp(c1.a - c2.a, c1.b - c2.b);
    return tmp;
    }
    */
private:
    T a;
    T b;
public:
    Complex(T a, T b);
    void print();
    Complex operator + (Complex &c2);
    Complex operator - (Complex &c2);
};

complex.cpp

#include "complex.h"
template <typename T>
Complex<T>::Complex(T a, T b)
{
    this->a = a;
    this->b = b;
}

template <typename T>
void Complex<T>::print()
{
    cout << a << "+" << b << "i" << 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> &c)
{
    out << c.a << "+" << c.b << "i" << endl;
    return out;
}

template<typename T>
Complex<T> Complex<T>::operator + (Complex<T> &c2)
{
    Complex<T> c1(0, 0);
    c1.a = this->a + c2.a;
    c1.b = this->b + c2.b;
    return c1;
}
main.cpp

#include <iostream>
using namespace std;
#include "complex.cpp"

int main()
{
    Complex<int> c1(1, 2);
    Complex<int> c2(3, 4);
    Complex<int> c3(5, 6);
    Complex<int> c4 = c1 + c2 + c3;
    cout << c4 << endl;

    //滥用友元
   // Complex<int> c5 = Sub(c1, c2);
   // cout << c5 << endl;  //这种是无法解决的
    Complex<int> c6 = c1 - c2;
    cout << c6 << endl;

    system("pause");
}