C++实验21 运算符重载

合集下载

C运算符重载PPT课件

C运算符重载PPT课件

//如果参数
index超出规定的范围,则输出越界信息
{ cout<<"\nError:下标"<<index<<"出界!"<<'\n';
exit(2);
//stdlib.h
}
return arp[index]; //如果不越界,则返回 相应的数据
}
第28页/共35页
void main(void)
{
CArray m1(10),m2(3);
int len;
int *arp;
public:
CArray(int n=0);
~CArray() {if (arp) delete[]arp;}
int & operator[] (int index);
义重载的下标运算符
};
// 定
第26页/共35页
CArray::CArray(int n)
{
if(n>0){
第14页/共35页
3. 复合运算符+= (利用成员函数重载) C C:: operator+=(C m ) { x+=m.x; return *this; }
C a,b; a+=b;
a.operator+=(b)
第15页/共35页
3. 复合运算符+= (利用友元函数重载) 先在类中声明: friend C operator+=(C & ,C); 再在类外定义: C operator+=(C &m1, C m2 ) { m1.x+=m2.x; return m1; }

C_运算符重载_各类详细介绍

C_运算符重载_各类详细介绍
▪ 有关友元函数重载单目运算符后缀方式的表示方法,将在后 面介绍
▪ 说明
运算符重载函数 operator@()可以返回任何类型,甚至可 以是 void类型,但通常返回类型与它所操作的类的类型 相同,这样可使重载运算符用在复杂的表达式中。例如, 在例7-2中,可以将几个复数连续进行加、减、乘、除的 运算。
用友元函数重载单目运算符时,需要一个显式的操作数, 例7-3中,用友元函数重载单目运算符“-”
#include<iostream.h> class nclass{ int a,b; public:
nclass(int x=0,int y=0) { a=x;b=y;} friend nclass operator -(nclass obj); void show(); };
▪ complex operator+(complex com1,complex com2) { return complex(com1.real+com2.real,com1.imag+com2.imag;}
▪ 这种方法是直接将一个无名临时对象创建到主调函数中,那么 运行效率高于前一种。
▪ 单目运算符重载
nclass operator-(nclass obj) { obj.a=-obj.a;
obj.b=-obj.b; return obj;} void nclass::show() { cout<<"a="<<a<<" b"<<b;} ▪ main() ▪{ ▪ nclass ob1(10,20),ob2; ▪ ob1.show(); ▪ ob2=-ob1; ▪ ob2.show(); ▪ return 0; ▪}

C语言运算符的重载详解

C语言运算符的重载详解

C语⾔运算符的重载详解⽬录写⼀个Add函数为什么不⽤加号作为函数名运算符的重载上⾯问题解决总结写⼀个Add函数我们先讨论下⾯代码,并复习前⾯的内容class Complex{private:double Real, Image;public:Complex() :Real(0), Image(0) {}Complex(double r, double i) :Real(r), Image(i) {}~Complex() {}//Complex Add(const Complex* const this,const Complex &c)Complex Add(const Complex& x)const{Complex y;y.Real = Real + x.Real;y.Image = Image + x.Image;return y;//return Complex(this->Real + x.Real, this->Image + x.Image);}void Print(){cout << Real << "+" << Image << "i" << endl;}};int main(){Complex c1(12, 23);Complex c2(4.5, 5.6);Complex c3;c3 = c1.Add(c2);c3.Print();return 0;}直接return可以使⽤⽆名函数直接代替将亡值对象,相⽐可以省⼀次对象的构建我们再分析如果我们使⽤引⽤返回Add函数const Complex& Add(const Complex& x)const{Complex y;y.Real = Real + x.Real;y.Image = Image + x.Image;return y;//return Complex(this->Real + x.Real, this->Image + x.Image);}若我们以引⽤返回,将亡值对象会创建在Add函数的栈帧中,然后返回将亡值地址,函数return结束该空间会被释放、若没有引⽤,构建⽆名对象也就是将亡值对象会构建在主函数的空间中,这⾥使⽤将亡值对象值给到c3是没有问题的我们查看对象的构造与析构class Complex{private:double Real, Image;public:Complex() :Real(0), Image(0) {}Complex(double r, double i) :Real(r), Image(i){cout << "Create:" << this << endl;}Complex(const Complex& x):Real(x.Real),Image(x.Image){cout << "Copy Create:" << this << endl;}~Complex(){cout << "~Complex:" << this << endl;}//Complex Add(const Complex* const this,const Complex &c)Complex Add(const Complex& x)const{return Complex(this->Real + x.Real, this->Image + x.Image);}void Print(){cout << Real << "+" << Image << "i" << endl;}};int main(){Complex c1(12, 23);Complex c2(4.5, 5.6);Complex c3;c3 = c1.Add(c2);c3.Print();return 0;}⾸先我们使⽤引⽤返回需要加上const修饰,这是因为我们返回将亡值在临时空间具有常性,所以普通引⽤是不能进⾏返回的,需要使⽤常引⽤返回const Complex& Add(const Complex& x)const{return Complex(this->Real + x.Real, this->Image + x.Image);}我们发现对临时对象的构建后马上就进⾏析构,那么是怎么将数据拿出给到c3的?这个在最后我们进⾏分析为什么不⽤加号作为函数名//Complex operator+(const Complex* const this,const Complex &c)Complex operator+(const Complex &c) const{return Complex(this->Real + x.Real, this->Image + x.Image);}这⾥是不可以的,加号是⼀个操作符,不能使⽤操作放作为有效的函数名称;但是在C++中为了使这些操作符号能够当作函数名,那么我们需要在前⾯加上⼀个关键字operator//Complex operator+(const Complex* const this,const Complex &c)Complex operator+(const Complex &c) const{return Complex(this->Real + x.Real, this->Image + x.Image);}也就是告诉编译器,加号是⼀个有效的函数名,这就叫做运算符的重载;随后我们之间使⽤ c3 = c1 + c2 就是可以的int main(){Complex c1(12, 23);Complex c2(4.5, 5.6);Complex c3;c3 = c1 + c2;//编译器编译会是下⾯的情况//c3 = c1.operator+(c2);//c3 = operator+(&c1,c2); 加上this指针}运算符的重载⼀个对象,编译器会给它有6个缺省函数我们再来看下⾯这个问题//我们写⼀个赋值运算符重载void operator=(const Object& obj){this->value = obj.value;}//返回类型为void,这样不可以就不可以连等//obja = objb = objc;//obja = objb.operator=(objc);//obja = operator=(&objb,objc); 返回的⽆类型,不能给obja赋值且赋值函数不可以定义为const修饰Object& operator=(const Object& obj){this->value = obj.value;return *this;}obja = objb = objc;//改写obja = objb.operator=(objc);obja = operator=(&objb,objc);obja.operator=(operator=(&objb,objc));operator=(&obja,operator=(&objb,objc));通过返回对象,就可以实现连等;并且我们可以通过引⽤返回,因为此对象的⽣存期并不受函数的影响,不会产⽣⼀个临时对象作为⼀个过度防⽌⾃赋值若是我们将obja给obja赋值,也就是⾃赋值obja = objaoperator=(&obja,obja);我们就需要进⾏⼀步判断Object& operator=(const Object& obj){if(this != &obj)//防⽌⾃赋值{this->value = obj.value;}return *this;}上⾯问题解决我们通过这段代码来看,与上⾯问题相同Object& operator=(const Object& obj){if (this != &obj){this->value = obj.value;}return *this;}};Object& fun(const Object& obj){int val = obj.Value() + 10;Object obja(val);return obja;}int main(){Object objx(0);Object objy(0);objy = fun(objx);cout << objy.Value() << endl;return 0;}我们在这⾥希望通过引⽤返回,这⾥return的临时对象会构建在fun函数的栈帧中,并且在函数结束栈帧释放,随后调⽤赋值运算符重载,但是数值依旧是正确的我们跟踪这个被析构对象的地址,⾸先我们定位在fun函数的return obja;,随后进⼊析构函数将我们的obja进⾏析构接着运⾏到回到主函数进⾏赋值,接着进⼊赋值运算符重载,可以看到,这⾥的obj地址与已被析构的obja地址相同可以看到这个值依旧存在,依旧可以打印给出,这是因为vs2019的特殊性质造成的;我们每次运⾏程序会发现每次的对象地址都在变化,逻辑地址会随机改变,被析构对象的栈帧不会被接下来的赋值运算符重载扰乱地址空间,所以即使我们引⽤返回的对象已经死亡依旧可以将数值正确返回但是在vc中,我们得到的值会是随机值,这是因为vc中每次运⾏程序地址都不会改变,当我们从fun函数退出进⼊赋值语句中,就会将原本存储数据的地址扰乱,继⽽变成了随机值尽管我们引⽤返回能够将数据正确打印,但是该对象已经死亡,这是不安全的,所以我们⼀定不要以引⽤返回对象VS2019具有⼀个特点:当我们调⽤函数,若函数中没有定义局部变量或局部对象时,该函数基本不对栈帧进⾏清扫总结到此这篇关于C语⾔运算符的重载详解的⽂章就介绍到这了,更多相关C语⾔运算符重载内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持!。

C++实验21 运算符重载

C++实验21 运算符重载

实验21 运算符重载一、实验目的和要求1.理解运算符重载的作用。

2.掌握实现运算符重载的方法及几种特殊运算符的重载格式。

3.进一步锻炼针对类的编程能力。

二、实验准备☞知识点1.运算符重载定义的一般格式、基本概念。

2.运算符函数重载的两种形式。

3.通过成员函数实现运算符重载的一般格式。

4.通过友元函数实现运算符重载的一般格式。

5.”++”运算符的重载。

6.”=”赋值运算符的重载。

☞课前练习题1.重载运算”+”,实现a+b运算,则。

A.a必须为对象,b可为整数或实数B.a和b必须为对象C.b必须为对象,a可为整数或实数D.a和b均可为整数或实数2.在C++中,运算符的重载有两种实现方法,一种是通过成员函数来实现,另一种则通过_________来实现。

3.不能重载的5个运算符是:______、______、______、______、_________。

4.重载赋值运算符必须通过________函数实现。

5.用成员函数实现前置”--”运算符重载的一般格式为:_______________________________。

6.用友元函数实现后置”--”运算符重载的一般格式为:_______________________________。

☞分析1.有以下程序:#include<iostream.h>class C{private:double x;public:C( ) { x=0.0; }C(double a) { x=a; }friend C operator--(C t) //行A{t.x--;return t;}void show(){cout<<x<<endl;}};void main(){C c(5.6);(--c).show(); //行Bc.show(); //行C}请回答问题:①从行A 的形式上看,这是利用________函数实现__________运算符的重载。

[C++]运算符重载实验报告

[C++]运算符重载实验报告

+operator+(const COMPLEX &other): COMPLEX+operator-(const COMPLEX &other) : COMPLEX+operator-(): COMPLEX+operator=(const COMPLEX &other) : COMPLEX运行结果2. 程序的类结构图为:Tx,y:int+T(int a,int b)+&operator<<(ostream &os,T &a):friend ostream运行结果3. 程序的类结构图为:Shape+Area():virtual double const+PrintShapeName():virtual void const +Print():virtual void constPointx,y:int+Point(int=0,int=0)+SetPoint(int a,int b):void+GetX():int const+GetY():int const+PointShapeName():virtual void const +Print():virtual void constCircleradius:double+Circle(int x=0,int y=0,double r=0.0) +SetRadius(double r):void+GetRadius():double const+Area():virtual double const+Print():virtual void const+PrintShapeName():virtual void const 运行结果{cout<<'['<<x_size<<","<<y_size<<']'<<", "<<'['<<i_size<<","<<j_size<<']'; }int main(){Circle1 circle(0.0,0.0,3.0);circle.area();circle.perimeter();circle.print();cout<<"\n";Square1 square(0.0,0.0,3.0,3.0);square.area();square.perimeter();square.print();cout<<"\n";cout<<"圆的面积为:"<<circle.area()<<endl;cout<<"圆的周长为:"<<circle.perimeter()<<endl;cout<<"圆的圆心坐标和半径为:";circle.print();cout<<"\n\n";cout<<"正方形的面积为:"<<square.area()<<endl;cout<<"正方形的周长为:"<<square.perimeter()<<endl;cout<<"正方形的中心坐标和一个顶点坐标分别为:";square.print();cout<<"\n";return 0;}运行结果【实例编程】运行结果。

C++程序设计运算符重载实验报告

C++程序设计运算符重载实验报告
(3)能区分单目运算符的前置与后置。
二、实验内容与设计(主要内容,操作步骤、算法描述或程序代码)
本次实验主要实现以下内容:
【项目内容】
定义一个复数类Complex,重载运算符“+”,“-”,“*”,“/”“++”“--”“>”“<”,使之能用于复数的加、减、乘、除、自增、自减、比较大小。运算符重载函数作为Complex类的成员函数。编程序,分别求两个复数之和、差、积、商、自增、自减、比较大小。 提示:注意复数的乘、除法计算。
//重载*
Complexoperator*(Complex a,Complex b){
Complex t;
t.r=a.r*b.r-a.i*b.i;
t.i=b.r*b.i+b.i*b.r;
returnt;
}
//重载/
Complexoperator/(Complex a,Complex b) {
Complex t;
专业:计算机科学与技术年级班级:13计科
学生姓名:侯瑄学号:222013321210092
实验教师:陈睿
计算机与信息科学学院软件学院
实验项目名称
C++程序设计运算符重载
实验时间
2015.10.25
实验类型
□验证性□设计性□综合性
一、实验目的和要求
(1)掌握通过运算符重载实现多态性的方法;
(2)学会运算符重载的成员函数法和友元函数法;
cout<<r;
if(i>0) cout<<"+";
if(i!=0) cout<<i<<"i"<<endl;

C++运算符重载三种形式(成员函数,友元函数,普通函数)详解

C++运算符重载三种形式(成员函数,友元函数,普通函数)详解

C++运算符重载三种形式(成员函数,友元函数,普通函数)详解三种重载⽅式⾸先,介绍三种重载⽅式:1//作为成员函数重载(常见)2class Person{3 Private:4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}8bool operator<(const Person& b);910 };11bool Person::operator<(const Person& b)12 {13//作为成员函数时,*this即为左操作数a14 ...15 }1//作为友元函数重载2class Person{3private:4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}8 friend bool operator<(const Person& a,const Person& b);910 };11bool operator<(const Person& a,const Person& b)12 {13 ...14 }1//作为普通函数重载(不推荐)2class Person{3public://注意,重载运算符为普通函数时,使⽤到的类成员必须为public4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}89 };10bool operator<(const Person& a,const Person& b)11 {12 ...13 }作为成员函数重载先介绍第⼀种:bool Person::operator<(const Person& b),bool是函数返回类型,Person::只是指定了成员函数所属类名。

C++实验报告之静态成员、运算符重载

C++实验报告之静态成员、运算符重载

题目1:定义一个复数类,通过重载运算符:*,/,直接实现二个复数之间的乘除运算。

编写一个完整的程序,测试重载运算符的正确性。

要求乘法“*”用友元函数实现重载,除法“/”用成员函数实现重载。

源程序1/*******************第1题*******************//******************单森汉*****************//******************2012-5-1*****************/#include<iostream>using std::cout;using std::endl;class Complex{float Real, Image;public:Complex(float r=0,float i=0) { Real=r;Image=i;}void Show(){cout <<"Real="<<Real<<'\t'<<"Image="<<Image<<'\n';}friend Complex operator *(Complex &, Complex &);Complex operator /(Complex &); //重载运算符+Complex operator +( Complex &);friend Complex operator -(Complex &, Complex &);};Complex operator *( Complex &c1,Complex &c2){Complex t;t.Real=c1.Real * c2.Real - c1.Image * c2.Image;t.Image = c1.Image*c2.Real +c1.Real* c2.Image;return t;}Complex Complex::operator /(Complex &c){Complex t;t.Real =(Real *c.Real+ Image * c.Image)/(c.Real*c.Real+ c.Image * c.Image);t.Image = (Image *c.Real - Real * c.Image)/(c.Real*c.Real+ c.Image * c.Image);return t;}Complex Complex::operator + ( Complex &c){Complex t;t.Real = Real + c.Real;t.Image = Image + c.Image;return t;}Complex operator -(Complex &c1, Complex &c2){Complex t;t.Real=c1.Real-c2.Real;t.Image=c1.Image-c2.Image;return t;}void main(){Complex c1(1,2),c2(3,4),c3;c3=c1*c2;cout<<"两个复数的乘法c3=c1*c2:";c3.Show();c3=c1/c2;cout<<"两个复数的除法c3=c1/c2:";c3.Show();Complex c4(1,2),c5(3,4),c6,c7(1,2),c8(3,0),c9; c6=c4+c5;cout<<"两个复数的加法c6=c4+c5:";c6.Show();c6=c4-c5;cout<<"两个复数的减法c6=c4-c5:";c6.Show();c9=c7+c8;cout<<"一个复数与一个实数的加法c9=c7+c8:"; c9.Show();c9=c7-c8;cout<<"一个复数与一个实数的减法c9=c7-c8:"; c9.Show();}运行结果截图题目2:定义一个向量(一维数组)类,通过重载运算符实现向量之间的加法和减法。

C 程序设计(谭浩强完整版)运算符重载

C  程序设计(谭浩强完整版)运算符重载
第十三章
运算符重载
1
函数的重载 所谓函数的重载是指完成不同功能的函数可以具 有相同的函数名。 C++的编译器是根据函数的实参来确定应该调用 哪一个函数的。
int fun(int a, int b) void main(void) { cout<<fun(3,5)<<endl; cout<<fun(5)<<endl; }
由这个函数来完成该运算符应该完成的操作。这 种函数称为运算符重载函数,它通常是类的成员 函数或者是友元函数。运算符的操作数通常也应 该是类的对象。
6
重载为类的成员函数
格式如下:
关键字 <类名> operator<运算符>(<参数表>)
{ 函数体 } 函数名 运算的对象
运算的对象
返回类型
A operator + (A &);
15
class A { int i; public:A(int a=0){ i=a; } void Show(void){ cout<<"i="<<i<<endl; } A operator +(A &a) //重载运算符+ { A t; t.i=i+a.i; return t; } void operator+=(A &a) { i=i+a.i; } 由左操作符调用右操 }; 作符,没有返回值, void main(void) 故函数类型为void。 { A a1(10),a2(20),a3; a1.Show (); a2.Show (); 相当于a3=a1.operator+(a2) a3=a1+a2; a1+=a2; 相当于a1.operator+=(a2) a3.Show (); }

C++实验报告(10)运算符重载

C++实验报告(10)运算符重载
指导老师:年月日
填写内容时,可把表格扩大。
{cout<<"num:"<<num<<"\nname:"<<name<<"\nsex:"<<sex<<"\npay:"<<pay<<"\n\n";}
int main()
{Teacher teacher1(10001,"Li",'f',1234.5),teacher2;
Student student1(20010,"Wang",'m',89.5);
Complex operator+(int &i);
friend Complex operator+(int&,Complex &);
void display();
private:
double real;
double imag;
};
Complex Complex::operator+(Complex &c)
return c;}
Complex Complex::operator/(Complex &c2)
{Complex c;
c.real=(real*c2.real+imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);
c.imag=(imag*c2.real-real*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);

运算符重载—C++课程实验报告

运算符重载—C++课程实验报告
#include<iostream>
using namespace std; class AB
{
public:
AB(int xx, int yy); void ShowAB(); AB& operator ++(); AB operator ++(int);
AB& operator --();
AB operator --(int);
通过这次实验我基本掌握了通过运算符重载实现多态性的方法学会了运算符重载的成员函数法和友元函数法基本能够区分单目运算符的前置与后置
C++
学生姓

xxx
班级
学号
xxxxxxxxx
实验项

实验四运算符重载
指导教师
杜之波
实验目
的和要

一、实验目的
(1)掌握通过运算符重载实现多态性的方法;
(2)学会运算符重载的成员函数法和友元函数法;
运算后,
A的值为:"
什+AA).ShowAB();
coutvv"
B
的值为:";
(++BB).ShowAB();
cout<v"B=A--运算后,A的值为:";
(--AA).ShowAB();
coutvv"B的值为:";
(BB--).ShowAB();
cout<<"B=--A运算后,A的值为:";
(--AA).ShowAB();
{
AB AA(0,0);
AB BB(0,0);
cout<v"A的值为:";

运算符重载实验报告

运算符重载实验报告
};
RMB::RMB(unsigned int d, unsigned int c)
{
yuan = d;
jf = c;
while ( jf >=100 ){ //以使构造时,确保角分值小于100
yuan ++;
jf -= 100;
}
}
RMB operator+(RMB& s1, RMB& s2) // 此处改为RMB& operator+(RMB& s1, RMB& s2)
private:
unsigned int yuan; //元
unsigned int jf; //角分
};
RMB RMB::interest(double rate)
{
return RMB((yuan + jf / 100.0) * rate);
}
RMB RMB::add(RMB d)
{
return RMB(yuan + d.yuan + jf / 100.0 + d.jf / 100.0);
expense2(x,yrate).display();
}
3.实验结果:
(二)实验题目二:
(2) 将以下程序中重载运算符定义函数的返回类型更改(值返回更改为引用返回,引用
返回更改为值返回),观察程序运行结果,说明原因。
#include<iostream.h>
class RMB{
public:
RMB(unsigned int d, unsigned int c);
学 号:
指导教师:
2013年11月18日

《C运算符重载》PPT课件

《C运算符重载》PPT课件
右结合:a=b=c; a.operator=(b.opertor=( c) )
h
4
二元运算符重载(2)
函数的返回值 返回引用 返回非常量值 返回常量值 返回值优化
重载+和+=运算符对(- -=, * *=, 等)
h
5
重载赋值p; operator=(const T&);
默认的赋值运算
限制赋值运算
重载赋值运算符
原因:成员有指针,并动态分配内存时。 检查自我赋值:
• 效率
• a=a; 的情况
h
6
一元运算符
全局函数 成员函数 增量/减量运算符(++/--)
前缀:T& operator++ (); 后缀:T operator++(int);
迭代器
h
7
重载运算符的方针
运算符 所有的一元运算符 = () [] -> ->* += -= *= /= ^=&=|=%=>>=<<= 成员 所有其他二元运算符
成员 非成员
建议使用 必须是成员
h
8
运算符重载
h
1
重载运算符
意义(例)
重载条件 自定义的类型 不可重载的运算符 :: . ->* 不可使用新的运算符
运算符重载 一元/二元运算符: 全局函数/成员函数
h
2
二元运算符重载(1)
全局函数格式: 成员函数的格式: 重载后的表达式形式(成员函数)
左结合:a+b+c; (a.operator+(b)).operator+(c)

C++学习之运算符重载的总结

C++学习之运算符重载的总结

C++学习之运算符重载的总结C++学习之运算符重载的总结运算符重载是对已有的运算符赋予多重含义,使同⼀个运算符作⽤域不同类型的数据导致不同⾏为的发⽣,C++为运算符重载提供了⼀种⽅法,即运算符重载函数。

其函数名字规定为operator后紧跟重载运算符。

⽐如:operator+(),operator*()等。

(1)运算符重载函数作为类的友元函数的形式: class 类名 { friend 返回类型 operator运算符(形参表); } 类外定义格式: 返回类型 operator运算符(参数表) { 函数体 }友元函数重载双⽬运算符(有两个操作数,通常在运算符的左右两则),参数表中的个数为两个。

若是重载单⽬运算符(只有⼀个操作数),则参数表中只有⼀参数。

同⼀个运算符可以定义多个运算符重载函数来进⾏不同的操作。

(2)运算符重载函数作为类的成员函数的形式: class 类名 { 返回类型 operator 运算符(形参表); } 类外定义格式: 返回类型类名:: operator 运算符(形参表) { 函数体; }对于成员函数重载运算符⽽⾔,双⽬运算符的参数表中仅有⼀个参数,⽽单⽬则⽆参数。

同样的是重载,为什么和友元函数在参数的个数上会有所区别的。

原因在于友元函数,没有this指针。

对于双⽬运算符⽽⾔,运算符重载函数的形参中仅为⼀个参数,它作为运算符的右操作数(如com2对象),⽽当前对象作为左操作数(如:上述中的com1对象),它是通过this指针隐含传递给成员运算符重载函数的。

例如下⾯这样的定义:Complex operator+(Complex com1);//成员函数重载双⽬运算符+20Complex Complex::operator+(Complexcom1)21{22return Complex(real+com1.real,imag+com1.imag);23}对于单⽬运算符⽽⾔,当前对象作为运算符的操作数。

C++ 第二十讲_运算符重载

C++ 第二十讲_运算符重载
双目运行符重载: 双目运行符重载:
例: 类名 obj1,obj2,obj3; obj1=obj2.operator+(obj3); 等价于:obj1=obj2+obj3;
双目运算符“+”的左操作数就是调用函数operator+的对象,而右操 作数就是用作函数实参的对象。这样,原先是内部预定义的双目运 算符“+”,现在就可以用作执行两个同类对象的相加。上式表示将类 对象obj2和obj3相加,得到同类的另一个对象,并将其赋邓类对象 obj1。
-17
12.2 用类的成员函数进行运算符重载
void main() { Int n(15); cout<<"n="<<n.geti()<<endl; cout<<"n++="<<(n++).geti()<<endl; cout<<"Now n="<<n.geti()<<endl; cout<<"++n="<<(++n).geti()<<endl; cout<<"Now n="<<n.geti()<<endl; cout<<"(n++)++="<<((n++)++).geti()<<endl; cout<<"Now n="<<n.geti()<<endl; cout<<"++(++n)="<<(++(++n)).geti()<<endl; cout<<"Now n="<<n.geti()<<endl; cout<<endl; cout<<"n="<<n.geti()<<endl; cout<<"n--="<<(n--).geti()<<endl; cout<<"Now n="<<n.geti()<<endl; cout<<"--n="<<(--n).geti()<<endl; cout<<"Now n="<<n.geti()<<endl; cout<<"(n--)--="<<((n--)--).geti()<<endl; cout<<"Now n="<<n.geti()<<endl; cout<<"--(--n)="<<(--(--n)).geti()<<endl; cout<<"Now n="<<n.geti()<<endl; }

C程序设计运算符重载资料

C程序设计运算符重载资料


{
目的对象与源对象不是同一个对象

……
复制被被赋值对象

}

*;
返回目的对象
•}
*重载赋值运算符“=”
• 如用户没有为一个类重载赋值运算符,编译程序将生成一个默认赋值运算符函数。赋值运算 把源对象的数据成员逐个地复制到目的对象的相应数据成员
0;
返回值0, 返回操作系统
}
程序运行时屏幕输出如下: 6 -6 请按任意键继续. . .
用类的友元函数重载双目运算符
• 将双目运算符重载为类的友元函数时,友元函数形参表中包含有两个参数,这两个参数分别 作为运算符的左、右操作数。
例4.6 双目运算符重载为类的友元函数示例。
<>
编译预处理命令
;
使用命名空间
例4.8 双目运算符重载为普通函数示例。 声明整型类
{
:
数据成员
;
数据值
:
公有函数
( n = 0): (n){ }
构造函数
( n) { = n; }
设置数据值
() { ; } 返回数据值
};
( , ) 重载运算符"+"
{ (() + ()); }
()
主函数()
{
i(6), j(9), k;
定义整型对象
例4.5 单目运算符重载为类的友元函数示例。
<>
编译预处理命令
;
使用命名空间
声明整型类
{
: 数据成员
在 6.0下会出现的编译时错语,是 6.0的一个,在
<> ;;
编译预处理:
:
改为:
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验21 运算符重载一、实验目的和要求1.理解运算符重载的作用。

2.掌握实现运算符重载的方法及几种特殊运算符的重载格式。

3.进一步锻炼针对类的编程能力。

二、实验准备☞知识点1.运算符重载定义的一般格式、基本概念。

2.运算符函数重载的两种形式。

3.通过成员函数实现运算符重载的一般格式。

4.通过友元函数实现运算符重载的一般格式。

5.”++”运算符的重载。

6.”=”赋值运算符的重载。

☞课前练习题1.重载运算”+”,实现a+b运算,则。

A.a必须为对象,b可为整数或实数B.a和b必须为对象C.b必须为对象,a可为整数或实数D.a和b均可为整数或实数2.在C++中,运算符的重载有两种实现方法,一种是通过成员函数来实现,另一种则通过_________来实现。

3.不能重载的5个运算符是:______、______、______、______、_________。

4.重载赋值运算符必须通过________函数实现。

5.用成员函数实现前置”--”运算符重载的一般格式为:_______________________________。

6.用友元函数实现后置”--”运算符重载的一般格式为:_______________________________。

☞分析1.有以下程序:#include<iostream.h>class C{private:double x;public:C( ) { x=0.0; }C(double a) { x=a; }friend C operator--(C t) //行A{t.x--;return t;}void show(){cout<<x<<endl;}};void main(){C c(5.6);(--c).show(); //行Bc.show(); //行C}请回答问题:①从行A 的形式上看,这是利用________函数实现__________运算符的重载。

②行B 的输出结果:_________,行C 的输出结果:_________。

③上机验证输出结果,并且回答行B 和行C 的输出结果一样吗?为什么?2.已知C 为某类名,以下是”+”和”+=”的运算符重载函数。

C C:: operator+(C &m ) //利用成员函数重载{C temp;temp.x=x+m.x;return temp; //行A}friend C operator+(C &m1, C &m2 ) //利用友元函数重载{C temp;temp.x=m1.x+m2.x;return temp; //行B}C &C:: operator+=(C &m ) //利用成员函数重载{x+=m.x;return *this; //行C}要求:①三个函数参数均为对象的引用(也可不用引用),请解释这样做的好处?_____________________________________________________________。

②行A 和行B 为何不写成:return *this; ,如行C ?__________________________________________________________________________。

三、实验内容1.定义一个类MatrixAdd ,其数据成员为一个M*N 的矩阵(即二维数组),其中M 和N 是两个预先定义的符号常数。

通过重载运算符”+”和”=”,实现矩阵相加和赋值运算。

如定义矩阵A=⎥⎦⎤⎢⎣⎡654321和B=⎥⎦⎤⎢⎣⎡333222,通过运算C=A+B ,得到结果矩阵C=⎥⎦⎤⎢⎣⎡987543。

具体要求如下:(1)私有数据成员int a[M][N]:存放二维数组值。

(2)公有成员函数● MatrixAdd ( ):缺省构造函数,空操作。

● MatrixAdd ( int x[M][N]):构造函数,用x 初始化数据成员a 。

● MatrixAdd operator+(MatrixAdd &b):重载加法运算符”+”,实现两个矩阵相加。

● void operator=(MatrixAdd &b):重载赋值运算符”=”,实现两个矩阵赋值。

● void show( ):按二维方式输出a 数组。

(3)在主函数中完成对该类的测试。

注意:在程序的开头,定义符号常数M 和N 的值分别为2和3,表示二维数组的行数和列数。

在主函数中定义整型数组a[M][N]和b[M][N],它们的初值取上述示例值。

定义三个Matrix 类的对象A 、B 和C ,并用数组a 和b 初始化对象A 和B 。

将A 加B 后赋值给C 。

然后输出对象C 的数据成员a 矩阵的值。

2.建立分数类Fraction ,用于表示最简分数。

最简分数为分子分母没有公约数的分数。

该分数类重装运算符+和-,分别实现两个分数的加法和减法。

具体要求如下:(1)私有数据成员● int m :分子。

● int n :分母。

(2)公有成员函数● Fraction(int _m,int _n):构造函数,用_m 、_n 分别初始化m 、n ,同时对分数进行约简,使其成为最简分数。

● int gcd(int x,int y):求x 和y 的最大公约数(对分数进行约简时用到),注意结果要为正数。

● Fraction operator+(Fraction &b):重载双目加法运算。

● Fraction operator-(Fraction &b):重载双目减法运算。

● void show():输出分数,格式为m/n 。

(3)在主函数中完成对该类的测试。

定义分数a 和b ,其初值分别为-1/3与6/12,求出它们的和与差并分别赋值给分数c 和d ,最后输出c 和d 。

正确的运行结果为:1/6-5/63.设a 为M 行N 列的二维数组,编程将a 中的每个元素向右移动一列,最右一列换到最左一列,移动后的数组仍然存放在a 中,试建立一个类TDarray ,完成以上操作。

例如,原始数组以及移动元素之后的数组如下:具体要求如下:(1)私有数据成员● int a[M][N]:存入二维数组的值,M 、N 为预定义的符号常量。

(2)公有成员函数● TDarray(int x[M][N]):构造函数,用x 数组初始化数组a 。

● void move():将数组a 的每个元素向右移动一列。

● void print():按矩阵方式输出数组a 。

(3)在主函数中完成对该类的测试。

在程序的开头定义符号常数M 和N 的值分别为3和4。

在主函数中定义二维数组int x[M][N],用以上数据赋初值。

定义一个TDarray 类的对象arr , 1 2 3 5 6 7 9 10 11 1 2 3 4 5 6 7 8 9 10 11用数组x初始化该对象,通过arr调用成员函数,首先输出数组的原始值,然后移动并输出移动后的数组值。

4.建立一个类ComposeStr,连接两个字符串后,将结果字符串中的字符按升序排列。

例如,字符串s1的值为”pear”,字符串s2的值为”apple”,将s1和s2连接后得到字符串”pearapple”,存入字符数组s3,排序后得”aaeelpppr”。

具体要求如下:(1)私有数据成员●char s1[80],s2[80]:存放两个原始字符串。

●char s3[160]:存放结果字符串。

(2)公有成员函数●ComposeStr (char a[ ], char b[ ]):构造函数,用字符串参数a和b分别初始化数据成员s1和s2。

●void compose( ):合并字符串后存入s3。

●void asort( ):对s3中的字符升序排序。

●void show( ):输出两个原始字符串和结果字符串。

(3)在主程序中定义两个字符数组char a[80],b[80],任意输入两个字符串,再定义一个ComposeStr类的对象str,用字符串a和b初始化该对象,然后按上述要求测试该类。

四、课后练习题1.通过重载运算符”=”和”+”,实现字符串类的赋值与拼接。

# include<iostream.h># include<string.h>class String{char * str;public:String (char * s=0){if(s){str=new char[strlen(s)+1];strcpy(str,s);}else str=0;}~ String(){if(str)delete[]str;}friend String operator+(const String&, const String &);String & operator=(String &);void Show(){if(str) cout<<str<<'\n';}};String operator+(const String &s1, const String &s2){String t;t.str=new char ;strcpy(t.str,s1.str);strcat(t,str,s2.str);return ;}String & String∷operator=(String &s){if(str) ;str=new char[strlen(s.str)+1];strcpy(str,s.str);return ;}void main(void){String s1(Computer"),s2("tests"),s3;s1.Show();s2.Show();s3=s1+s2;s3.Show();}2.通过重载运算符”>”实现字符串类的比较运算。

重载构造函数实现字符串对象的初始化。

# include<iostream.h># include<string.h>class String{char * str;public:String(char * s=0){if( ){str=new char[ ];strcpy(str,s);}else str=0;}String(String &);~ String(){ if(str) delete [] str;}int operator>(String &);void Show(){ if(str)cout<<str<<'\n';}}String∷String(String &s){if( ){str=new char[ ];strcpy(str,s.str);}else str=0;}int String∷operator>(String &s){if(strcmp(str,s.str)>0) return 1;else return 0;}void main(void){String s1("Computer"),s2("tests"),s3(s1);s1.Show();s2.Show();s3.Show();cout<<(s1>s2)<<'\n';}3.通过重载运算符”+”,直接实现两个一维数组对应元素相加的运算。

相关文档
最新文档