C++运算符重载

更新于 2015-12-03  约 9 分钟

为什么要有这玩意

定义一个复数类,创建两个复数对象。那么想把这两个复数相加,应该怎么办?

#include <iostream>
#include <stdio.h>

using namespace std;

class Complex {
public:
    int real;
    int imaginary;
    
    Complex(int real, int imaginary) {
        this->real = real;
        this->imaginary = imaginary;
    }
    // 先不看这段;运算符重载,类的成员函数,
//    Complex operator+(const Complex & c) {
//        return Complex(real + c.real, imaginary + c.imaginary);
//    }
};

// 运算符重载,普通函数
Complex operator+(const Complex & c1, const Complex & c2) {
    return Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);
}

int main() {
    // 创建两个复数
    Complex c1(1, 2);
    Complex c2(3, 4);
    // 实部,虚部相加后,再创建新的对象
    Complex c3 = Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);
    cout << "c3.real = " << c3.real << endl;
    cout << "c3.imaginary = " << c3.imaginary << endl;
    // 调用运算符重载,将两个复数对象直接相加
    Complex c4 = c1 + c2;
    cout << "c4.real = " << c4.real << endl;
    cout << "c4.imaginary = " << c4.imaginary << endl;
    return 0;
}

定义

既然叫运算符重载,那么定义的方式就会跟重载类似

  • operator运算符,相当于函数名

  • 形参表,就是参数列表

  • 与返回值类型无关,决定是否构成重载的是函数名和参数列表

普通函数

形参表,必须有两个参数

返回值类型 operator运算符(形参表) {
...... 
}

// 定义成这样,也是可以的,虽然没有意义。
// 我只是定义了两个复数相加的运算,返回类型不一定要是复数
int operator+(const Complex & c1, const Complex & c2) {
    return 1;
}

类的成员函数

  • 参数列表,只能有一个参数

  • 如果普通函数和类的成员函数都存在两个Complex相加的定义,生效的是类的成员函数

Complex operator+(const Complex & c) {
    return Complex(real + c.real, imaginary + c.imaginary);
}

调用

普通函数

// 两个类型相加就可以了
c1 + c2;
// 返回值才是我们想要的,所以有
Complex c4 = c1 + c2; 
// 以下是上一句的解释,以便于理解赋值运算符重载
// 上一句相当于Complex c4 = operator+(c1, c2);
// operator+是方法名,c1和c2是参数,返回创建的对象给c4

类的成员函数

Complex operator+(const Complex & c) {
    return Complex(real + c.real, imaginary + c.imaginary);
}
// 返回值才是我们想要的,所以有
Complex c3 = c1 + c2; 
// 以下是上一句的解释,以便于理解赋值运算符重载
// 上一句相当于Complex c3 = c1.operator+(c2);
// c1调用它的operator+方法,以c2作用参数,返回创建的对象给c4

赋值运算符重载

为什么要重载它

默认的赋值运算符,是浅拷贝,也就是对于指针变量,只拷贝地址,不复制内容。

#include <iostream>
#include <stdio.h>

using namespace std;

class Student {
    
private:
    int * scores;
public:
    Student (int * scores) : scores(scores) {
        
    }
    
    const int * getScores() {
        return scores;
    }
    
    ~Student() {
        cout << "~Student() --- " << scores << endl;
        delete []scores;
    }
};

int main(){
    int * scores1 = new int[3]{100, 100, 100}; // 学霸
    int * scores2 = new int[3]{10, 10, 10}; // 学渣
    Student s1(scores1);
    Student s2(scores2);
    
    // 地址不同
    cout << s1.getScores() <<endl;
    cout << s2.getScores() <<endl;

    s2 = s1; // 赋予学渣,学霸的力量
    // 地址相同,s1中的scores存储的地址,给我s2的scores
    cout << s1.getScores() <<endl;
    cout << s2.getScores() <<endl;
    // 局部变量回收,析构函数中,s1,s2,都释放了同一个内存空间,因此报错
    return 0;
}

示例

#include <iostream>
#include <stdio.h>

using namespace std;

class Student {
    
private:
    int * scores;
    int scoresLength;
public:
    Student (int * scores, int scoresLength)
    : scores(scores), scoresLength(scoresLength) {
        
    }
    
    const int * getScores() {
        return scores;
    }
    
    Student & operator=(const Student & student) {
        delete []this->scores;
        this->scores = new int[student.scoresLength];
        for (int i = 0; i < student.scoresLength; i++) {
            this->scores[i] = student.scores[i];
        }
        return *this;
    }
    
    ~Student() {
        cout << "~Student() --- " << scores << endl;
        delete []scores;
    }
    
    Student(Student & student) {
        cout << "Student(Student & student)" << endl;
    }
};

int main(){
    int * scores1 = new int[3]{100, 100, 100}; // 学霸
    int * scores2 = new int[3]{10, 10, 10}; // 学渣
    int * scores3 = new int[3]{1, 1, 1}; // 学渣
    Student s1(scores1, 3);
    Student s2(scores2, 3);
    Student s3(scores3, 3);
    
    // 地址不同
    cout << s1.getScores() <<endl;
    cout << s2.getScores() <<endl;
    
    s3 = s2 = s1; // 赋予学渣,学霸的力量
    
    // 地址相同,s1中的scores存储的地址,给我s2的scores
    cout << s1.getScores() <<endl;
    cout << s2.getScores() <<endl;
    cout << s3.getScores() <<endl;
    // 局部变量回收,析构函数中,s1,s2,都释放了同一个内存空间,因此报错
    return 0;
}

问题

返回值类型,一个是对象,一个是引用,为什么?
说不清,道不明啊...

Complex operator+(const Complex & c) {
    return Complex(real + c.real, imaginary + c.imaginary);
}
Student & operator=(Student & student) {
    // ...省略
    return *this;
}
阅读 1k更新于 2015-12-03

推荐阅读
人工智能之路
用户专栏

一只笨鸟的人工智能之路

5 人关注
26 篇文章
专栏主页
目录