c++类——运算符重载(二)

本文最后更新于:1 年前

经典例子:

我们以两个类,二维向量vector2和二维新式向量newvector2来说明各种运算符的重载。

vector全部使用友元函数重载,newvector全部使用成员函数重载,两个都可以时同时重载。

其成员为x和y,主要操作为x(如自增自减等等),次要操作为y。

(一)重载++和--:

和--的重载分为前置和后置两种情况,另外,虽然修改了类对象的状态,但是可以使用友元函数传入引用来实现和--的类外重载。

前置++或--的成员函数不需要传入参数,在代码块内不需要拷贝临时变量返回,只通过this指针进行自增/自减。

后置或--需要传入一个int类型的参数,可以不指定名称,因为一般在代码块内部不会使用它,这个参数只是为了占位置,用于和前置/--运算符的区别。在代码块内需要先拷贝一个临时变量返回。只通过this指针自增/自减。

前置++或--的友元函数需要传入一个类对象的引用,不需要拷贝临时变量返回,直接对传入参数进行操作(因为引用可以对其有效修改)。

后置++或--的友元函数需要传入两个参数,一个是类对象的引用,且为左操作数,一个是占位的int类型参数(和上面逻辑相同),需要先拷贝临时变量返回,直接对传入参数进行操作。

详细代码如下:

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
26
27
28
29
30
31
32
33
34
//vector2.h
#include<iostream>
using namespace std;
class vector2
{
friend vector2 operator ++(vector2& v); //前置++重载友元
friend vector2 operator ++(vector2& v, int); //后置++重载友元
friend vector2 operator --(vector2& v); //前置--重载友元
friend vector2 operator --(vector2& v, int); //后置--重载友元
private:
double x;
double y;
public:
vector2(double vx = 0, double vy = 0);
vector2(const vector2 &v);
void print();
~vector2();
};

class newvector2
{
private:
double x;
double y;
public:
newvector2(double vx = 0, double vy = 0);
newvector2(const newvector2& v);
newvector2 operator++(); //前置++重载成员
newvector2 operator++(int vx); //后置++重载成员
newvector2 operator--(); //前置--重载成员
newvector2 operator--(int vy); //后置--重载成员
void print();
~newvector2();
};
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
//vector2.cpp
#include"vector2.h"
#include<iostream>
using namespace std;
vector2::vector2(double vx,double vy):x(vx),y(vy)
{
cout << "创建了一个二维向量" << endl;
}

vector2::vector2(const vector2& v)
{
this->x = v.x;
this->y = v.y;
cout << "调用拷贝构造函数创建了一个二维向量" << endl;
}

vector2::~vector2()
{
cout << "析构了一个二维向量" << endl;
}


vector2 operator ++(vector2& v)
{
++v.x;
return v;
}

void vector2::print()
{
cout << "x:" << x << ",y:" << y << endl;
return;
}

vector2 operator ++(vector2& v, int)
{
vector2 temp(v);
v.x++;
return temp;
}

vector2 operator --(vector2& v)
{
--v.x;
return v;
}

vector2 operator --(vector2& v, int)
{
vector2 temp(v);
v.x--;
return temp;
}



newvector2::newvector2(double vx, double vy) :x(vx), y(vy)
{
cout << "创建了一个新式二维向量" << endl;
}

newvector2::newvector2(const newvector2& v)
{
this->x = v.x;
this->y = v.y;
cout << "调用拷贝构造函数创建了一个二维向量" << endl;
}

newvector2::~newvector2()
{
cout << "析构了一个新式二维向量" << endl;
}

void newvector2::print()
{
cout << "x:" << x << ",y:" << y << endl;
return;
}

newvector2 newvector2::operator++()
{
++this->x;
return *this;
}

newvector2 newvector2::operator++(int)
{
newvector2 temp(*this);
this->x++;
return temp;
}

newvector2 newvector2::operator--()
{
--this->x;
return *this;
}

newvector2 newvector2::operator--(int)
{
newvector2 temp(*this);
this->x--;
return temp;
}
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
//main.cpp
#include"vector2.h"
int main()
{
vector2 v(2, 4);
vector2 vv;
cout << "开始的v: ";
v.print();
vv=v++;
cout << "v++后: " << endl;
cout << "v:";
v.print();
cout << "vv: ";
vv.print();
vv=++v;
cout << "++v后: " << endl;
cout << "v: ";
v.print();
cout << "vv: ";
vv.print();
vv=v--;
cout << "v--后: " << endl;
cout << "v: ";
v.print();
cout << "vv: ";
vv.print();
vv=--v;
cout << "--v后: " << endl;
cout << "v: ";
v.print();
cout << "vv: ";
vv.print();

newvector2 newv(2, 4);
newvector2 newvv;
cout << "开始的newv: ";
newv.print();
newvv = newv++;
cout << "newv++后: " << endl;
cout << "newv:";
newv.print();
cout << "newvv: ";
newvv.print();
newvv = ++newv;
cout << "++nwev后: " << endl;
cout << "newv: ";
newv.print();
cout << "newvv: ";
newvv.print();
newvv = newv--;
cout << "newv--后: " << endl;
cout << "newv: ";
newv.print();
cout << "newvv: ";
newvv.print();
newvv = --newv;
cout << "--newv后: " << endl;
cout << "newv: ";
newv.print();
cout << "newvv: ";
newvv.print();
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/*运行结果:
创建了一个二维向量
创建了一个二维向量
开始的v: x:2,y:4
调用拷贝构造函数创建了一个二维向量
调用拷贝构造函数创建了一个二维向量
析构了一个二维向量
析构了一个二维向量
v++后:
v:x:3,y:4
vv: x:2,y:4
调用拷贝构造函数创建了一个二维向量
析构了一个二维向量
++v后:
v: x:4,y:4
vv: x:4,y:4
调用拷贝构造函数创建了一个二维向量
调用拷贝构造函数创建了一个二维向量
析构了一个二维向量
析构了一个二维向量
v--后:
v: x:3,y:4
vv: x:4,y:4
调用拷贝构造函数创建了一个二维向量
析构了一个二维向量
--v后:
v: x:2,y:4
vv: x:2,y:4
创建了一个新式二维向量
创建了一个新式二维向量
开始的newv: x:2,y:4
调用拷贝构造函数创建了一个二维向量
调用拷贝构造函数创建了一个二维向量
析构了一个新式二维向量
析构了一个新式二维向量
newv++后:
newv:x:3,y:4
newvv: x:2,y:4
调用拷贝构造函数创建了一个二维向量
析构了一个新式二维向量
++nwev后:
newv: x:4,y:4
newvv: x:4,y:4
调用拷贝构造函数创建了一个二维向量
调用拷贝构造函数创建了一个二维向量
析构了一个新式二维向量
析构了一个新式二维向量
newv--后:
newv: x:3,y:4
newvv: x:4,y:4
调用拷贝构造函数创建了一个二维向量
析构了一个新式二维向量
--newv后:
newv: x:2,y:4
newvv: x:2,y:4
析构了一个新式二维向量
析构了一个新式二维向量
析构了一个二维向量
析构了一个二维向量
*/

(二)重载=:

赋值运算符的重载用于对象数据的复制,且必须重载为成员函数,返回类型为对象的引用(为了能够连续操作,否则会有临时变量作为左值出现)。

赋值运算符是用已存在的对象给另一个对象赋新的值,该对象原来是有值的,所以重载的赋值运算符只能被已经存在了的对象调用,而不能凭空产生。

  • 和拷贝构造函数的区别:

    1. 拷贝构造函数生成新的类对象,而重载的赋值运算符是给已有的类对象进行赋值。

      ——因此,如果是一个类对象初始化使用"="运算符,右侧操作数即使也是这个类的对象,调用的仍然是拷贝构造函数而不是重载的赋值运算符,毕竟其还未被初始化完毕。

    2. 拷贝构造函数不必检测源对象是否与新建对象相同,而赋值运算符则需要。

    3. 如果赋值运算符中被赋值的对象有内存分配,需要先把内存释放掉再进行赋值。(要不原来的分配的内存就一直不会被释放了,另外此处的赋值他也是在堆上进行的)

1
2
3
4
5
6
7
//vector2.h
//为newvector2添加一个新的char指针成员。
char* p;
//添加了一个重载赋值运算符
newvector2& operator=(const newvector2& v);
//构造函数参数修改:
newvector2(double vx = 0, double vy = 0,const char*vp="\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
26
27
28
29
30
31
32
33
34
35
36
//vector2.cpp
//构造函数修改:
newvector2::newvector2(double vx, double vy,const char*vp) :x(vx), y(vy)
{
p = new char[strlen(vp) + 1];
strcpy_s(p, strlen(vp)+1, (char*)vp);
cout << "创建了一个新式二维向量" << endl;
}
//复制构造函数修改:
newvector2::newvector2(const newvector2& v)
{
this->x = v.x;
this->y = v.y;
p = new char[strlen(v.p) + 1];
strcpy_s(p, strlen(v.p) + 1, v.p);
cout << "调用拷贝构造函数创建了一个新式二维向量" << endl;
}

//析构函数修改:
newvector2::~newvector2()
{
delete[]p;
p = NULL;
cout << "析构了一个新式二维向量" << endl;
}

//定义重载赋值运算符
newvector2& newvector2::operator=(const newvector2& v)
{
this->x = v.x;
this->y = v.y;
delete[](this->p);
this->p = new char[strlen(v.p) + 1];
strcpy_s(this->p,strlen(v.p)+1,v.p);
return *this;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//main.cpp
#include"vector2.h"
int main()
{
newvector2 v1(2, 3, "first");
newvector2 v2 = v1;
newvector2 v3, v4;
v4 = v3 = v1;
return 0;
}
//运行结果:
创建了一个新式二维向量
调用拷贝构造函数创建了一个新式二维向量
创建了一个新式二维向量
创建了一个新式二维向量
调用赋值运算符为一个对象赋值
调用赋值运算符为一个对象赋值
析构了一个新式二维向量
析构了一个新式二维向量
析构了一个新式二维向量
析构了一个新式二维向量

(三)重载+ (- | * | / | %相同):

一般建议使用友元函数重载,但是也可以使用全局函数或者成员函数重载。

本类型中尽量不要使用引用进行传递,否则会无法进行隐性的类型转化。

当然一般情况下建议使用引用进行传递,不过这样在不加其他函数的情况下不可以进行隐式类型转化。

成员函数的弊端是不能只把基本类型放在左操作数上(不发生隐形类型转化,有限制),不过可以让两个均为基本类型(均发生隐形类型转化)

是比较简单的二元运算符重载。

1
2
3
4
5
//vector2.h
//vector2加一个友元函数:
friend vector2 operator +(vector2 v1, vector2 v2);
//newvector2加一个成员函数:
newvector2 operator+(newvector2 v);
1
2
3
4
5
6
7
8
9
10
11
//vector2.cpp
//vector2的+运算符重载定义
vector2 operator+(vector2 v1,vector2 v2)
{
return vector2(v1.x + v2.x, v1.y + v2.y);
}
//newvector2的+运算符重载定义
newvector2 newvector2::operator+(newvector2 v)
{
return newvector2(this->x + v.x, this->y + v.y, this->p);
}
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
26
27
28
29
//main.cpp
#include"vector2.h"
int main()
{
vector2 v1(1, 2);
vector2 v2(3, 4);
vector2 v3(4, 8);
vector2 v4 = v1 + v2 + v3;
v4.print();
vector2 v5 = 1.0 + v3; //发生隐性类型转化
v5.print();
vector2 v6 = v3 + 2.0; //同
v6.print();
vector2 v7 = 3.0 + 4.0; //同
v7.print();

newvector2 vv1(1, 2);
newvector2 vv2(2, 3);
newvector2 vv3(3, 4);
newvector2 vv4 = vv1 + vv2 + vv3;
vv4.print();
newvector2 vv6 = vv3 + 2.0; //发生隐性类型转化
vv6.print();
//newvector2 vv5 = 1.0 + vv3; 成员函数的弊端:必须把左操作数设置为类对象
newvector2 vv7 = 3.0 + 4.0; //同转化
vv7.print();
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
//运行结果
创建了一个二维向量
创建了一个二维向量
创建了一个二维向量
调用拷贝构造函数创建了一个二维向量
调用拷贝构造函数创建了一个二维向量
调用拷贝构造函数创建了一个二维向量
创建了一个二维向量
析构了一个二维向量
析构了一个二维向量
创建了一个二维向量
析构了一个二维向量
析构了一个二维向量
x:8,y:14
调用拷贝构造函数创建了一个二维向量
创建了一个二维向量
创建了一个二维向量
析构了一个二维向量
析构了一个二维向量
x:5,y:8
创建了一个二维向量
调用拷贝构造函数创建了一个二维向量
创建了一个二维向量
析构了一个二维向量
析构了一个二维向量
x:6,y:8
创建了一个二维向量
x:7,y:0
创建了一个新式二维向量
创建了一个新式二维向量
创建了一个新式二维向量
调用拷贝构造函数创建了一个新式二维向量
调用拷贝构造函数创建了一个新式二维向量
创建了一个新式二维向量
析构了一个新式二维向量
创建了一个新式二维向量
析构了一个新式二维向量
析构了一个新式二维向量
x:6,y:9
创建了一个新式二维向量
创建了一个新式二维向量
析构了一个新式二维向量
x:5,y:4
创建了一个新式二维向量
x:7,y:0
析构了一个新式二维向量
析构了一个新式二维向量
析构了一个新式二维向量
析构了一个新式二维向量
析构了一个新式二维向量
析构了一个新式二维向量
析构了一个二维向量
析构了一个二维向量
析构了一个二维向量
析构了一个二维向量
析构了一个二维向量
析构了一个二维向量
析构了一个二维向量

可以仔细想想每个构造和析构函数出现的原因(当思考题了😋)

(四)重载<和> (其他比较运算符性质相同):

此处只通过友元函数重载,且使用const引用。

注意,此要返回bool值,尽可能不要返回其他类型。

1
2
3
4
//vector2.h
//vector2增加友元函数
friend bool operator <(const vector2& v1, const vector2& v2);
friend bool operator >(const vector2& v1, const vector2& v2);
1
2
3
4
5
6
7
8
9
10
11
//vector2.cpp
//增加两个友元函数的定义
bool operator <(const vector2& v1, const vector2& v2)
{
return bool(v1.x * v1.x + v1.y + v1.y < v2.x* v2.x + v2.y * v2.y);
}

bool operator >(const vector2& v1, const vector2& v2)
{
return bool(v1.x * v1.x + v1.y + v1.y > v2.x* v2.x + v2.y * v2.y);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//main.cpp
#include"vector2.h"
int main()
{
vector2 v1(1, 2);
vector2 v2(2, 2);
if (v1 < v2) { cout << "v1到0距离小于v2" << endl; }
else if (v1 > v2) { cout << "v1到0距离大于v2" << endl; }
return 0;
}
//运行结果:
创建了一个二维向量
创建了一个二维向量
v1到0距离小于v2
析构了一个二维向量
析构了一个二维向量

(五)重载[]和():

是二元运算符,但是均只能用成员函数重载。

  • 重载下表运算符[]:

    用于访问数据对象的元素,这种写法更符合我们的习惯。

    x[y]等价于x.operator(y)

    参数类型和返回类型可以自定。

    但是需要我们自己增加下标越界检查,这样[]的使用更为安全。

    1
    2
    3
    4
    5
    6
    //vector2.h
    //newvector2增加新成员函数:
    double operator[](int i);
    //增加新数据成员:
    double darray[20];
    //构造函数保持不变
    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
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    //vector2.cpp
    //构造函数改为:
    newvector2::newvector2(double vx, double vy,const char*vp) :x(vx), y(vy)
    {
    for (int i = 0; i < 20; i++) {
    darray[i] = i+1;
    }
    p = new char[strlen(vp) + 1];
    strcpy_s(p, strlen(vp)+1, (char*)vp);
    cout << "创建了一个新式二维向量" << endl;
    }
    newvector2::newvector2(const newvector2& v)
    {
    this->x = v.x;
    this->y = v.y;
    for (int i = 0; i < 20; i++) {
    this->darray[i] = v.darray[i];
    }
    p = new char[strlen(v.p) + 1];
    strcpy_s(p, strlen(v.p) + 1, v.p);
    cout << "调用拷贝构造函数创建了一个新式二维向量" << endl;
    }
    //赋值运算符改为
    newvector2& newvector2::operator=(const newvector2& v)
    {
    this->x = v.x;
    this->y = v.y;
    for (int i = 0; i < 20; i++)
    {
    this->darray[i] = v.darray[i];
    }
    delete[](this->p);
    this->p = new char[strlen(v.p) + 1];
    strcpy_s(this->p,strlen(v.p)+1,v.p);
    cout << "调用赋值运算符为一个对象赋值" << endl;
    return *this;
    }
    //增加[]重载运算符的定义:
    double newvector2::operator[](int i)
    {
    //越界要检查
    if (i < 20 and i >= 0) {
    return darray[i];
    }
    else
    {
    cout << "越界!将输出限定为0" << endl;
    return 0.0;
    }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    //main.cpp
    #include"vector2.h"
    int main()
    {
    newvector2 v(1, 2, "1");
    cout << v[5] << endl;
    cout << v[222] << endl;
    return 0;
    }
    //运行结果:
    创建了一个新式二维向量
    6
    越界!将输出限定为0
    0
    析构了一个新式二维向量
  • 重载函数调用符:

    用于函数调用。

    x(y1,y2,y3,...)等价于x.operator()(y1,y2,y3,...)

    这样,我们可以像使用函数一样使用类的对象,因为其可以存储类的状态,所以相较于函数这种写法更加灵活。

    调用运算符的参数表是不唯一的,可以根据需要确定个数及类型。

    返回类型也没有限定。

    这里的函数调用符用于计算传入两个值作为一个点到(0,0)的距离。

    1
    2
    3
    //vector2.h
    //newvector2增加新成员函数:
    double operator()(double xx, double yy);
    1
    2
    3
    4
    5
    6
    //vector2.cpp
    //增加()重载运算符的定义:
    double newvector2::operator()(double xx, double yy)
    {
    return sqrt(xx * xx + yy * yy);
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    //main.cpp
    #include"vector2.h"
    int main()
    {
    newvector2 v;
    cout << v(2, 3) << endl;
    return 0;
    }
    //运行结果:
    创建了一个新式二维向量
    3.60555
    析构了一个新式二维向量

(六)重载<<和>>:

istream和ostream是c++的预定义流类。

cin是istream的对象,cout是ostream的对象。

运算符<<由ostream重载为插入操作,用于输出基本类型数据,我们可以对其重载,使输出为自定义的数据类型。

运算符>>由istream重载为提取操作,用于输入基本类型数据,我们可以对其重载,使输入为自定义的数据类型。

只能重载为友元函数。(因为cout<<的左操作数只能为cout,右操作数才是需要输出的对象,cin>>同理)

返回类型限定为ostream& 和istream&,第一个参数强制为ostream&和istream&,第二个参数为用户自定义的类型。(引用绝对不可以省略!)

1
2
3
4
//vector2.h
//vector2增加新友元函数:
friend ostream& operator <<(ostream& output, const vector2& v);
friend istream& operator >>(istream& input, vector2& v);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//vector2.cpp
//增加<<和>>重载运算符的定义:
ostream& operator <<(ostream& output, const vector2& v)
{
output << "x:" << v.x << ",y:" << v.y << endl;
return output;
}

istream& operator >>(istream& input, vector2& v)
{
cout << "请分别输入这个二维向量的x和y:" << endl;
input >> v.x;
input >> v.y;
return input;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//main.cpp
#include"vector2.h"
int main()
{
vector2 v;
cin >> v;
cout << v;
return 0;
}
//输出结果:
创建了一个二维向量
请分别输入这个二维向量的x和y:
5 9
x:5,y:9
析构了一个二维向量

c++类——运算符重载(二)
https://github.com/xiaohei07/xiaohei07.github.io/2023/03/24/c++类——运算符重载(二)/
作者
07xiaohei
发布于
2023年3月24日
许可协议