有的操作符重载函数只能是成员函数

╰半橙微兮° 2022-05-16 12:18 145阅读 0赞

# 1 基本概念 #

(1) 不能重载的运算符只有5个：
    .           ( 成员访问运算符 )
    
    .*          ( 成员指针访问运算符 )
    
    ::          ( 域运算符 )
    
    sizeof      ( 长度运算符 )
    
    ?:          ( 条件运算符 )
    
    
    (2) 运算符必须是成员函数
    
    =          ( 赋值 )
    
    []         ( 下标 )
    
    ()         ( 调用) 
    
    ->         ( 成员访问箭头 )
    
    
    (3) 只能为友元
    
    >>         ( 输入流操作 )
    <<         ( 输出流操作 )

（1）.\*是C++的类成员函数指针调用运算符，是用来调用一个类函数指针的。

举例：假设有一个ClassA类拥有一个成员函数void ClassA::func(int i)，则可以这么用：

#include <iostream>
    using namespace std;
    
    class Test
    {
    public:
        void func( int a) { cout << a << endl; }
    };
    
    int main()
    {
        void (Test::*fp)(int i);   // 定义一个类函数指针
    
        fp = &Test::func;          // 给这个类函数指针赋值
        
        Test test;
        (test.*fp)(5);              // 这么用, 相当于调用obj.func(5);
    
        return 0;
    }

# 2 分析 #

（1） 编译器对一些操作符只允许重载为成员函数

对于赋值运算符来说，我们知道一个c++类，程序员如果没有为其定义了赋值操作符重载函数，编译器也会隐式的定义，这样倘若再定义全局赋值运算符重载函数，将会发生二义性。即使编译器允许这样的定义手法，在调用的时候也编译不过：

#include <iostream>
    using namespace std;
    
    class cls
    {
    public:
        cls( int a, char c ) : m_a( a ), m_c( c ) {}
        
    private:
        int m_a;
        char m_c;
    };
    
    cls& operator=( cls& c1, const cls& c2 )
    {
        // ...
        return c1;
    }
    
    int main(void)
    {
        cls c1( 1, 2 );
        cls c2( 3, 4 );
    
        c1 = c2;    // 调用的是编译器隐式定义的operator=()还是程序员显示定义的全局的operator=()
    
        return 0;
    }

编译器告诉我们这个函数必须是非静态成员函数。（must be a nonstatic member function）

# g++ -o main ./operator.cpp 
    ./operator.cpp:14:40: error: ‘cls& operator=(cls&, const cls&)’ must be a nonstatic member function
     cls& operator=(cls& c1, const cls& c2)
                                          ^
    #

（2）有些操作符重载函数规定是类的成员函数的原因

类的this指针会被绑定到运算符的左侧运算对象，成员运算符函数的显示参数比运算符对象总数少一个，这样可以减少程序员的错误。也就是说上文提到这些运算符的左操作数必须是该类类型的参数，换句话说，假设c++编译器允许\[\]操作符重载函数是全局的，那么程序员完全可能写出容易出错的代码。

#include <iostream>
    using namespace std;
     
    class cls
    {
    public:
        cls(int a, char c) : m_a(a), m_c(c) {}
        
    private:
        int m_a;
        char m_c;
    };
    
    cls& operator[](int dat, cls& c)
    {
        //...
        return c;
    }
    
    int main(void)
    {
        cls c(1, 'h');
        6[c];
     
        return 0;
    }

因为\[\]操作符重载函数是全局(友元)的，也就是没有了该函数的左操作数是this指针的限制，程序员可以任意定义左操作数的类型，类似的，就会出现6=c, 6(c), 6->c的代码，显然这样的代码是错误的。

不仅如此，假设cls类定义了转换构造函数：

cls::cls(int i);

那么 operator的函数原型大可以是：

cls& operator[](cls& c1, cls& c2)
    {
        //...
        return c1;
    }

看似正确，但是若用户利用转换构造函数的隐式类型转换调用该函数：

int main(void)
    {
        cls c(1, 'h');
        6[c];
     
        return 0;
    }

同样编译通过，显然这还是错误的。因此，c++编译器对这些操作直接视为语法问题。

（3）string类的加号操作符重载函数

另外我们可以推测string类的加号操作符重载函数是有两个版本的。如下正常运行的代码：

#include <iostream>
    using namespace std;
    
    int main(void)
    {
        std::string s1 = "hello";
        const char* s2 = "world";
     
        string s3 = s1 + "world";   
        string s4 = "world" + s1;
     
        return 0;
    }

代码中的两个加法操作分别执行成员函数的

string& operator+(const string& s);

和友元全局函数的

string& opreator+(std::string s1, std::string& s2);

因为假设二者都是调用成员函数的operator+()，那么第2个加法语句等价于

s4 = s2.operator+(s1);

然而s2是const char\*类型，根本没有成员函数。