需要类型转换时定义为非成员函数_类型转换时定义非成员函数-优快云博客

本文探讨了在C++中，当需要类型转换时如何使用非成员函数，特别是在重载运算符和模板类的情况下。条款24强调，如果所有参数都需要类型转换，应使用non-member函数，因为这允许编译器尝试隐式转换参数。条款46进一步扩展到模板类，解释了如何处理模板化时的类型转换问题，通过在模板类中声明友元非成员函数来解决编译器的推导限制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

需要类型转换时定义为非成员函数

前言：

因为自己查阅文章时经常遇到，这些问题：因为环境不同而导致结果不一致、因为文章跳跃度太大而导致无法理解、因为文章代码运行结果不同而苦恼。

所以为了看我文章的人不会遭遇同样的问题，

以后我的文章将遵循以下原则：

1.会在文章开头标明相关配置与环境

2.尽可能循序渐进（还是看不懂可能是我没有这样的天赋），标出阅读的前提知识

3.列出的代码自己先跑一遍

////////////////////////////////////////

语言：

c++

前提知识：

1.类

2.函数重载

3.类型转换

集成开发环境：Visual Studio 2017

////////////////////////////////////////

条款24：若为所有参数皆需类型转换，请为此采用non-member函数

class Num
{
public：
         Num(intN=0,int M=1):n(N),M(M){}//不设explicit，提供隐式转换
         constNum operator*(const Num& rhs)const
         {
                  returnNum(rhs.getN()*n+rhs.getM()*M);
         }
         const int getN()const{return n;}
         const int getM()const{return m;}
private:
         int n;
         int m;
};

int main()
{
         Numnum1(2,3);
         Numnum2(3,4);
         Numnum3=num1*num2;      //成功
         num3=num3*num1;                //成功
         num3=num3*2;               //成功
         num3=2*num1;               //失败
         return0;
}

为何num3=num3* 2成功而num3=2* num1却失败

因为num3=num3*2中，函数operator=由num3调用且参数为2，参数2为int可通过构造函数隐式转换为Num，所以成功

而num3=num3*2中，虽然想调用operator=但，这个函数却不属于int，这个基础类型int根本不拥有函数。

使用函数形式重写上面两个例子：

num3=num3.operator*(2);
num3=2.operator*(num3);             //明显错误

上述情况下，编译器会尝试寻找参数为(int,Num)的operator*的非成员函数。

所以只要写一个参数为(int,Num)的operator的非成员函数即可，这就是我们一般重载乘法运算符时的做法————将重载乘法运算符声明为friend函数，即非成员函数的operator可以调用类中的private成员进行运算。

friend const Num operator*(const Num& lhs,const Num& rhs)const
         {
                  returnNum(rhs.getN()*lhs.getN()+rhs.getM()*lhs.getN());
                  //虽然可以直接使用m和n,但这是个好习惯，保持封装
         }

因为声明为友元函数，不再是成员函数，成员函数隐含一个参数this指向调用方，所以友元函数比成员函数多一个参数。

 num3=2*num1;               //成功
 <=>num3=operator*(Num(2),num1);

该条款的重点在于，只有参数位于参数列中，这个参数才有可能被隐式类型转换。

条款46：需要类型转换时请为模板定义非成员函数

条款24的升级版？可能这样说有点不妥，实质上就是把条跨23中的类模板化了,但是一旦模板化了事情就会变得复杂，因为编译器的处理策略不同了。

template
class Num
{
public：
Num(T&N=0,T& M=1);//不设explicit，提供隐式转换
constNum operator*(const Num& rhs)const
{
returnNum(rhs.getN()*n+rhs.getM()M);
}
constT getN()const{return n;}
constT getM()const{return m;}
private:
Tn;
Tm;
};
Num num;
num=num2; //失败