[019]转--C++ operator关键字(重载操作符)

原博客:http://www.cnblogs.com/speedmancs/archive/2011/06/09/2076873.html

operator是C++的关键字,它和运算符一起使用,表示一个运算符函数,理解时应将operator=整体上视为一个函数名。

这是C++扩展运算符功能的方法,虽然样子古怪,但也可以理解:

一方面要使运算符的使用方法与其原来一致,另一方面扩展其功能只能通过函数的方式(c++中,“功能”都是由函数实现的)。

一、为什么使用操作符重载?

对于系统的所有操作符,一般情况下,只支持基本数据类型和标准库中提供的class,对于用户自己定义的class,如果想支持基本操作,比如比较大小,判断是否相等,等等,则需要用户自己来定义关于这个操作符的具体实现。比如,判断两个人是否一样大,我们默认的规则是按照其年龄来比较,所以,在设计person 这个class的时候,我们需要考虑操作符==,而且,根据刚才的分析,比较的依据应该是age。

那么为什么叫重载呢?这是因为,在编译器实现的时候,已经为我们提供了这个操作符的基本数据类型实现版本,但是现在他的操作数变成了用户定义的数据类型class,所以,需要用户自己来提供该参数版本的实现。

二、如何声明一个重载的操作符?

A:  操作符重载实现为类成员函数

重载的操作符在类体中被声明,声明方式如同普通成员函数一样,只不过他的名字包含关键字operator,以及紧跟其后的一个c++预定义的操作符。

可以用如下的方式来声明一个预定义的==操作符:

1 class person{
2 private:
3     int age;
4 public:
5     person(int a){
6         this->age=a;
7     }
8     inline bool operator == (const person &ps) const;
9 };

实现方式如下:

1 inline bool person::operator==(const person &ps) const
2 {
3     if (this->age==ps.age)
4         return true;
5     return false;
6 }

调用方式如下:

1 #include
2 using namespace std;
3 int main()
4 {
5     person p1(10);
6     person p2(20);
7     if(p1==p2) cout<<”the age is equal!”< return 0;
8 }

这里,因为operator ==是class person的一个成员函数,所以对象p1,p2都可以调用该函数,上面的if语句中,相当于p1调用函数==,把p2作为该函数的一个参数传递给该函数,从而实现了两个对象的比较。

B:操作符重载实现为非类成员函数(全局函数)

对于全局重载操作符,代表左操作数的参数必须被显式指定。例如:

 1 class person
 2 {
 3 public:
 4     int age;
 5 public:
 6 };
 7
 8 bool operator==(person const &p1 ,person const & p2)
 9     //满足要求,做操作数的类型被显示指定
10 {
11     if(p1.age==p2.age)
12         return true;
13     return false;
14 }

调用方式如下:

1 int main()
2 {
3     person rose;
4     person jack;
5     rose.age=18;
6     jack.age=23;
7     if(rose==jack)
8         cout<<"ok"< return 0;
9 }

C:如何决定把一个操作符重载为类成员函数还是全局名字空间的成员呢?

①如果一个重载操作符是类成员,那么只有当与他一起使用的左操作数是该类的对象时,该操作符才会被调用。如果该操作符的左操作数必须是其他的类型,则操作符必须被重载为全局名字空间的成员。

②C++要求赋值=,下标[],调用(), 和成员指向-> 操作符必须被定义为类成员操作符。任何把这些操作符定义为名字空间成员的定义都会被标记为编译时刻错误。

③如果有一个操作数是类类型如string类的情形那么对于对称操作符比如等于操作符最好定义为全局名字空间成员。

以下是C++ operator重载的例子


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

105

106

107

108

109

110

111

#include <iostream>

using namespace std;

class A

{

public:

    A(double _data = 0.0):data(_data){}

    A& operator = (const A& rhs)

    {

        data = rhs.data;

        return *this;

    }

    

    friend A operator + (const A& lhs,const A& rhs);

    friend A operator - (const A& lhs,const A& rhs);

    friend A operator * (const A& lhs,const A& rhs);

    friend A operator + (const A& lhs,double rhs);

    friend A operator + (double lhs,const A& rhs);

    friend A operator * (const A& lhs,double rhs);

    friend A operator * (double lhs,const A& rhs);

    friend A operator - (const A& lhs,double rhs);

    friend A operator - (double lhs,const A& rhs);

    

    

    friend ostream& operator << (ostream& fout,A& a);

//  A& operator += (const A& rhs);

//  A& operator -= (const A& rhs);

//  A& operator *= (const A& rhs); 

private:

    double data;

};

A operator + (const A& lhs,const A& rhs)

{

    A res(0);

    res.data = lhs.data + rhs.data;

    return res;

}

A operator - (const A& lhs,const A& rhs)

{

    A res(0);

    res.data = lhs.data - rhs.data;

    return res;

}

A operator * (const A& lhs,const A& rhs)

{

    A res(0);

    res.data = lhs.data * rhs.data;

    return res;

}

 A operator + (const A& lhs,double rhs)

 {

    A res(0);

    res.data = lhs.data + rhs;

    return res;

}

A operator + (double lhs,const A& rhs)

{

    A res(0);

    res.data = lhs + rhs.data;

    return res;

}

A operator * (const A& lhs,double rhs)

{

    A res(0);

    res.data = lhs.data * rhs;

    return res;

}

A operator * (double lhs,const A& rhs)

{

    A res(0);

    res.data = lhs * rhs.data;

    return res;

}

A operator - (const A& lhs,double rhs)

{

    A res(0);

    res.data = lhs.data - rhs;

    return res;

}

A operator - (double lhs,const A& rhs)

{

    A res(0);

    res.data = lhs - rhs.data;

    return res;

}

    

ostream& operator << (ostream& fout,A& a)

{

    fout << a.data ;

    return fout;

}

int main(int argc, char* argv[])

{

    A a(2.3);

    A b(1.2);

    A d(3.4);

    A c;

    c = a + b + d;

    c=a+b;

    c=a+1.0;

    c=a-b;

    c=a-1.0;

    c=a*b;

    c=a*1.0;

    cout << c << endl;

    

    c=1.0+2.0*a*a-3.0*a*b;

    cout << c << endl;

    return 0;

}

时间: 2024-07-29 20:06:11

[019]转--C++ operator关键字(重载操作符)的相关文章

C++ operator(重载操作符) 【转】

转自:http://www.cnblogs.com/xiangxiaodong/archive/2012/02/12/2348144.html operator是C++的关键字,它和运算符一起使用,表示一个运算符函数,理解时应将operator=整体上视为一个函数名. 这是C++扩展运算符功能的方法,虽然样子古怪,但也可以理解:一方面要使运算符的使用方法与其原来一致,另一方面扩展其功能只能通过函数的方式(c++中,“功能”都是由函数实现的).  一.为什么使用操作符重载?对于系统的所有操作符,一

[c++primer][14]重载操作符与转换

14.1 重载操作符的定义 不能重载的操作符:.  ?:  sizeof  ::  .* 不能为任何内置类型定义额外的新的操作符:优先级和结合性是固定的:不再具备短路求值特性(不建议重载&&.||.逗号): 一般将算术和关系操作符定义为非成员函数,而将赋值操作符定义为成员: 使用重载操作符的方式: 1)  与内置类型使用操作符方式一样: 2)  也可像调用普通函数一样调用重载操作符函数,指定函数并传递适当类型适当数目的形参: item1 += item2; // expression ba

C++ Primer 学习笔记_58_重载操作符与转换 --重载操作符的定义

重载操作符与转换 --重载操作符的定义 引言: 明智地使用操作符重载可以使类类型的使用像内置类型一样直观! 重载操作符的定义 重载操作符是具有特殊名称的函数:保留字operator后接定义的操作符符号.如: Sales_item operator+(const Sales_item &,const Sales_item &); 除了函数调用操作符之外,重载操作符的形参数目(包括成员函数的隐式this指针)与操作符的操作数数目相同.函数调用操作符可以接受任意数目的操作数. 1.重载的操作符名

重载操作符与转换

?  重载操作符的定义 重载操作符是具有特殊名称的函数:保留字operator 后接需定义的操作符号.像任意其他函数一样,重载操作符具有返回类型和形参表,如下语句: Sales_item  operator+(const Sales_item&, constSales_item&); ?  可以和不可以重载的操作符 ?  重载操作符必须具有一个类类型操作数,这条规则强制重载操作符不能重新定义用于内置类型对象的操作符的含义. ?  操作符的优先级.结合性或操作数不能改变. ?  重载操作符并

C++中operator关键字(重载操作符)

operator是C++的关键字,它和运算符一起使用,表示一个运算符函数,理解时应将operator=整体上视为一个函数名. 这是C++扩展运算符功能的方法,虽然样子古怪,但也可以理解:一方面要使运算符的使用方法与其原来一致,另一方面扩展其功能只能通过函数的方式(c++中,“功能”都是由函数实现的).  一.为什么使用操作符重载? 对于系统的所有操作符,一般情况下,只支持基本数据类型和标准库中提供的class,对于用户自己定义的class,如果想支持基本操作,比如比较大小,判断是否相等,等等,则

转载:C++ operator关键字(重载操作符)

C++ operator关键字(重载操作符) 转自:http://blog.sina.com.cn/s/blog_4b3c1f950100kker.html operator是C++的关键字,它和运算符一起使用,表示一个运算符函数,理解时应将operator=整体上视为一个函数名. 这是C++扩展运算符功能的方法,虽然样子古怪,但也可以理解:一方面要使运算符的使用方法与其原来一致,另一方面扩展其功能只能通过函数的方式(c++中,“功能”都是由函数实现的).  一.为什么使用操作符重载?对于系统的

C++重载操作符operator

operator是C++关键字,用于对C++进行扩展: 1.可以被重载的操作符:new,new[],delete,delete[],+,-,*,/,%,^,&,|,~,!,=,<,>,+=,<<,>>,<<=,>>=,++,!=,<=,>=,&&,||,++,--,->*,->,(),[] 不可以被重载的操作符:.  .* :: ?: 2.基类对赋值操作符(=)重载不能被派生类继承. “+”操作符重

C++的重载操作符(operator)介绍(转)

本文主要介绍C++中的重载操作符(operator)的相关知识. 1. 概述 1.1 what operator 是C++的一个关键字,它和运算符(如=)一起使用,表示一个运算符重载函数,在理解时可将operator和运算符(如operator=)视为一个函数名. 使用operator重载运算符,是C++扩展运算符功能的方法.使用operator扩展运算符功能的原因如下: 使重载后的运算符的使用方法与重载前一致扩展运算符的功能只能通过函数的方式实现(实际上,C++中各种"功能"都是由函

重载操作符 &#39;operator&#39;

operator 是 C++ 的(运算符的)重载操作符.用作扩展运算符的功能. 它和运算符一起使用,表示一个运算符函数,理解时应将  [operator+运算符] 整体上视为一个函数名. 要注意的是:一方面要使运算符的使用方法与其原来一致,另一方面扩展其功能只能通过函数的方式(c++中,"功能"都是由函数实现的). 使用时: [返回类型] [operator+运算符] (const ElemType&a)const  {...} 为什么需要重载操作符? 系统的所有操作符,一般情