掘根宝典之C++运算符重载

什么是运算符重载

运算符重载是一种形式的C++多态。这很容易让大家想到函数多态,让我们使用同名的函数来完成相同的基本操作,即使是用于不同的类型,不懂函数多态的看这里http://t.csdnimg.cn/ipbqR

运算符重载把重载的概念拓展到运算符上,允许赋予C++运算符多种含义。

实际上C++已经重载了很多运算符了,比如"*“,可以用于乘法,也可以用于解引用

C++根据操作数的数目和类型来决定采用哪种操作

例如啊,我们知道数组是不能相加的啊,那我们可以通过重载运算符来实现数组“相加”,赋予特定意义

实现下面这种操作

int a[10];
int b[10];
int c=a+b;

实现运算符重载

重载运算符的本质是编写以运算符为名称的函数

格式为

返回类型  operator运算符 (参数列表)
{
函数体
}

先看个例子

#include
using namespace std;
class AA
{
private:
	int a_;
public:
	AA(int a)
	{
		a_ = a;
	}
//重载运算符
	int operator+(AA& t)
	{
		return a_ + t.a_;
	}
};
int main()
{
	AA e = { 2 };
	AA r = { 3 };
//检查运算符结果
	cout << e + r << endl;
}

发现打印出来的是5,这说明我们重载后的+也可以用于对象相加了

重载运算符的规则

重载运算符有以下限制:

1. 重载运算符只能作用于自定义类型的对象,不能用于内置类型(如int、float等),也就是说重载之后的运算符的操作数必须有一个是自定义类型。

2.C++中不允许用户定义新的运算符,只能对已有的运算符进行重载,

3.重载后的运算符的优先级、结合性也应该保持不变,也不能改变其操作个数和语 法结构。

4.重载后的含义,与操作基本数据类型的运算含义应类似,如加法运算符“+”,重 载后也应完成数据的相加操作。

5.有5个运算符不可重载:类关系运算符“:”、成员指针运算符“*”、作用域运算 符“::”、sizeof运算符、三目运算符“?:”

6.运算符重载函数不能有默认参数,否则就改变了运算符操作数的个数,是错误的。

7.运算符重载函数既可以作为类的成员函数,也可以作为类的友元函数,也可以是全局函数。 

8.作为全局函数时,一般都需要在类中将该函数声明为友元函数。因为该函数大部分情况下都需要使用类的private成员。

9.作为类的成员函数时,二元运算符的参数只有一个, 一元运算符不需要参数(参数没有任何意义,只是为了区分是前置还是后置形式:带 一个整型参数为后置形式)。因为有个参数(左操作数)是隐含的(隐式访问this指针 所指向的当前对象)。

10.作为全局函数或者友元函数时,二元操作符需要两个参数,一元操作符需要一 个参数,而且其中必须有一个参数是对象,好让编译器区分这是程序员自定义的运算符, 防止程序员修改用于内置类型的运算符的性质。

重载运算符的几种情况

1.重载为普通全局函数

重载运算符可以是普通函数,但是有个限制,就是它的函数参数必须有一个类类型或枚举类型

看个例子 

#include
using namespace std;
class AA
{public:     //注意是public
	int a;
	int b;
};
int operator+(AA t,AA y)//可以
{
	return t.a + y.a;
}
int operator+(AA t,int y)//可以
{
	return t.a + y;
}

int operator+(int t,int y)//这是不行的
{
	return t+ y;
}

int main()
{
	AA f = { 1,2 };
	AA g = { 3,4 };
	cout << f + g << endl;
    cout<<  f+3<

但是上面的AA类的数据成员是public的(如果是private的话,普通全局函数没权限访问),这违反了类的原则之一——数据隐藏,所以我们很少重载为普通的全局函数 

2.重载为类的成员函数

重载运算符最常见的就是在类里面作为类方法进行重载的


(1),双目运算符


如果是双目运算符重载为类的成员函数,则它有两个操作数:左操作数是对象本身 的数据,由this指针指出(我们不写),右操作数则通过运算符重载函数的参数表来传递(必须要写)

也就是说,我们只需写下右操作数即可

定义格式:

返回类型 operator操作符(右操作数类型)
{
函数体
}

调用格式为:

左操作数 操作符 右操作数 

编译器会自动将上面这个语句展开为下面这种 

左操作数.operator运算符(右操作数)

当然我们也可以直接使用第二种 

 看个例子

#include 
using namespace std;
 
class A
{
private:
    int x, y;
public:
    A(int x1 = 0, int y1 = 0) //默认构造函数
    {
        x = x1;
        y = y1;
    }
    A operator+(const A& a)const   //const成员函数,运算符重载
    {
        A t;
        t.x = this->x + a.x;
        t.y = this->y + a.y;
        return t;
    }
    void show()
    {
        cout << "x=" << x << "," << "y=" << y << endl;
    }
};
int main()
{
    A a1(1, 2);
    A a2(3, 4);
    A a;
    a = a1 + a2;//实际上等价于a=a1.operator+(a2);
    a.show();
}

输出结果

x=4,y=6

我们这也是成功重载运算符+


(2),单目运算符


如果是单目运算符重载为类的成员函数,则要分为前置(++i)和后置(i++)运算符。

如果是前置运算符,则它的操作数是函数调用者,函数没有参数。

前置调用格式为:

操作符 操作数;

被编译器展开为 

操作数.operator运算符()

后置调用格式为 

操作数 操作符;

被编译器展开为 

操作数.operator运算符(操作数类型)

举个例子 

#include 
using namespace std;
 
class A
{
private:
    int x, y;
public:
    A(int x1 = 0, int y1 = 0)
    {
        x = x1;
        y = y1;
    }
    A &operator++()//++i 前置++实现
    {
        ++x;    //先自增
        ++y;
        return *this;    //后引用
    }
    A operator++(int)    //i++ 后置++实现
    {
        //int参数没有任何意义,只是为了区分是前置还是后置形式
        A a = *this;    //保存对象引用
        ++(*this);    //自增,调用前面实现的前置++
        return a;    //返回先前保存的对象
    }
    void show()
    {
        cout << "x=" << x << "," << "y=" << y << endl;
    }
};
int main()
{
    A a1(1, 2), a2(3, 4);
    (a1++).show();
    (++a2).show();
    return 0;
}

输出结果

x=1,y=2
 
x=4,y=5


实现前置“++”时,数据成员进行自增运算,然后返回当前对象(即this指针所指 向的对象)。实现后置“++”时,创建了一个临时对象来保存当前对象的值,然后再将当前对象自增,最后返回的是保存了初始值的临时对象。

注意:前置单目运算符和后置单目运算符的最主要区别是函数的形参,后置单目运 算符带一个int型形参,但它只起区分作用。

3.重载为类的友元函数


运算符重载为类的友元函数,只是在函数前加一个friend关键字。

(1)重载格式

friend 返回类型 operator 运算符(参数列表)

{

    函数体;

}

明:运算符重载为类的友元函数时,由于没有隐含的this指针,因此,操作数的个数没有变化,所有的操作数都必须通过函数形参进行传递,函数的参数与操作数 自左自右保持一一对应。

调用格式为:

左操作数 操作符 右操作数 

编译器会自动将上面这个语句展开为下面这种 

operator 运算符(左操作数,右操作数);

例如:调用a1+a2相当于函数调用operator+(a1, a2)

下面看一个例子:

将”+”运算符重载为类的友元函数

#include 
using namespace std;
 
class A
{
private:
    int x, y;
public:
    A(int x1 = 0, int y1 = 0)
    {
        x = x1;
        y = y1;
    }
    friend A operator+(const A& a, const A& b);
    void show()
    {
        cout << "x=" << x << "," << "y=" << y << endl;
    }
};
A operator+(const A& a, const A& b)
{
    return A(a.x + b.x, a.y + b.y);
}
int main()
{
    A a1(1, 2), a2(3, 4);
    A c;
    c = a1 + a2;//可以替换为c=operator+(a1,a2);
    c.show();
    return 0;
}

输出结果

x=4,y=6


4.两种重载方式的选择(不包括普通全局函数)


多数情况下,将运算符重载为类的成员函数和类的友元函数都是可以的,但两者各具特点:

1,一般,单目运算符最好重载为类的成员函数,双目运算符最好重载为类的友元函数。

2,若一个运算符的操作需要修改对象的状态,选择重载为成员函数较好。

3,若运算符的操作数(尤其是第一个操作数)可能有隐式类型转换,则只能选用友元函 数。

4,具有对称性的运算符可能转换任意一端的运算对象,如:算术(a+b和b+a)、关系运算 符(a>b和b

5,有4个运算符必须重载为类的成员函数:赋值=、下标[ ]、调用( )、成员访问->。

重载

常用运算符的重载

1.输入输出运算符的重载


C++标准库对左移运算符<<和右移运算符>>分别进行了重载,使其能够用于不同数 据的输入输出。对于基本类型数据(如bool、int、double等)和标准库所包含的 类(如string、complex、ofstream、ifstream等)可以直接使用输入运算符“>>”、 输出运算符“<<”进行读写操作。对于自己定义的新数据类型(如:类对象)则需要重载这两个运算符。

cout<>obj1;   //cout是ostream类的对象,cin是istream类的 对象

由于输入输出操作的第一个操作数为ostream/istream对象,也就是说左侧的运算 对象必须是ostream/istream对象,如果重载成类的成员函数,则左侧的操作对 象将是我们定义的一个类对象(需要修改标准库中的类,显然不是我们所期望 的)。因此输入输出运算符不可重载为类的成员函数,只能重载为非成员函数 (全局函数,友元函数)。

重载“<<”和“>>”运算符的一般格式为:

istream& operator>>(istream&, 类对象引用);         //输入运算符>>重载

ostream& operator<<(ostream&, const 类对象引用);    //输出运算符<<重载

说明
(1)对于输入运算符来说,第一个参数是istream对象的引用,第二个参数是要 向其中存入数据的对象,不能为常量返回istream类对象的引用(可作为下次调 用时的第一个参数),是为了能够连续读取:cin>>c1>>c2;,让代码书写更加漂亮。 如果不返回引用,就只能一个一个地读取:cin>>c1;  cin>>c2;

cin>> c; 可以理解为:operator >> (cin , c);

(2)对于输出运算符“<<”来说,第一个参数是ostream对象引用,因为向流中 写入数据会改变流的状态 ,所以不能用const修饰ostream对象。由于采用了引用 的方式进行参数传递,并且也返回了对象的引用,所以重载后的运算符可以实现连 续输出。

cout<< c; 可以理解为:operator<< (cout , c);

案例

#include 
using namespace std;
 
class A
{
private:
    int x, y;
public:
    A(int x1 = 0, int y1 = 0)
    {
        x = x1;
        y = y1;
    }
    friend istream& operator>>(istream& is, A& a);
    friend ostream& operator<<(ostream& os, const A& a);
};
istream& operator>>(istream& is, A& a)
{
    is >> a.x >> a.y;
    return is;
}
ostream& operator<<(ostream& os, const A& a)
{
    os << "x=" << a.x << "," << "y="<> a1;
    cout << a1;
    return 0;
}

输出结果

21 88
 
x=21,y=88


重载输入输出运算符后,便可像基本数据类型一样直接对类对象进行输入输出,不 用再编写用于输入输出对象数据成员的show()等成员函数,而且使用起来更为简洁。

注意:
通常情况下,输出运算符主要负责输出对象的内容,而非控制格式,此时不应该把 换行符也重载进去。如果把换行符也重载进去,用户有时想在同一行输出一些描述 性的文本,就无法完成了。因此,在重载输出运算符时,应尽量少一些格式化操作, 可以使用户控制更多的输出细节。

2,关系运算符的重载


关系运算符(如“==”或“<”)也是较常用的一类运算符,同样,若类对象间需要 完成比较操作,也应完成对关系运算符的重载。关系运算符重载的过程非常直观。 重载关系运算符一般都返回true或false值。

关系运算符共有六个,并且相互之间有对应关系,如小于运算符“<”与大于运算 符“>”对应,因此对于关系运算符的重载应成对完成。

可重载为类的成员函数也可重载为类的友元函数(具有对称性的运算符通常重载为 类的友元函数)

案例

#include 
using namespace std;
 
class A
{
private:
    int x, y;
public:
    A(int x1 = 0, int y1 = 0)
    {
        x = x1;
        y = y1;
    }
    friend bool operator>(const A& a1,const A& a2);
    friend bool operator<(const A& a1,const A& a2);
    friend bool operator==(const A& a1, const A& a2);
};
bool operator>(const A& a1, const A& a2)
{
    return a1.x > a2.x;
}
bool operator<(const A& a1, const A& a2)
{
    return a1.x < a2.x;
}
bool operator==(const A& a1, const A& a2)
{
    return a1.y == a2.y;
}
int main()
{
    A a1(1, 2);
    A a2(3, 2);
    if (a1 > a2)
    {
        cout << "a1的x大于a2的x"<

输出结果

a1的x小于a2的x
 
a1的y都等于a2的y


重载了”>”,”<”,”==”的关系运算符,其他的也是一样,重载关系运算符之后可以直 接比较对象的大小,实际上”>”,”<”只是比较了对象中的x值,”==”只是比较了对象 中的y值,

重载关系运算符的准则
(1)关系运算符都要成对的重载。如:重载了“<”运算符,就要重载“>” 运算符,反之亦然。

(2)“==”运算符应该具有传递性。如:a==b,b==c,则a==c成立。

(3)当成对出现运算符重载时,可以把一个运算符的工作委托给另一个运算 符。如:重载“!=”运算符是在“==”运算符的基础上,重载“<”运算 符 由重载过的“>”运算符来实现。

你可能感兴趣的:(c++,c++,开发语言)