我不明白操作符重载到底有什么用?

Tomorrow0 2003-08-29 09:02:11
耐着性子看了操作符重载这一章,每个字我都认识,可脑子里就是一片空白,我真的看不懂,重载操作符有什么实际作用?
...全文
216 25 打赏 收藏 转发到动态 举报
写回复
用AI写文章
25 条回复
切换为时间正序
请发表友善的回复…
发表回复
Wolf0403 2003-08-31
  • 打赏
  • 举报
回复
如果使用时候符号左边是你的数据类型,那么就重载为成员函数;否则就是友元
Tomorrow0 2003-08-31
  • 打赏
  • 举报
回复
那么什么时候应重载为友元函数,何时又为成员函数?
ruanzheng13 2003-08-30
  • 打赏
  • 举报
回复
使代码简单明了
tonybaobao 2003-08-30
  • 打赏
  • 举报
回复
当然不建议你把+重载成-咯!
kof99 2003-08-30
  • 打赏
  • 举报
回复
刚开始学 运算符重载,感觉既简单,又有许多隐藏的复杂性. 光书上说到的可能引起的错误就有一大堆.所以我觉得要少用重载. 只有能够使程序更简单易懂的情况下才用.
我的理解就是 重载使程序的可读性更好.
meteor135 2003-08-30
  • 打赏
  • 举报
回复
////////////////////////////////////////////////////////
/////////运算符重载机制实现集合运算例程/////////////////
////////////////////////////////////////////////////////
/*
原题目要求:
编写一个程序,使用类存储字符集合,可以用运算符添加删除字符,
也可以用运算符将两个集合相加、相减。
在原题目要求的基础上扩充了部分功能。
能实现大多数的集合操作。

作者:meteor135 meteor@mail.biti.edu.cn
日期:2003.8.29
版本号:0.6
编译环境:VC6.0
http://www.programfan.net/club/showbbs.asp?id=17146
*/
//郑重声明:该程序没有实现动态性,因而测验时不能无限扩容

#pragma warning(disable: 4172)

#include<iostream>
using namespace std;

class Set;

//友员函数声明

//或
Set operator + (const Set set1, const Set set2);
//差
Set operator - (const Set set1, const Set set2);
//交
Set operator * (const Set set1, const Set set2);
//异或
Set operator / (const Set set1, const Set set2);
//流式输出
ostream& operator << (ostream& os, const Set set);

class Set
{
private:
char len[50];//集合最大容量为50
public:
Set()
{
len[0]=0;
}
//成员函数重载
Set operator = (Set set);
Set& operator + (char word);
Set& operator - (char word);
Set& operator += (Set set);
Set& operator -= (Set set);
Set& operator *= (Set set);
Set& operator /= (Set set);
bool operator < (Set set) const;
bool operator > (Set set) const;
bool operator <= (Set set) const;
bool operator >= (Set set) const;
bool operator == (Set set) const;
bool operator != (Set set) const;

//只能用友员函数重载
friend ostream& operator << (ostream& os, const Set set);
//友员函数重载
friend Set operator + (const Set set1, const Set set2);
friend Set operator - (const Set set1, const Set set2);
friend Set operator * (const Set set1, const Set set2);
friend Set operator / (const Set set1, const Set set2);

bool isMember (char word) const;
void show();
};

//==============================================
//friend operators
Set operator + (const Set set1, const Set set2)
{
Set set = set1;
return set.operator += (set2);
}
Set operator - (const Set set1, const Set set2)
{
Set set = set1;
return set.operator -= (set2);
}
Set operator * (const Set set1, const Set set2)
{
Set set = set1;
return set.operator *= (set2);
}
Set operator / (const Set set1, const Set set2)
{
Set set = set1;
return set.operator /= (set2);
}

ostream& operator << (ostream& os, const Set set)
{
int i=0;
while(set.len[i])
os<<set.len[i++];
os<<"\n";
return os;
}
//================================================
//end friend operators

//=============================================
//member operators
void Set::show()
{
cout<<(*this);
}

bool Set::isMember(char word) const{
int i;
for(i=0;len[i];i++){
if(word==len[i]){
return true;
}
}
return false;
}
//集合拷贝
Set Set::operator=(Set set)
{
int i = 0;
do
{
this->len[i]=set.len[i];
}while(set.len[i++]);
return (*this);
}
//集合增容
Set& Set::operator+(char word)
{
int i;
i=strlen(len);
if(!isMember(word))
len[i]=word;
len[i+1]=0;
return *this;
}
//集合消减
Set& Set::operator-(char word)
{
int i;
for(i=0;len[i];i++)
{
if(len[i]==word)
{
for(;len[i];i++)
{
len[i]=len[i+1];
}
break;
}
}
return *this;
}
//包含
bool Set::operator >= (Set set) const
{
int i = 0;
for(i = 0;set.len[i]; i ++)
{
if(!isMember(set.len[i]))
return false;
}
return true;
}
//包含于
bool Set::operator <= (Set set) const
{
return(set>=(*this));
}
//相等
bool Set::operator==(Set set) const
{
int i = 0;
if ((*this<=set)&&(*this>=set))
return true;
return false;
}
//不等
bool Set::operator!=(Set set) const
{
return !((*this)==set);
}
//真包含
bool Set::operator > (Set set) const
{
if(*this>=set&&!(*this<=set))
return true;
return false;
}
//真包含于
bool Set::operator < (Set set) const
{
return(set>*this);
}
//交赋值
Set& Set::operator *= (Set set)
{
return (*this) - (::operator -(*this,set));
}
//异或赋值
Set& Set::operator /= (Set set)
{
return (*this += set) -= (::operator *(*this,set));
//or
//return (*this) = ::operator +(::operator -(*this,set),::operator -(set,*this));
}
//或赋值
Set& Set::operator += (Set set)
{
int i;
for(i=0;set.len[i];i++)
if(!isMember(set.len[i]))
(*this)+set.len[i];
return (*this);
}
//差赋值
Set& Set::operator -= (Set set)
{
int i;
for(i=0;set.len[i];i++)
if(isMember(set.len[i]))
(*this)-set.len[i];
return (*this);
}
//=============================================
//end member operators

int main()
{
Set set1,set2,set3,set4;
//测试+
set1+'a'+'b'+'c'+'d';
//测试<<
cout<<set1;
set1.show();
set2+'c'+'d'+'e'+'f';
set2.show();
set3 +'a';
set3.show();
//测试>
cout<<(set1>set3)<<endl;
//测试<
cout<<(set1<set3)<<endl;
//测试*和=
set3 = set1*set2;
set3.show();
//测试/和=
set3 = set1/set2;
set3.show();
//测试-
set1-'a';
set1+'f';
set1.show();
//测试=
set3=set1;
//测试==
cout<<(set1==set3)<<endl;
cout<<(set1==set2)<<endl;
//测试::+
set3=set1+set2;
set3.show();
//测试::-
set4=set1-set2;
set4.show();
//测试::-后set1和set4是否相等
cout<<(set1==set4)<<endl;
//其他测试自行解决

return 0;
}
gernal_dn 2003-08-30
  • 打赏
  • 举报
回复
操作符(operator)本质上与函数没有区别,重载操作符就是重载函数。
一般而言,我们更习惯于看自然语言(英文、中文)和数学语言(加减乘除),比如,我们说一加二,更习惯于表达成1+2,而不是1 add 2 或是什么 1 add(2) 之类的东西,这让我们看着别扭,并且干扰我们的思维。
举个例子,C++中虽然提供了整数、浮点数的加法(当然还有String等其他),但没有提供矩阵(matrix)的加法,假如我们实现了class matrix,那么最好为matrix重载 operator +等其他操作符,这样,我们的矩阵运算表达式就与数学上的表达式一样或接近。
sjd163 2003-08-30
  • 打赏
  • 举报
回复
使运算有模糊处理的特性。
nazha 2003-08-30
  • 打赏
  • 举报
回复
C++才有的东西因为他是面向对象的,三要素是封装、继承、多态。实现多态的三个方法就是:函数重载、运算符重载、虚函数。
idontlikenickname 2003-08-30
  • 打赏
  • 举报
回复


应该是挺多的,比如你要做一个矩阵类,用操作符向矩阵对象中添加元素就可以重载操作符"<<",总之你有完全的权利把操作符重载成任何形式(比如你说的+变-),但是最重要的还是要使重载后的程序看起来清楚明了,而不是越来越晦涩~

idontlikenickname 2003-08-30
  • 打赏
  • 举报
回复


应该是挺多的,比如你要做一个矩阵类,用操作符向矩阵对象中添加元素就可以重载操作符"<<",总之你有完全的权利把操作符重载成任何形式(比如你说的+变-),但是最重要的还是要使重载后的程序看起来清楚明了,而不是越来越晦涩~

Tomorrow0 2003-08-30
  • 打赏
  • 举报
回复
你们在实际的使用,软件的制作中用的频繁吗?
null2002 2003-08-30
  • 打赏
  • 举报
回复
可以使代码更简洁。
不过我认为主要的作用是,抽象出一个操作,可以让用户不关心它的实现,而轻松使用。

不过我不喜欢它。
eddyxu 2003-08-30
  • 打赏
  • 举报
回复
可以让你从逻辑上来理解,比方矢量加法等等
idontlikenickname 2003-08-29
  • 打赏
  • 举报
回复


完全可以,如果你要把自己弄糊涂~~

Tomorrow0 2003-08-29
  • 打赏
  • 举报
回复
操作符重载就是函数调用,照这么说的话这个函数的具体实现是否可以由我随心所欲?
比方我可以把+重载成-?
  • 打赏
  • 举报
回复
同意楼上的解释!
idontlikenickname 2003-08-29
  • 打赏
  • 举报
回复


让你的程序写得更漂亮~

SmileWolf 2003-08-29
  • 打赏
  • 举报
回复
这个问题要从两方面来看:
首先,操作符重载,虽然书写形式比较怪,但它实际上就是函数调用,而且是类的成员函数的调用。如果你不重载操作符,那么你也得写一个函数来处理诸如把一个对象间赋值、两对象相加、相减等操作。
其次就是当年创造出C++人高手们有一个原则问题:自己写的类也是一种数据类型,所以它要和语言内部的int、char、double等类型一样对待。这样的话,就需要操作符重载了。因为两个int型的变量可以用a+b求和,那么自己定义的类对象要想求和时,就也用“+”号来写,而不能调用一个Sum()函数了。
这样,操作符重载这种比较蹩脚的成员函数调用形式就诞生了。
lemon520 2003-08-29
  • 打赏
  • 举报
回复
运算符重载就是为了解决用户(你自己)自定义类型对象之间的运算操作!
完全是为了方便用户(别人),所以你也可以不用重载运算符!
加载更多回复(5)

69,336

社区成员

发帖
与我相关
我的任务
社区描述
C语言相关问题讨论
社区管理员
  • C语言
  • 花神庙码农
  • 架构师李肯
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧