原博主博客地址：javascript:void(0)

本文章博客地址：javascript:void(0)

         函数重载和运算符重载是简单的类多态性。所谓函数的重载简单地说就是赋值给同一个函数名多个含义。

      运算符重载即允许C/C++的运算符在用户定义类型（类）上拥有一个用户定义的意义，即运算符与类结合，产生新的含义。

         通过重载类上的标准运算符，使得用户程序所有的语言是面向问题的，而不是面向机器的，最终目标是降低学习曲线并减少错误率。几乎所有的运算符都可用作重载。具体包含：

 * 算术运算符：+、-、*、/、%、++、--；

 * 位操作运算符：&、|、~、^、<<、>>；

 * 逻辑运算符：!、&&、||；

 * 比较运算符：<，>，>=，<=，==，!=；

 * 赋值运算符：=、+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=；

 * 其他运算符：[]、()、->、，(逗号运算符)、new、delete、new[]、delete[]、->*；

下列运算符不允许重载：“.”、“*”、“::”、“?”、“:”；

      用户重载新定义运算符，不改变原运算符的优先级和结合性，也不改变运算符的结构，即单目运算符只能重载单目运算符类似的。

如下代码：

#include<iostream>
using namespace std;
class A
{
public:
    A() { _a=1; _b=2; cout << "construct A" << this << endl; }
    ~A(){  cout << "disconstruct A" << this << endl; }
    inline int a() { return_a; }
    inline int b() { return_b; } // 在类内定义的函数，如果不复杂，会隐式转为内敛函数，可省略inline
    inline int setA( int a) { _a=a; }
    inline int setB( int b) { _b=b; }
    void show() { cout << "a=" << _a << ";b=" << _b << endl; }
public: //以下都为重载的操作符
    A operator + (A &a1 )
   {
        //按照作用域的理解，此函数完成后，返回的t应该在函数结束时被释放，
        //但实际未释放，从结果中可以看出
        At;        
        t.setA(_a+a1.a());
        t.setB(_b+a1.b());
        //A t2; // 返回的不析构不释放，不返回的析构释放，所以t未释放，t2释放
        returnt; // t对象并未析构释放，而是存在且返回出去了
    }// 对象加对象生成新的对象
private:
    int_a;
    int_b;
};
int main(void)
{
    cout << "==========start==========" << endl;
    A a1;
    A a2;
#if 1 // 方式一
    //两次构造a3调用一次构造重载的操作符＋里面调用一次构造
    A a3;
    a3 = a1 + a2;
#else // 方式二
    // 一次构造 里面调用一次构造，直接赋值给a3,a3不再调用构造
    A a3= a1 + a2;
#endif
    a1.show();
    a2.show();
    a3.show();
    cout << "==========end==========" << endl;
    return 0;
}

方式一运行结果：

方式二运行结果：

3.2重载运算符示例

#include<iostream>
using namespace std;
class A
{
public:
    A():_a(1),_b(2),_c(true) { cout << "construct A" << this << endl; }
    ~A() { cout << "disconstruct A" << this << endl; }
    inline int a() { return_a;}
    inline int b() { return_b;}
    inline bool c() { return_c;}
    inline int setA(int a) { _a=a; }
    inline int setB(int b) { _b=b; }
    inline bool setC(bool c) { _c=c; }
    void show() { cout << "a=" << _a << ";b=" << _b << ";c=" << _c << this << endl;}
public:
    //重载运算符＋,此类包括：+、-、*、/、%、++、--；
    A operator + (A &a1)
    {
        At;//按照我们的理解，此函数完成后，返回的t应该在函数结束时被释放，
        //但实际未释放，从结果中可以看出
        t.setA( _a + a1.a() );
        t.setB( _b + a1.b() );
        A t2;
        returnt;
    }//对象加对象生成新的对象
    //重载运算符＆，此类包括：&、|、~、^、<<、>>；
    A operator & (A &a1)
    {
        At;
        t.setC( _a & a1.a() );
        return t;
    }
    //重载运算符!，此类包括：!、&&、||
    bool operator ! ()
    {
        _c = !_c;//重载为取反
        return _c;
    }
    //重重运算符<，此类包括：<，>，>=，<=，==，!=；
    bool operator < (A & a1)
    {
        _c=_b < a1.b();
        return_c;
    }
    //重载运算符+=，此类包括：=、+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=；
    A&operator+=(A &a1)
    {
        _a += a1.a();
        return *this;
    }
    //重载运算符->，此类包括：[]、()、->、，(逗号运算符)、new、delete、new[]、delete[]、->*；
    A*operator ->() {
        //返回他自己
        return this;
    }
private:
    int_a;
    int_b;
    bool_c;
};
 
int main(void)
{
    cout << "==========start==========" << endl;
    Aa1;
    Aa2;
    cout << "=== test + ===" << endl;
    a1.setA(1);
    a1.setB(10);
    a2.setA(2);
    a2.setB(20);
    A a3 = a1 + a2;// a=3 b=30
    a3.show();
    cout<< "=== test & ===1" << endl;
    a1.setA(3);
    a2.setA(14);
    A a4 = a1 & a2;// 3&14=1
    a4.show(); // c=1
    cout << "=== test ! ===1" << endl;
    a1.setC(false);//0-false1-true
    a1.show();
    !a1;
    a1.show();
    cout << "=== test < ===1" << endl;
    a1.setB(10);
    a2.setB(30);
    a1 < a2;
    a1.show();
    a1.setB(40);
    a1 < a2;
    a1.show();
    cout << "=== test + ====1" << endl;
    a1.setA(10);
    a2.setA(20);
    a1.show();
    a2.show();
    a1 += a2;
    a1.show();
    cout << " === test -> ===1" <<endl;
    cout << a1.operator->() << endl;
    cout << "==========end==========" << endl;
    return 0;
}

。

原博主博客地址：javascript:void(0)

本文章博客地址：javascript:void(0)