[c++] operator 运算符重载

运算符重载

全局函数重载输出运算符(<<)

class Person {
    friend void operator<<(ostream &our, Person ps);
private:
    int num;
    string name;
    float score;
public:
    Person();
    Person(int num, string name, float score)
        : num(num), name(name), score(score)
    {}
};
//全局函数重载<< 访问private变量需要声明友元
void operator<<(ostream &out, Person ps) {
    out<<ps.num<<" "<<ps.name<<" "<<ps.score;
}
int main() {
    //Person person = 1;
    Person person(111,"henry",99.8f);
    cout<<person;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

如果后面要继续接endl，则返回引用对象

ostream& operator<<(ostream &out, Person ps) {
    out<<ps.num<<" "<<ps.name<<" "<<ps.score;
    return out;
}

cout<<person<<endl;
1
2
3
4
5
6

重载输入运算符(>>)

istream& operator>>(istream &in, Person &ps) {
    in>>ps.num>>ps.name>>ps.score;
    return in;
}

cin>>person;
1
2
3
4
5
6

成员函数重载运算符(==)

当运算符的左边是类时，我们推荐使用成员函数重载，因为有一个参数已经被this指针包含了。

class Person {
private:
    int num;
    string name;
    float score;
public:
    Person();
    Person(int num, string name, float score)
        : num(num), name(name), score(score) {}

    bool operator==(Person ps) {
        if(num == ps.num && name == ps.name && score == ps.score) return true;
        return false;
    }
};
int main() {
    Person person(100,"henry",88.8);
    Person person2(100,"henry",88.8);
    if(person == person2) {
        cout<<"yes";
    }else {
        cout<<"No";
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

重载自增自减运算符(++)

• 重载后置++

Person operator++(int) {
    //保存旧值
    Person old = *this;
    //++
    num++;
    score++;
    //返回旧值
    return old;
}
1
2
3
4
5
6
7
8
9

• 重载前置++

Person operator++() {
    //++
    num++;
    score++;
    //返回旧值
    return *this;
}
1
2
3
4
5
6
7

重载中括号运算符([ ])

假设我们有一个自己定义的数组Array,我们需要进行[]操作符重载以实现 Array[i]数组元素快速访问 和 Array[i]=9 快速修改等操作。

首先根据我们的业务需求写出函数原型：

int& Array::operator[](int index);

我们以成员函数的方式进行重载，所以对象直接通过this指针隐式的传递了，参数只需要有一个int,因为我们业务中的索引是通过int类型；

返回值设计为int &是因为我们的业务需求中需要有Array[i]=0;这种赋值功能，这个语句的本质就是操作符重载这个函数做左值，当函数返回值做左值时需要返回引用类型，所以我们返回值设计为了int&

class Array
{
public:
	Array(int length);
	Array(const Array& obj);
	~Array();
 
public:
	int length();
 
private:
	int m_length;
	int *m_space;
 
public:
	//函数返回值当左值需要返回引用
	int& operator[](int i);
};
 
//重载[]
int& Array::operator[](int i){
	return m_space[i];
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23