Effective C++ ——如果要为所有参数隐形转换，需要non-member

effective c++ 条款46
总结：

1. 如果需要为某个函数所有参数（包括This指针所指的隐形参数）进行类型转换，则需要这个函数是non-member
2. 普通函数会发生隐式类型转换
3. 函数模板自动类型推导不发生隐式类型转换（可以是把5调用构造，隐形转换成testmultiply类型）
4. 函数模板显示指定类型发生隐式类型转换
5. == 重载函数，只能有0个或者1个参数，如果要写万能*，必须写在类外，即是non-member，或者写在类中，并使用friend==
6. 直接在友元函数内部, 实现代码(inline);参考链接
7. 在友元函数内部, 实现一个模板函数, 在把模板函数在外部实现.
8. testmultiply mul3 = 5 * mul1;中，需要先把5隐形转换成testmultiply，再走*，但是模板类不支持隐形推导，但是这里因为mul1的类型为testmultiply，推导出类模板的T，然后就可以进行隐形类型推导！这里使用友元的目的有两个，1是调用私有变量，2是为了让mul1的T能作用在class中所有的T上，推导出T，是的模板变成一个特定的类，帮助完成隐形转换！3、友元中函数体必须在内部，link不到在外面定义的模板函数体，但是能链接到确定的函数！
9. 接着8，如果 testmultiply mul3 = 5 * mul1;，那么推导出U为int，但是不代表templateclass testmultiply的T为U，testmultiply(T i):a(i){}的T不知道，所以推导不出来。想要隐形推导，必须在class内部函数中！！！！

template< class U>
const testmultiply operator*(const testmultiply& te1, const testmultiply& te2)
{
return testmultiply(te1.a*te1.a);
}

代码1

class testmultiply
{
public:
   testmultiply()=default;
   testmultiply(int i):a(i){}
   const testmultiply operator*(const testmultiply& te){this->a = this->a * te.a; return *this;}
private:
   int a;
   friend const testmultiply operator*(const testmultiply& te1, const testmultiply& te2);
};
 
const testmultiply operator*(const testmultiply& te1, const testmultiply& te2)
{
   testmultiply te;
   te.a = te1.a * te2.a;
   return te;
   }
int main()
{
   testmultiply mul1(10);
   testmultiply mul2 = mul1 * 5;  //5可以隐形转换
   testmultiply mul3 = 5 * mul1; //如果常规转换不行，因为5没有this，所以需要全局的*，因为对象是private所以需要friend

代码2

template<class T>
class testmultiply
{
public:
   testmultiply()=default;
   testmultiply(T i):a(i){}
   const testmultiply operator*(const testmultiply& te){this->a = this->a * te.a; return *this;}
   friend const testmultiply operator*(const testmultiply& te1, const testmultiply& te2);
private:
   T a;
   
};
template<class T>
const testmultiply<T> operator*(const testmultiply<T>& te1, const testmultiply<T>& te2)
{
   testmultiply<T> te;
   te.a = te1.a * te2.a;
   return te;
   }
int main()
{
   testmultiply<int> mul1(10);
   testmultiply<int> mul2 = mul1 * 5;
   testmultiply<int> mul3 = 5 * mul1; //注意模板类不能自动类型推导，5不能推导出T的类型int，需要mul1推导出T，然后走构造，再重载*

代码3

template<class T>
class testmultiply
{
public:
   testmultiply()=default;
   testmultiply(T i):a(i){}
   const testmultiply operator*(const testmultiply& te){this->a = this->a * te.a; return *this;}
   

   T a;
private:
 friend const testmultiply<T> operator*(const testmultiply<T>& te1, const testmultiply<T>& te2);
 //或者在这里写明{return testmultiply<int>(te1.a*te1.a);}
};

template<class U>
const testmultiply<U> operator*(const testmultiply<U>& te1, const testmultiply<U>& te2)
{
   return testmultiply<U>(te1.a*te1.a);
   }
   
const testmultiply<int> operator*(const testmultiply<int>& te1, const testmultiply<int>& te2){return testmultiply<int>(te1.a*te1.a);};
int main()
{
   testmultiply<int> mul1(10);
   testmultiply<int> mul2 = mul1 * 5;
   testmultiply<int> mul3 = 5 * mul1; //

代码4

#include<bits/stdc++.h>
using namespace std;

template<class T>
T add(T a,T b)
{
    return a + b;
}

int padd(int a,int b)
{
    return a + b;
}

//普通函数会发生隐式类型转换
//函数模板自动类型推导不发生隐式类型转换
//函数模板显示指定类型发生隐式类型转换
int main()
{
    int a = 1,b = 2;
    char c = 'a';
    cout << padd(a , b) << endl;
    cout << padd(a , c) << endl;
    cout << add(a,b) << endl;
    //cout << add(a,c) << endl;//函数模板自动类型推导不发生隐式类型转换

    cout << add<int>(a,b) << endl;
    cout << add<int>(a,c) << endl;
}