c++操作符重载
2015-06-22 15:13
344 查看
C++中的操作符重载
一、什么是操作符重载
操作符重载可以分为两部分:“操作符”和“重载”。说到重载想必都不陌生了吧,这是一种编译时多态,重载实际上可以分为函数重载和操作符重载。运算符重载和函数重载的不同之处在于操作符重载重载的一定是操作符。我们不妨先直观的看一下所谓的操作符重载:
我们看到操作符“+”完成float和int两种类型的加法计算,这就是操作符重载了。这些内置类型的操作符重载已经实现过了,但是如果现在我们自己写过的类也要实现实现类似的加法运算,怎么办呢??比如现在现在有这样一个点类point,要实现两个点的相加,结果是横纵坐标都要相加,这时候就需要我们自己写一个操作符重载函数了。
View
Code
二、实现操作符重载的两种方式
操作符重载的实现方式有两种,即通过“友元函数”或者“类成员函数”。
1.友元函数重载操作符的格式:
2.类成员函数实现操作符重载的格式:
这样说吧,还是不足以比较这两种实现方式的区别,我们分别用两种实现方式写point类的”+“和”-“的重载。代码如下:
View
Code
这里不知道大家看到没有,利用友元函数重载二元操作符”-“时,形式参数是两个,而利用类成员函数时,形式参数却只有一个。这时因为类成员函数中存在this指针,这相当于一个参数,所以类成员实现操作符重载需要的形式参数比原来少一个,这比如:利用类成员函数实现一元操作符”-“,就不需要参数了。也正是因为这个原因,友元函数实现的操作符重载是有限制的,比如:[] ,(),->和 =不能利用友元函数实现运算符的重载。
在实际开发过程中,单目运算符建议重载为成员函数,而双目运算符建议重载为友元函数。通常下双目运算符重载为友元函数比重载为成员函数更方便,但是有时双目运算符必须重载为成员函数,例如赋值运算符=。还有如果需要修改对象内部的状态,一般可以选择利用类成员函数进行修改。
三、运算符重载的原则
这样一看,运算符重载还是蛮简单的嘛,实际上运算符重载也是要遵循一些原则的:
1.C++中只能对已有的C++运算符进行重载,不允许用户自己定义新的运算符。
2.C++中绝大部分的运算符可重载,除了成员访问运算符.,作用域运算符::,长度运算符sizeof以及条件运算符?:。
3.运算符重载后不能改变运算符的操作对象(操作数)的个数。如:"+"是实现两个操作数的运算符,重载后仍然为双目运算符。
4.重载不能改变运算符原有的优先级和原有的结合性。
6.运算符重载不能全部是C++中预定义的基本数据,这样做的目的是为了防止用户修改用于基本类型数据的运算符性质。
四、为什么要进行运算符重载
关于运算符重载要遵循这么多原则,那么为什么还要进行运算符重载呢?为什么我不是写一个add()函数,代替operator +()呢??个人感觉C++中之所以要支持运算符的重载是为了与内置数据类型统一操作,比如:c = a + b 和 c = add(a,b),这看起来哪个更直观一点呢,显然是前者了。同时,我们希望操作我们自己定义的数据类型能像操作int和double这些内置数据类型一样方便。可能举这个加法的例子有点不好,现在加入重载的运算符是[],<<,^,|等呢?这时我们要用什么成员函数代替呢??代替之后又是一种什么效果呢?会一眼就看出来这个函数要干什么吗??
操作符的重载有一些规则:
1. 重载操作符必须具有一个类类型或枚举类型操作数。这条规则强制重载操作符不能重新定义用于内置类型对象的操作符的含义。
如: int operator+(int, int), 不可以
2. 为类设计重载操作符的时候,必须选择是将操作符设置为类成员还是普通非成员函数。在某些情况下,程序没有选择,操作符必须是成员;在另外一些情况下,有些经验可以指导我们做出决定。下面是一些指导:
a. 赋值(=),下标([]),调用(())和成员访问箭头(->)等操作符必须定义为成员,将这些操作符定义为非成员函数将在编译时标记为错误。
b. 像赋值一样,复合赋值操作符通常应定义为类的成员。与赋值不同的是,不一定非得这样做,如果定义为非成员复合赋值操作符,不会出现编译错误。
c. 改变对象状态或与给定类型紧密联系的其他一些操作符,如自增,自减和解引用,通常应定义为类成员。
d 对称的操作符,如算术操作符,相等操作符,关系操作符和位操作符,最好定义为普通非成员函数。
e io操作符必须定义为非成员函数,重载为类的友元。
[cpp] view
plaincopy
// OverloadCinCout.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "iostream"
#include "string"
using namespace std;
class Fruit
{
public:
Fruit(const string &nst = "apple", const string &cst = "green"):name(nst),colour(cst){}
~Fruit(){}
friend ostream& operator << (ostream& os, const Fruit& f); //输入输出流重载,不是类的成员,
friend istream& operator >> (istream& is, Fruit& f); // 所以应该声明为类的友元函数
private:
string name;
string colour;
};
ostream& operator << (ostream& os, const Fruit& f)
{
os << "The name is " << f.name << ". The colour is " << f.colour << endl;
return os;
}
istream& operator >> (istream& is, Fruit& f)
{
is >> f.name >> f.colour;
if (!is)
{
cerr << "Wrong input!" << endl;
}
return is;
}
int _tmain(int argc, _TCHAR* argv[])
{
Fruit apple;
cout << "Input the name and colour of a kind of fruit." << endl;
cin >> apple;
cout << apple;
return 0;
}
一、什么是操作符重载
操作符重载可以分为两部分:“操作符”和“重载”。说到重载想必都不陌生了吧,这是一种编译时多态,重载实际上可以分为函数重载和操作符重载。运算符重载和函数重载的不同之处在于操作符重载重载的一定是操作符。我们不妨先直观的看一下所谓的操作符重载:
1 #include <iostream> 2 3 using namespace std; 4 5 int main() 6 { 7 int a = 2 , b = 3; 8 float c = 2.1f , d = 1.2f; 9 cout<<"a + b = "<<a+b<<endl; 10 cout<<"c + d = "<<c+d<<endl; 11 return 0; 12 }
我们看到操作符“+”完成float和int两种类型的加法计算,这就是操作符重载了。这些内置类型的操作符重载已经实现过了,但是如果现在我们自己写过的类也要实现实现类似的加法运算,怎么办呢??比如现在现在有这样一个点类point,要实现两个点的相加,结果是横纵坐标都要相加,这时候就需要我们自己写一个操作符重载函数了。
View
Code
1 #include <iostream> 2 3 using namespace std; 4 5 class point 6 { 7 double x; 8 double y; 9 public: 10 double get_x() 11 { 12 return x; 13 } 14 double get_y() 15 { 16 return y; 17 } 18 point(double X = 0.0 , double Y = 0.0):x(X),y(Y){}; 19 point operator +(point p); 20 }; 21 //重载操作符“+” 22 point point::operator +(point p) 23 { 24 double x = this->x + p.x; 25 double y = this->y + p.y; 26 point tmp_p(x,y); 27 return tmp_p; 28 } 29 int main() 30 { 31 point p1(1.2,3.1); 32 point p2(1.1,3.2); 33 point p3 = p1+p2; 34 cout<<p3.get_x()<<" "<<p3.get_y()<<endl; 35 return 0; 36 }
二、实现操作符重载的两种方式
操作符重载的实现方式有两种,即通过“友元函数”或者“类成员函数”。
1.友元函数重载操作符的格式:
1 class 类名 2 { 3 friend 返回类型 operator 操作符(形参表); 4 }; 5 //类外定义格式: 6 返回类型 operator操作符(参数表) 7 { 8 //函数体 9 }
2.类成员函数实现操作符重载的格式:
1 class 类名 2 { 3 public: 4 返回类型 operator 操作符(形参表); 5 }; 6 //类外定义格式 7 返回类型 类名::operator 操作符(形参表) 8 { 9 //函数体 10 }
这样说吧,还是不足以比较这两种实现方式的区别,我们分别用两种实现方式写point类的”+“和”-“的重载。代码如下:
View
Code
1 #include <iostream> 2 3 using std::endl; 4 using std::cout; 5 6 class point 7 { 8 double x; 9 double y; 10 public: 11 double get_x() 12 { 13 return x; 14 } 15 double get_y() 16 { 17 return y; 18 } 19 point(double X = 0.0 , double Y = 0.0):x(X),y(Y){}; 20 friend point operator -(point p1,point p2); 21 point operator +(point p); 22 }; 23 //重载操作符“-” 24 point operator -(point p1,point p2) 25 { 26 double x = p1.get_x() - p2.get_x(); 27 double y = p1.get_y() - p2.get_y(); 28 point p3(x,y); 29 return p3; 30 } 31 //重载操作符“+” 32 point point::operator +(point p) 33 { 34 double x = this->x + p.x; 35 double y = this->y + p.y; 36 point tmp_p(x,y); 37 return tmp_p; 38 } 39 int main() 40 { 41 point p1(1.2,3.2); 42 point p2(1.1,3.1); 43 point p3 = p1+p2; 44 point p4 = operator-(p1,p2); 45 cout<<p3.get_x()<<" "<<p3.get_y()<<endl; 46 cout<<p4.get_x()<<" "<<p4.get_y()<<endl; 47 return 0; 48 }
这里不知道大家看到没有,利用友元函数重载二元操作符”-“时,形式参数是两个,而利用类成员函数时,形式参数却只有一个。这时因为类成员函数中存在this指针,这相当于一个参数,所以类成员实现操作符重载需要的形式参数比原来少一个,这比如:利用类成员函数实现一元操作符”-“,就不需要参数了。也正是因为这个原因,友元函数实现的操作符重载是有限制的,比如:[] ,(),->和 =不能利用友元函数实现运算符的重载。
在实际开发过程中,单目运算符建议重载为成员函数,而双目运算符建议重载为友元函数。通常下双目运算符重载为友元函数比重载为成员函数更方便,但是有时双目运算符必须重载为成员函数,例如赋值运算符=。还有如果需要修改对象内部的状态,一般可以选择利用类成员函数进行修改。
三、运算符重载的原则
这样一看,运算符重载还是蛮简单的嘛,实际上运算符重载也是要遵循一些原则的:
1.C++中只能对已有的C++运算符进行重载,不允许用户自己定义新的运算符。
2.C++中绝大部分的运算符可重载,除了成员访问运算符.,作用域运算符::,长度运算符sizeof以及条件运算符?:。
3.运算符重载后不能改变运算符的操作对象(操作数)的个数。如:"+"是实现两个操作数的运算符,重载后仍然为双目运算符。
4.重载不能改变运算符原有的优先级和原有的结合性。
6.运算符重载不能全部是C++中预定义的基本数据,这样做的目的是为了防止用户修改用于基本类型数据的运算符性质。
四、为什么要进行运算符重载
关于运算符重载要遵循这么多原则,那么为什么还要进行运算符重载呢?为什么我不是写一个add()函数,代替operator +()呢??个人感觉C++中之所以要支持运算符的重载是为了与内置数据类型统一操作,比如:c = a + b 和 c = add(a,b),这看起来哪个更直观一点呢,显然是前者了。同时,我们希望操作我们自己定义的数据类型能像操作int和double这些内置数据类型一样方便。可能举这个加法的例子有点不好,现在加入重载的运算符是[],<<,^,|等呢?这时我们要用什么成员函数代替呢??代替之后又是一种什么效果呢?会一眼就看出来这个函数要干什么吗??
操作符的重载有一些规则:
1. 重载操作符必须具有一个类类型或枚举类型操作数。这条规则强制重载操作符不能重新定义用于内置类型对象的操作符的含义。
如: int operator+(int, int), 不可以
2. 为类设计重载操作符的时候,必须选择是将操作符设置为类成员还是普通非成员函数。在某些情况下,程序没有选择,操作符必须是成员;在另外一些情况下,有些经验可以指导我们做出决定。下面是一些指导:
a. 赋值(=),下标([]),调用(())和成员访问箭头(->)等操作符必须定义为成员,将这些操作符定义为非成员函数将在编译时标记为错误。
b. 像赋值一样,复合赋值操作符通常应定义为类的成员。与赋值不同的是,不一定非得这样做,如果定义为非成员复合赋值操作符,不会出现编译错误。
c. 改变对象状态或与给定类型紧密联系的其他一些操作符,如自增,自减和解引用,通常应定义为类成员。
d 对称的操作符,如算术操作符,相等操作符,关系操作符和位操作符,最好定义为普通非成员函数。
e io操作符必须定义为非成员函数,重载为类的友元。
[cpp] view
plaincopy
// OverloadCinCout.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "iostream"
#include "string"
using namespace std;
class Fruit
{
public:
Fruit(const string &nst = "apple", const string &cst = "green"):name(nst),colour(cst){}
~Fruit(){}
friend ostream& operator << (ostream& os, const Fruit& f); //输入输出流重载,不是类的成员,
friend istream& operator >> (istream& is, Fruit& f); // 所以应该声明为类的友元函数
private:
string name;
string colour;
};
ostream& operator << (ostream& os, const Fruit& f)
{
os << "The name is " << f.name << ". The colour is " << f.colour << endl;
return os;
}
istream& operator >> (istream& is, Fruit& f)
{
is >> f.name >> f.colour;
if (!is)
{
cerr << "Wrong input!" << endl;
}
return is;
}
int _tmain(int argc, _TCHAR* argv[])
{
Fruit apple;
cout << "Input the name and colour of a kind of fruit." << endl;
cin >> apple;
cout << apple;
return 0;
}
相关文章推荐
- vc++6.0错误
- C++ 复习
- C语言中的undefined behavior
- 2015-第14周项目4-处理C++源代码的程序
- C++数组的简单示例
- [LeetCode] Basic Calculator II
- [转]Visual C++ RunTime的特征——非烫即屯
- 学习C++编程时,遇到过的小问题
- C++学习笔记__类的派生和多态性
- C++程序设计--对象分册(第5章)
- C++中模板声明与实现的分离问题
- 学习笔记---单例的C++实现(从大神那看到的)
- 1 通过JNI混合使用Java和C++ -----> 操作字符串
- 输出以下图案
- c++使用流迭代器istream_iterator和ostream_iterator
- C语言学习笔记(六)——其他编程知识
- C语言学习笔记(五)——指针【C语言的灵魂】
- C语言(2)数据类型、常量、Printf、sizeof、scanf的使用
- C++函数模板
- C++类构造函数初始化列表,子类向父类传参数