任务十二 运算符的重载——复数运算
c++运算符重载复数加减乘除
c++运算符重载复数加减乘除C++中的复数是由实部和虚部组成的数字,可以使用运算符重载来实现复数的加减乘除操作。
对于加法和减法,我们只需将实部和虚部分别相加或相减即可。
对于乘法,我们需要使用以下公式:(a+bi)×(c+di) = (ac-bd) + (ad+bc)i其中,a、b、c、d分别为复数的实部和虚部。
对于除法,我们需要使用以下公式:(a+bi) / (c+di) = ((ac+bd)/(c+d)) + ((bc-ad)/(c+d))i 实现时,我们需要在类中重载相应的运算符。
以下是一个示例程序:```#include <iostream>using namespace std;class Complex {private:float real, imag;public:Complex(float r = 0, float i = 0) : real(r), imag(i) {} Complex operator+(const Complex &c) {return Complex(real + c.real, imag + c.imag);}Complex operator-(const Complex &c) {return Complex(real - c.real, imag - c.imag);}Complex operator*(const Complex &c) {float r = real * c.real - imag * c.imag;float i = real * c.imag + imag * c.real;return Complex(r, i);}Complex operator/(const Complex &c) {float r = (real*c.real + imag*c.imag) / (c.real*c.real + c.imag*c.imag);float i = (imag*c.real - real*c.imag) / (c.real*c.real + c.imag*c.imag);return Complex(r, i);}void show() {cout << '(' << real << ' + ' << imag << 'i)' << endl;}};int main() {Complex c1(2, 3), c2(4, 5);Complex c3 = c1 + c2;c3.show(); // (6 + 8i)c3 = c1 - c2;c3.show(); // (-2 - 2i)c3 = c1 * c2;c3.show(); // (-7 + 22i)c3 = c1 / c2;c3.show(); // (0.560976 + 0.0243902i)return 0;}```运行结果:```(6 + 8i)(-2 - 2i)(-7 + 22i)(0.560976 + 0.0243902i)```以上是一个简单的复数运算符重载示例,可以根据需要进行扩展和优化。
运算符重载——精选推荐
运算符重载运算符重载学习运算符重载,让运算符能做⼀些原来做不了的事情,⽅便它的使⽤⼀、运算符重载的概念1、什么是运算符重载1.重载:重新载⼊,就像之前学的函数重载,对⼀个已有的函数赋值⼀个新的定义,因此同⼀个函数名就可以有不同的含义。
2.运算符也是可以重载的,⽐如cout在输出⼀个变量的时候,能接受不同类型的数据并输出,他就是重载了<<运算符,这个就是运算符重载3.所以运算符重载指的是对已有的运算符重新定义新的运算规则,以适应不同的数据类型,当然重载之后之前的运算规则还是有的2、为什么要进⾏运算符重载1.运算符重载之后可以让运算符去适应不同的数据类型,对于基本数据类型,系统给出了运算符的操作规则,对于⾃定义数据类型来说,系统不知道该给出什么规则class student{int id;int age;char name[20];public:student(int id,int age,const char* name){this->id=id;this->age=age;strcpy(this->name,name);}}student stu1(1,23,"张三");student stu2(2,24,"李四");stu1+stu2;//如果是这样相加,那么应该加的是什么呢?编译器是不知道的,所以编译器就提供了运算符重载这个机制,让⽤户⾃定义运算符的运算规则⼆、运算符重载1、运算符重载类中定义1.关键字:operator,通过关键字来定义运算符重载(跟写个函数⼀样)2.定义:函数返回值类型 operator 要加载的运算符(参数列表){函数体;}这⾥把运算符的使⽤,理解为调⽤函数,只是和平时的调⽤函数有⼀点区别#include<iostream>#include<string>using namespace std;class student{int id;int age;string name;public:student(int age){this->age = age;id = 1;name = "sss ";}student(int id, int age, string name){this->id = id;this->age = age;this->name = name;}void showstudent(){cout << id << "\t" << age << "\t" << name << endl;}student operator+(student& p1)//这个函数会返回⼀个新的对象{int x=this->age + p1.age;student p(x);return p;//返回的是⼀个对象,会调⽤拷贝构造}int operator-(int x){return this->id - x;}void operator+(student&p2){cout << this->id + p2.id << endl;}};//1.操作这个运算符之后,返回值类型是什么int main(){student p1(0, 1, "yunfei");int x = p1.operator-(1);cout << x << endl;student stu1(1, 23, "张三");student stu2(2, 24, "李四");//student stu3 = stu1.operator+(stu2);//student stu3 = stu1 + stu2;stu1 + stu2;//stu3.showstudent();system("pause");return 0;}注意:因为我们这个运算符是在类中写的,所以是通过对象调⽤的,那么this指针会占⼀个参数,⽽且是第⼀个参数,也就是说我们重载⼀个运算符,是在类中,⽽这个运算符是个单⽬运算符,那么参数列表就不⽤写东西了,是双⽬运算符,那么就需要传另⼀个参数进来绝⼤部分的运算符重载都可以参照上⾯这个+号重载2、运算符重载的特点1.⼏乎所有的运算符都可以被重载,除了 . :: ()?() ) sizeof()2.运算符重载基本出现在类中和结构体中3.运算符可以理解为函数的⼀个表现3、运算符重载的注意事项1.重载运算符,这个重载的运算符还是满⾜原来的原则,但不能说重载+号,结果做的事-号的事,这样会使运算符的运⽤上增加很⼤的难度2.运算符重载的参数,类中重载调⽤对象会占⼀个参数,就是this会占⼀个参数,参数列表就是⽤来表⽰运算符的操作的3.对于运算符重载的调⽤,可以直接使⽤运算符,也可以通过对象 . 出来调⽤4.考虑返回值,不同的运算符有不同的返回值,要记得满⾜运算符原来的规则4、使⽤友元函数,实现运算符重载1.类在已经实现且部分修改的情况下下,需要进⾏运算符重载,就可以通过友元的⽅式来进⾏重载#include<iostream>#include<string>using namespace std;class person{int id;int age;string name;public:person(int id, int age, string name){this->id = id;this->age = age;this->name = name;}void showperson(){cout << id << "\t" << age << "\t" << name << endl;}friend int operator+(person&p1, person&p2);};//形参使⽤的是类对象的引⽤,在实参传对象的时候不会调⽤拷贝构造int operator+(person&p1, person&p2){return p1.id + p2.id;}//1.操作这个运算符之后,返回值类型是什么int main(){person stu1(1, 23, "张三");person stu2(2, 24, "李四");int x = operator+(stu1, stu2);//显⽰调⽤int y = stu1 + stu2;//隐式调⽤cout << x << endl << y << endl;system("pause");return 0;}容器:#include<iostream>#include<vector>using namespace std;int main(){//int 是v1这个容器存的类型vector<int> v1;for (int i = 0; i < 10; i++){//push_back()是⼀个函数,功能是尾插元素v1.push_back(i + 1);}for (int i = 0; i < 10; i++){cout << v1[i] << "\t";}system("pause");return 0;}左移右移运算符重载:#include<iostream>using namespace std;class person{int id;public:person(int id){this->id = id;}friend ostream& operator<<(ostream& os, person& p1);friend istream & operator>>(istream & in, person & p2);};//左移右移运算符重载,必须在类外重载,通过友元实现ostream& operator<<(ostream& os, person& p1)//左移运算符{os << p1.id << endl;return os;//返回的是⼀个cout,⽽且只能⽤引⽤}istream & operator>>(istream & in, person & p2)//右移运算符{in >> p2.id;return in;}int main(){person p1(10), p2(20);cin >> p1 >> p2;cout << p1 << endl << p2 << endl;system("pause");return 0;}前++,后++运算符重载:#include<iostream>using namespace std;class person{int id;public:person(int id){this->id = id;}person& operator++()//前++{this->id++;return *this;}person& operator++(int)//后++,int是⼀个占位符,⽤来区分前++和后++的{static person temp = *this;//引⽤不能返回局部变量,要⽤静态变量this->id++;return temp;}friend ostream& operator<<(ostream& os, person& p1);friend istream & operator>>(istream & in, person & p2);};//左移右移运算符重载,必须在类外重载,通过友元实现ostream& operator<<(ostream& os, person& p1)//左移运算符{os << p1.id << endl;return os;//返回的是⼀个cout,⽽且只能⽤引⽤}istream & operator>>(istream & in, person & p2)//右移运算符{in >> p2.id;return in;}int main(){person p1(10), p2(20);//cin >> p1 >> p2;//cout << p1 << endl << p2 << endl;cout << p1 ;//10cout << p1++ ;//10cout << p1 ;//11cout << ++p1 ;//12cout << p1 ;//12system("pause");return 0;}等号运算符重载:#include<iostream>using namespace std;class person{char* name;public:person(const char* name){this->name = new char[strlen(name) + 1];strcpy(this->name, name);}person& operator=(person&p1)//⽤不⽤引⽤传参,要看返回的对象会不会消失 {if (this->name != NULL){delete[]this->name;this->name = NULL;}this->name = new char[strlen() + 1];strcpy(this->name, );return *this;}void show(){cout << name << endl;}~person()//如果有申请函数,就要加上析构函数{if (name != NULL){delete[]name;name = NULL;}}};int main(){{person p1("张三"), p2("李四"), p3("王五");p1 = p2 = p3;p1.show();p2.show();p3.show();}//加上⼤括号,让对象死亡,就能调⽤析构函数system("pause");return 0;}智能指针和==号运算符重载:#include<iostream>using namespace std;class person{int id;public:person(int id){this->id = id;}void show(){cout << id << endl;}bool operator==(person& p){return this->id == p.id;}~person(){cout << "person的析构函数" << endl;}};class smartpointer{person* ps;//包含你要new出来的对象的类的指针public:smartpointer(person* p){ps = p;}//重载->person* operator->()//传回来的是地址,不是对象,不⽤引⽤{return ps;}//重载*person& operator*()//返回的是对象,会调⽤拷贝构造,所以⽤返回值⽤引⽤,就不会再调⽤拷贝构造了 {return *ps;//得到⼀个对象,}~smartpointer(){if (ps != NULL){delete ps;ps = NULL;}}};int main(){{smartpointer p(new person(5));p->show();(*p).show();person p1(1), p2(3);cout << (p1 == p2) << endl;}//有三个对象,所以析构函数执⾏了三次system("pause");return 0;}[]运算符重载:#include<iostream>using namespace std;class person{char* name;public:person(const char* name){this->name = new char[strlen(name) + 1];strcpy(this->name, name);}char& operator[](int index){return name[index];}~person(){if (name != NULL){delete[]name;name = NULL;}cout << "这是析构函数" << endl;}};int main(){person p("asdfg");cout << p[3] << endl;system("pause");return 0;}c++引⽤作为函数返回值:1.以引⽤返回函数值,定义函数时需要在函数名前加 &2.⽤引⽤返回⼀个函数值的最⼤好处是,在内存中不产⽣被返回值的副本3.返回值为引⽤的时候,返回的是⼀个地址,隐形指针4.当返回值不是引⽤时,编译器会专门给返回值分配出⼀块内存的引⽤作为返回值,必须遵守以下规则:(1)不能返回局部变量的引⽤。
运算符重载2012
int operator==(Rmb &r1,Rmb &r2) { return r1.m_yuan==r2.m_yuan&&r1.m_jiaofen= =r2.m_jiaofen; } int operator==(Rmb &r,double v) { int y,jf; y=(int)v; jf=(v-y)*100+0.5; return y==r.m_yuan&&r.m_jiaofen==jf; } int operator==(double v,Rmb &r) { int y,jf; y=(int)v; jf=(v-y)*100+0.5; return y==r.m_yuan&&r.m_jiaofen==jf; }
5
运算符重载的方法是定义一个重载运算符的函数,这个函数的原型 为:
类型 operator运算符名称(形参表); 想要重载哪个运算符就以operator加上这个运算符为函数名定义函 数,函数内部对运算符实现重载操作,根据需要返回适当的数据。在程 序中若使用这个运算符的重载计算功能,系统会自动去调用该重载函数, 以实现相应的计算。如定义函数 “Complex operator+(Complex &c1,Complex &c2);” 之后,在程序中可以使用c1+c2计算(假设c1和c2是Complex类的对象), 这时系统自动调用operator+函数以实现两个复数相加的功能。
运行结果为: r1:3.45 r2:4.56 r1不等于r2
17
14
例:定义人民币类,实现人民币对象之间比较以及人民币与实数的比较。 #include<iostream> using namespace std; class Rmb {public: Rmb(double value=0.0) { m_yuan=(int)value; m_jiaofen=(value-m_yuan)*100+0.5; } friend int operator==(Rmb &r1,Rmb &r2); friend int operator==(Rmb &r,double v); friend int operator==(double v,Rmb &r); void Display() { cout<<m_yuan+m_jiaofen/100.0<<endl; } private: int m_yuan; int m_jiaofen; };
C++学习之路—运算符重载(二)运算符重载作为类的成员函数和友元函数
C++学习之路—运算符重载(⼆)运算符重载作为类的成员函数和友元函数对运算符重载的函数有两种处理⽅式:(1)把运算符重载的函数作为类的成员函数;(2)运算符重载的函数不是类的成员函数,在类中把它声明为友元函数。
1 把运算符重载函数作为类的成员函数例1:为了便于说明问题,将重载函数的定义重写如下:1: Complex Complex :: operator + ( Complex& c2 )2: {3: Complex c ;4: c.real = real + c2.real ;5: c.imag = imag + c2.imag ;6:return c ;7: }有⼈可能会提出这样的疑问:“+”是双⽬运算符,为什么重载函数只有⼀个参数呢?实际上,运算符重载函数应当有两个参数,但是,由于重载函数是Complex类中的成员函数,因此有⼀个参数是隐含的,运算符函数是⽤this指针隐式的访问类对象的成员。
可以看到operator+访问了两个对象中的成员,⼀个是this指针指向的对象中的成员,⼀个是形参对象中的成员。
2 把运算符重载函数作为类的友元函数运算符重载函数除了可以作为类的成员函数外,还可以是⾮成员函数。
在有关的类中把它声明为友元函数,即友元运算符重载函数。
例2:将运算符+重载为适⽤于复数加法,重载函数不作为成员函数,⽽放在类外,作为Complex类的友元函数。
1:class Complex2: {3:public:4: ...5:friend Complex operator + ( Complex& c1 , Complex& c2 ) ; //重载函数作为友元函数6:private:7:double real ;8:double imag ;9: };10:11: Complex operator + ( Complex& c1 , Complex& c2 ) //定义运算符+重载函数12: {13: Complex c ;14: c.real = c1.real + c2.real ;15: c.imag = c1.imag + c2.imag ;16:return c ;17: }这个程序和把运算符重载函数作为类的成员函数相⽐,只做了⼀处改动,就是将运算符重载函数作为类外的普通函数,并在Complex类中声明它为友元函数。
运算符重载——精选推荐
运算符重载什么是运算符的重载?运算符与类结合,产⽣新的含义。
为什么要引⼊运算符重载?作⽤:为了实现类的多态性(多态是指⼀个函数名有多种含义)怎么实现运算符的重载?⽅式:类的成员函数或友元函数(类外的普通函数)规则:不能重载的运算符有 . 和 .* 和 ?: 和 :: 和 sizeof友元函数和成员函数的使⽤场合:⼀般情况下,建议⼀元运算符使⽤成员函数,⼆元运算符使⽤友元函数1、运算符的操作需要修改类对象的状态,则使⽤成员函数。
如需要做左值操作数的运算符(如=,+=,++)2、运算时,有数和对象的混合运算时,必须使⽤友元3、⼆元运算符中,第⼀个操作数为⾮对象时,必须使⽤友元函数。
如输⼊输出运算符<<和>>具体规则如下:运算符建议使⽤所有⼀元运算符成员函数= ( ) [ ] ->必须是成员函数+= -= /= *= ^= &= != %= >>= <<= , 似乎带等号的都在这⾥了成员函数所有其它⼆元运算符, 例如: –,+,*,/友元函数<< >>必须是友元函数2. 参数和返回值当参数不会被改变,⼀般按const引⽤来传递(若是使⽤成员函数重载,函数也为const).对于返回数值的决定:1) 如果返回值可能出现在=号左边, 则只能作为左值, 返回⾮const引⽤。
2) 如果返回值只能出现在=号右边, 则只需作为右值, 返回const型引⽤或者const型值。
3) 如果返回值既可能出现在=号左边或者右边, 则其返回值须作为左值, 返回⾮const引⽤。
运算符重载举例:+和 -运算符的重载:class Point{private:int x;public:Point(int x1){ x=x1;}Point(Point& p){ x=p.x;}const Point operator+(const Point& p);//使⽤成员函数重载加号运算符friend const Point operator-(const Point& p1,const Point& p2);//使⽤友元函数重载减号运算符};const Point Point::operator+(const Point& p){return Point(x+p.x);}Point const operator-(const Point& p1,const Point& p2){return Point(p1.x-p2.x);}输出:Point a(1);Point b(2);a+b; //正确,调⽤成员函数a-b; //正确,调⽤友元函数a+1; //正确,先调⽤类型转换函数,把1变成对象,之后调⽤成员函数a-1; //正确,先调⽤类型转换函数,把1变成对象,之后调⽤友元函数1+a; //错误,调⽤成员函数时,第⼀个操作数必须是对象,因为第⼀个操作数还有调⽤成员函数的功能1-a; //正确,先类型转换后调⽤友元函数总结:1、由于+ -都是出现在=号的右边,如c=a+b,即会返回⼀个右值,可以返回const型值2、后⼏个表达式讨论的就是,数和对象混合运算符的情况,⼀般出现这种情况,常使⽤友元函数3、双⽬运算符的重载:重载运算符函数名:operator@(参数表)隐式调⽤形式:obj1+obj2显式调⽤形式:obj1.operator+(OBJ obj2)---成员函数operator+(OBJ obj1,OBJ obj2)---友元函数执⾏时,隐式调⽤形式和显式调⽤形式都会调⽤函数operator+()++和--运算符的class Point{private:int x;public:Point(int x1){ x=x1;}Point operator++();//成员函数定义⾃增const Point operator++(int x); //后缀可以返回⼀个const类型的值friend Point operator--(Point& p);//友元函数定义--friend const Point operator--(Point& p,int x);//后缀可以返回⼀个const类型的值};Point Point::operator++()//++obj{x++;return *this;}const Point Point::operator++(int x)//obj++{Point temp = *this;this->x++;return temp; // 需要返回⼀个临时对象,效率不如 ++obj ⾼}Point operator--(Point& p)//--obj{p.x--;return p;//前缀形式(--obj)重载的时候没有虚参,通过引⽤返回*this 或⾃⾝引⽤,也就是返回变化之后的数值}const Point operator--(Point& p,int x)//obj--{Point temp = p;p.x--;return temp;// 后缀形式obj--重载的时候有⼀个int类型的虚参, 返回原状态的拷贝}调⽤:Point b(2);a++;//隐式调⽤成员函数operator++(0),后缀表达式++a;//隐式调⽤成员函数operator++(),前缀表达式b--;//隐式调⽤友元函数operator--(0),后缀表达式--b;//隐式调⽤友元函数operator--(),前缀表达式cout<<a.operator ++(2);//显式调⽤成员函数operator ++(2),后缀表达式cout<<a.operator ++();//显式调⽤成员函数operator ++(),前缀表达式cout<<operator --(b,2);//显式调⽤友元函数operator --(2),后缀表达式cout<<operator --(b);//显式调⽤友元函数operator --(),前缀表达式 </pre>总结:1、a++函数返回:temp(临时变量)函数返回是否是const类型:返回是⼀个拷贝后的临时变量),不能出现在等号的左边(临时变量不能做左值),函数的结果只能做右值,则要返回⼀个const类型的值++a函数返回:*this;函数返回是否是const类型:返回原状态的本⾝,返回值可以做左值,即函数的结果可以做左值,则要返回⼀个⾮const类型的值2、前后缀仅从函数名(operator++)⽆法区分,只能有参数区分,这⾥引⼊⼀个虚参数int x,x可以是任意整数。
运算符重载解读
02
在重载运算符时,应明确指定 运算符的参数类型和返回类型 ,避免与其他操作符混淆。
03
在重载运算符时,应尽量使用 有意义的操作符名称,以提高 代码的可读性。
考虑性能和效率
01
02
03
运算符重载时,应考虑 性能和效率,避免对原 有代码造成不必要的性
能损失。
在重载运算符时,应尽 量减少额外的计算和内 存开销,以提高代码的
一元运算符重载
一元运算符重载是指对一元运算符进行重载,使其能够应用于一个操作数。例如,在C中,我们可以 重载一元减号运算符(-)来返回一个数的相反数。
常见的一元运算符有:+、-、~、!等。
二元运算符重载
二元运算符重载是指对二元运算符进行重载,使其能够应用于两个操作数。例如,在C中,我们可以重载加号运算符(+)来定 义两个自定义类型的相加行为。
01
提高代码可读性
运算符重载可以使代码更易读, 因为运算符的使用可以使代码更 简洁、更直观。
02
03
方便函数调用
运算符重载可以使得函数调用更 加方便,因为运算符的使用可以 减少函数调用的开销。
04
缺点分析
易造成混淆
运算符重载可能会使得代码难以理解,因为 运算符的行为可能会被改变,导致读者难以
理解代码的含义。
常见的二元运算符有:+、-、*、/、%等。
三元运算符重载
三元运算符重载是指对三元运算符进行重载,使其能够应用于三个操作数。例如,在C中,我们可以重载条件运 算符(?)来定义一个自定义类型的条件判断行为。
常见的三元运算符有:?:。
03
运算符重载的常见场景
类与类之间的运算
01
两个类对象之间的加法运算,可以表示它们之间的某种关联或 合并。
第12章 运算符(operator)重载
什么是运算符重载
运算符重载的基本方法
运算符重载的一般规则
用成员函数重载运算符
用友元函数重载运算符
算术运算符、关系运算符的重载
1. 什么是运算符重载
(1)问题的提出:在前面的章节中,我们学习了基本数 据类型和运算符的有关内容,知道3+19、84.7-23.8 等式子是成立的。 假设已定义了日期类Date,复数类Complex 现在定义几个对象: Date d1(2008,10,1),d2(2010,11,12); Complex c1(3,4), c2(4,-5); 问题: (1)能否用 d2-d1 求出2008年国庆距离2010年广州 亚运会(第16届)开幕的天数? (2)能否用 c1+c2 求出两个复数之和?
回答是否定的! 事实上,C++预定义的+、-、*、/、>、>=、<、 <=、==、!=等一系列运算符的操作对象只能是基本 数据类型,要让它们在用户自定义的数据类型(如: 类)中也能类似使用,就需要对运算符赋予多种含 义,这就是运算符重载。 (2)运算符重载的概念:对C++中的已有运算符赋 予更多的含义,使之作用于特定类的对象,实现 特定的功能,而且使用形式与基本数据类型的形 式相同。
[操作数1] 运算符 [ 操作数2] (至少有一个操作数)
不同点:由于友元函数不属于类的成员,不存在当前 对象参与运算的问题,因此,该运算符函数的参数 个数与操作数的个数一样多。
友元函数声明、定义、调用格式如下:
(1)运算符函数(即友元函数 )的类内声明格式: friend 函数类型 operator 运算符(形参表); //参数个数为一个或两个,不可能为空 (2)运算符函数(即友元函数)的类外定义格式: //在函数名前不能加 类名和::符号 函数类型 operator 运算符(形参表) { …… //对运算符的重载处理 }
运算符重载+重载复数四则运算
实验报告第页题目:1)基本要求:•设计一个Complex(复数)类,完成如下要求:•(1)该类具有实部(Real_Part)和虚部(Image_Part)•(2)输入两个复数•(3)通过重载运算符“+”实现两个复数的相加•(4)输出相加的结果•输出时注意对齐,整齐美观2)扩展要求:•(A)重载“-”运算符,实现复数的减法。
•(B)重载“++”运算符,实现复数实部的自增源码#include<iostream.h>class Complex{public:void Complex::f_cin();//用于录入复数的函数void Complex::f_cout();//用于输出复数的函数Complex Complex::operator+(Complex c);Complex Complex::operator-(Complex c);Complex Complex::operator*(Complex c);Complex Complex::operator/(Complex c);Complex Complex::operator++(void);private:float Real_Part;float Image_Part;};//*************************************int extern a=1;//在后面用于判断是否输出结果,问:是否可以用更好的方法来判断?void main(){char ch[10];Complex c2,c1,c3;do{cout<<"输入复数c1*****************"<<endl;c1.f_cin();cout<<"输入复数c2*****************"<<endl;c2.f_cin();cout<<"加,减,乘。
运算符重载详解
运算符重载详解1.运算符重载定义:C++中预定义的运算符的操作对象只能是基本数据类型。
但实际上,对于许多⽤户⾃定义类型(例如类),也需要类似的运算操作。
这时就必须在C++中重新定义这些运算符,赋予已有运算符新的功能,使它能够⽤于特定类型执⾏特定的操作。
运算符重载的实质是函数重载,它提供了C++的可扩展性,也是C++最吸引⼈的特性之⼀。
运算符重载是通过创建运算符函数实现的,运算符函数定义了重载的运算符将要进⾏的操作。
运算符函数的定义与其他函数的定义类似,惟⼀的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。
运算符函数定义的⼀般格式如下:<返回类型说明符> operator <运算符符号>(<参数表>){<函数体>} 2.运算符重载时要遵循以下规则:(1) 除了类属关系运算符"."、成员指针运算符".*"、作⽤域运算符"::"、sizeof运算符和三⽬运算符"?:"以外,C++中的所有运算符都可以重载。
(2) 重载运算符限制在C++语⾔中已有的运算符范围内的允许重载的运算符之中,不能创建新的运算符。
(3) 运算符重载实质上是函数重载,因此编译程序对运算符重载的选择,遵循函数重载的选择原则。
(4) 重载之后的运算符不能改变运算符的优先级和结合性,也不能改变运算符操作数的个数及语法结构。
(5) 运算符重载不能改变该运算符⽤于内部类型对象的含义。
它只能和⽤户⾃定义类型的对象⼀起使⽤,或者⽤于⽤户⾃定义类型的对象和内部类型的对象混合使⽤时。
(6) 运算符重载是针对新类型数据的实际需要对原有运算符进⾏的适当的改造,重载的功能应当与原有功能相类似,避免没有⽬的地使⽤重载运算符。
(7)重载运算符的函数不能有默认的参数,否则就改变了运算符的参数个数,与前⾯第3点相⽭盾了;(8)重载的运算符只能是⽤户⾃定义类型,否则就不是重载⽽是改变了现有的C++标准数据类型的运算符的规则了,会引会天下⼤乱的;(9)⽤户⾃定义类的运算符⼀般都必须重载后⽅可使⽤,但两个例外,运算符“=”和“&”不必⽤户重载;(10)运算符重载可以通过成员函数的形式,也可是通过友元函数,⾮成员⾮友元的普通函数。
C++运算符重载实现复数类的加减乘除Microsoft Office Word 文档
cout<<"*****************-4-乘****************************"<<endl;
cout<<"*****************-5-除****************************"<<endl;
cin>>demo2.imaginary;
demo1=demo1/demo2;
break;
case 6:
++demo1;
break;
case 7:
--demo1;
break;
case 8:
flag=0;
break;
default:break;
}
cout<<"现在复数是:"<<demo1.real<<"+"<<demo1.imaginary<<"i\t"<<"mode="<<demo1.getmode()<<endl;
{
real/=obj.real;
imaginary/=obj.imaginary;
return *this;
}
double Complex::getmode()
{
double pp;
pp=pow((real*real+imaginary*imaginary),0.5);
c++运算符重载-实例-定义复数类Complex
c++运算符重载-实例-定义复数类Complex/*定义复数类Complex,数据成员:实部real,虚部image。
为该类(a)重载运算符"+",实现两个复数相加,复数与实数相加,实数与复数相加。
(b)重载前置和后置运算符"++",实现实部和虚部同时加1。
(c)重载运算符'>',实现复数大小的比较(以复数的模作为比较标准)(d)重载运算符"[ ]",实现以下标0引用实部,以下标1引用虚部。
(e)设计类型转换函数,实现将Complex转换为double型(取复数的模)。
设计主函数测试之。
*/#include#includeusing namespace std;class Complex{public:Complex(int,int);intgetreal();intgetimage();operator+(Complex &);operator+(int );operator++();bool operator>(Complex &);int operator[](constint&);double change();private:int real;int image;};Complex::Complex(intr,int i){real=r;image=i;}Complex::getreal(){return real;}Complex::getimage(){return image;}Complex::operator +(Complex &o) {real+=o.real;image+=o.image;}Complex::operator +(int a){real+=a;}Complex::operator ++(){real++;image++;}bool Complex::operator>(Complex &o1){if(this->real>o1.real)return true;elsereturn false;}int Complex::operator [](constint&index){if(index==0)return real;else if(index==1)return image;else{cout<<"subscript error"<<endl;< p="">exit(0);}}double Complex::change(){returnstatic_cast(sqrt(real*real+image*image)*0.01)*0.01; } </endl;<>。
【免费下载】任务十二 运算符的重载复数运算
任务实施: 步骤一 定义一个复数类 CComplex
//CComplex.h class CComplex { private:
//定义复数的实部和虚部 double real; double imag; public:
3、掌握运算符重载的形式(作为类的成员函数和友元函数)
4、掌握常见运算符的重载方式 任务描述:
1、定义复数类 CComplex
2、为复数类添加“+”运算符重载函数作为成员函数
3、在主函数中测试“+”运算符的功能
4、修改“+”运算符重载函数作为复数类的友元函数
5、在主函数中重新测试“+”运算符的功能相关知识点 任务环境:
CComplex CComplex::operator +(CComplex &c) { CComplex t; t.real= real+c.real;//等价于 t.real=this->real+c.real; t.imag= imag+c.imag;//等价于 t.imag=this->imag+c.imag; return t; }
定义复数类 CComplex
为复数类添加
配分
10
评分标准
找到正确方法得分 50%,方 法完全使用正确再得分 50%
“+”运算符重 25 找到正确方法得分 50%,方
载函数作为成
员函数
在主函数中测 步骤三 试“+”运算符的
功能
法完全使用正确再得分 50%
找到正确属性得分 50%,计 15
复数类加法减法和赋值运算符重载
例示例运算符重载为成员函数形式。
复数类加法、减法和赋值运算符重载。
#include <iostream.h>class Complex //复数类{public:Complex(double r=0.0,double i=0.0){m_fReal=r;m_fImag=i;} //构造函数double Real(){return m_fReal;} //返回复数的实部double Imag(){return m_fImag;} //返回复数的虚部Complex operator+(Complex &c); //复数加复数Complex operator+(double d); //复数加实数Complex operator-(Complex &c); //复数减复数Complex operator=(Complex x); //复数对象=复数private:double m_fReal,m_fImag; //私有数据成员};Complex Complex::operator+(Complex &c) //重载运算符“+”,两个复数相加{Complex temp;temp.m_fReal=m_fReal+c.m_fReal; //实部相加temp.m_fImag=m_fImag+c.m_fImag; //虚部相加return temp;}Complex Complex::operator +(double d) //重载运算符“+”,一个复数加一个实数{Complex temp;temp.m_fReal=m_fReal+d;temp.m_fImag=m_fImag;return temp;}Complex Complex::operator-(Complex &c) //重载运算符“-”,两个复数相减{Complex temp;temp.m_fReal=m_fReal-c.m_fReal; //实部相减temp.m_fImag=m_fImag-c.m_fImag; //虚部相减return temp;}Complex Complex::operator=(Complex c) //重载运算符“=”{m_fReal=c.m_fReal;m_fImag=c.m_fImag;return* this; //*this表示当前对象}void main(){Complex c1(3,4),c2(5,6),c3,c4; //定义复数类的对象cout<<"c1="<<c1.Real()<<"+j"<<c1.Imag()<<endl;cout<<"c2="<<c2.Real()<<"+j"<<c2.Imag()<<endl;c3=c1+c2; //调用运算符“+”、“=”重载函数,完成复数加复数cout<<"c3=c1+c2="<<c3.Real()<<"+j"<<c3.Imag()<<endl;c3=c3+6.5; //调用运算符“+”、“=”重载函数,完成复数加实数cout<<"c3+6.5="<<c3.Real()<<"+j"<<c3.Imag()<<endl;c4=c2-c1; //调用运算符“-”、“=”重载函数,完成复数减复数 cout<<"c4=c2-c1="<<c4.Real()<<"+j"<<c4.Imag()<<endl;}。
复数运算符重载
说明:只供参考,有待改进#include <iostream>using namespace std;class Complex{protected:double real;//实部double imaginary;//虚部public:Complex(){}Complex(double r,double i):real(r),imaginary(i){}void init(double r,double i){real=r;imaginary=i;}~Complex(){}void Show(){if(imaginary>0.0)cout<<real<<"+"<<imaginary<<"i"<<endl;elsecout<<real<<imaginary<<"i"<<endl;}//前面的必要,后面的看题选择//加号Complex operator+(const Complex &ComplexTemp) const {return Complex(real+ComplexTemp.real,imaginary+ComplexTemp.imaginary);}//减号Complex operator-(const Complex &ComplexTemp) const {return Complex(real-ComplexTemp.real,imaginary+ComplexTemp.imaginary);}//乘号Complex operator*(const Complex &ComplexTemp) const{return Complex(real*imaginary-ComplexTemp.real*ComplexTemp.imaginary, real*ComplexTemp.imaginary+imaginary*ComplexTemp.real);}//除号Complex operator/(const Complex &ComplexTemp) const{return Complex((real*imaginary+ComplexTemp.real*ComplexTemp.imaginary)/(ComplexTemp.real*ComplexTemp.real-ComplexTemp.imaginary*ComplexTemp.imaginary), (imaginary*ComplexTemp.real-real*ComplexTemp.imaginary)/(ComplexTemp.real*ComplexTemp.real-ComplexTemp.imaginary*ComplexTemp.imaginary));}};//下面的必要,有部分自选int main(){Complex c,c1,c2(1.0,-10.0);c1.init(2,2);//赋值c1.Show();//显示复数c1c2.Show();////加号c=c1+c2;c.Show();//减号c=c1-c2;c.Show();//乘号c=c1*c2;c.Show();//除号c=c1/c2;c.Show();return 0;}。
重载运算符
Complex temp;
temp.real=a.real-b.real;
temp.imag=a.imag-b.imag;
return temp;
}
int main()
{
double a1,b1;
double a2,b2;
while(cin>>a1>>b1>>a2>>b2)
{
Complex op1(a1,b1);
void print()
{cout<<n<<endl;
}
};
int main()
{
int m,n,i;
while(cin>>m>>n)
{
counter c(m);
if(n>0)
for(i=0;i<n;i++;)
c++;
else for(i=0;i>n;i--)
c--;
c.print();
return 0;
int operator>(const string &);
};
将类定义完整,并在主函数中进行测试。
Input
输入数据有多行,每行包括要比较的两个字符串。
Output
输出有多行,对应每行输入输出一行。
Sample Input
abcd abCd
09ab ab09
abcd efgh
hel hel
Sample Output
friend complex operator-(const complex &a,const complex &b);
★第12章 运算符重载
• 例12.1 定义复数类,重载加(+)、减(-)、乘(*)、除(/)运算 符,实现复数的四则运算;重载取负(-)运算符,实现复数的 取负操作。 #include<iostream.h>
class Complex{ //复数类 double real,image; public: Complex(double r=0,double i=0){real=r;image=i;} void print( ); Complex operator+(Complex&);//重载+:复数+复数 Complex operator-(Complex&);//重载-:复数-复数 Complex operator*(Complex&);//重载*:复数*复数 Complex operator/(Complex&);//重载/:复数/复数 Complex operator-( ); //重载-:-复数 };
12.1 12.2 12.3 12.4 12.5 12.6
运算符重载的基本方法 运算符重载为成员函数 运算符重载为友元函数 几个特殊运算符的重载 运算符重载的规则 字符串类
作业:6~9
12.1 运算符重载的基本方法 • 重载运算符的目的:使运算符可以直接操作自定义类 问:能否简写成 c3=c1+c2; 型的数据。 答:运算符虽能直接操作基本数据类 class Complex{ 型的数据,但对于自定义类型的数据, float real,imag; 若未重载有关运算符,则不能用这些 运算符操作自定义类型的数据。 public: Complex(float r=0,float i=0) { real=r;imag=i; } Complex add(const Complex &c) { return Complex(real+c.real,image+c.image);} }; void main( ) { complex c1(3.2,4.6),c2(6.2,8.7),c3; c3=c1.add(c2); };
12-运算符重载
10
冶金工业出版社
高等教育“十一五” 高等教育“十一五”规划教 材
• 说明: 说明: • ① 运算符函数参数的个数与操作数的个数相同, 即双目运算符有两个参数,单目运算符只有一 个参数。 • ② 运算符的使用只能采用“操作数1 运算符 操作数2”的基本形式,不允许像上一节那样写 成“对象.成员函数([实参表])”形式。 • ③ 插入运算符(<<)和提取运算符(>>)只 能用友元函数方法进行重载。
8
冶金工业出版社
高等教育“十一五” 高等教育“十一五”规划教 材
• 说明: 说明: • ① 总是默认调用该成员函数的对象参与了其中的运算, 因此,运算符函数隐含了一个参数,即this指针,它指 向当前对象。所以,运算符函数的参数个数要比操作 数的个数少一个,即双目运算符仅有一个参数,单目 运算符无参数。 • ② 由①可知,重载双目运算符时,对应的运算符函数 只能有一个参数,若是单目运算符,则其参数为空。 • ③ 运算符函数的调用方式有两种,一种是普通成员函 数的调用方式,另一种是表达式的形式,后一种方式 更直观,更常用。 • ④ 为了能在类外使用运算符表达式,通常把运算符函 数设为public权限。 • ⑤ =、()、[]、->等运算符只能用成员函数重载。
6
冶金工业出版社
高等教育“十一五” 高等教育“十一五”规划教 材
• ② 不能重载的运算符(只有5个): • .(成员访问运算符)、*(成员指针访问运算符)、::(作用 域运算符)、sizeof(长度运算符)、? ::(条件运算符) • (3)重载不能改变运算符操作数的个数、优先级和结合性。 • 这些要求也合情合理,我们希望的是保留、借助已有的知识 体系,而不是将它们推倒重组。 • (4)重载运算符的函数不能有默认的参数。 • 比如说+、-运算符,既可以进行单目运算,又可以进行双目 运算,两者之间差异较大,如果允许有默认值,那么就会分 不清是双目运算,还是单目运算。 • (5)重载运算符必须和用户自定义类型的对象一起使用,其 参数至少有一个是类对象或对象引用。 • (6)应当使重载运算符的功能类似于该运算符作用于基本数 据类型时所实现的功能。 • (7)对于运算符=(对象赋值)和&(取对象地址)的功能, 系统已有默认定义,通常情况用户不需要重新定义。
复数的运算法则(2020)
复数的运算法则(2020)C++ 复数运算完成复数类的运算符重载函数,包括:基本算术运算(+、-、*、-、=)自增自减运算(前置++、后置++、前置–、后置–)流运算符(、)z=a+bi(a,b均为实数)的数称为复数,其中a称为实部,b称为虚部,i称为虚数单位。
运算法则:加法: (a+bi)+(c+di)=(a+c)+(b+d)i减法:(a+bi)-(c+di)=(a-c)+(b-d)i乘法:(a+bi)(c+di)=ac+adi+bci+bdi2 = (ac-bd)+(bc+ad)i除法:(a+bi)-(c+di)=(ac+bd)-(c2+d2) +((bc-ad)-(c2+d2))i由上面题目得知,该复数需要运用到重载函数。
所以先写一个.h 头文件,如下Plural.h文件#pragma once#include iostreamusing namespace std;class Plural {Plural(double x = 0, double y = 0) {before = x;after = y;--基本算术运算friend Plural operator + (const Plural, const Plural); friend Plural operator - (const Plural, const Plural); friend Plural operator * (const Plural, const Plural); friend Plural operator - (const Plural, const Plural); Plural operator = (const Plural);--自增自减运算Plural operator ++(int);--后置++Plural operator --();--前置--Plural operator --(int);--后置----流运算符(、)friend ostream operator (ostream output, Plural); friend istream operator (istream input, Plural); private:double before, after;然后创建一个.cpp文件(要和.h文件同名)。
重载复数的四则运算
C++课程设计题目: 重载复数的四则运算日期:2008年6月15日题目: 重载复数的四则运算摘要:运算符重载是构成计算机语言的基础之一,而C++语言进一步拓展了运算符重载的概念。
熟练掌握运算符重载的概念,并熟练应用各类运算符的重载,程序设计者就可以进一步重载某个特定的运算符,赋予它新的含义,就像对语言本身进行扩充一样。
关键词:运算符重载两个复数一、简介算符重载是构成计算机语言的基础之一,C++提供的运算符只能用于C++的标准类型数据的运算。
本题主要是用C++编程来实现重载复数的四则运算,运算符重载就是赋予C++中已有的运算符多重含义。
通过重新定义运算符,使它能够用于特定类的对象执行特定的功能,这便增强了C++语言的扩充能力。
使用重载后的运算符还会使程序更加易于理解,符合人们的日常思维习惯。
本题是对两个复数进行四则运算,输入两个复数后,自动运行出结果,一目了能,当除数为零时,机器自己出示出错信息,提示你除数不能为零。
这样就可以达到进行复数的四则运算时不会出现运算的错误。
二、算法开始:定义一个基类complex{受保护成员变量:real 为double型,复数的实部imag 为double型,复数的虚部公有成员方法:定义一个无参数的构造函数complex{对成员变量grade 和Name进行赋值,初始值为0}重载构造函数complex,参数为(double rpart,double ipart) {rpart⇒realipart⇒imag}重载操作符“+”,参数为(const complex &com{实现两个复数的相加}重载操作符“-”,参数为(const complex &com){实现两个复数的相减}重载操作符“×”,参数为(const complex &com){实现两个复数的相乘}重载操作符“÷”,参数为(const complex &com){实现两个复数的相除}定义一个无参数无返回值的成员函数display{输出复数的标准形式:(a+bi)或(a-bi)}};返回值为整型的主函数{定义四个double型变量a ,b,c,d,即复数A=a+bi,复数B=c+di输入变量a ,b,c,d的值调用两个参数的构造函数complex,初始化对象n1(a,b),n2(c,d)输出复数A的值输出复数B的值n1+n2⇒result1输出两个复数的相加,及结果n1-n2⇒result2输出两个复数的相减,及结果n1*n2⇒result3输出两个复数的相乘,及结果if 复数n2中c=d=0给出出错信息,除数不能为0else{n1/n2⇒result4输出两个复数的相除,及结果}返回0值end}三、程序#include<iostream.h> //头文件class complex //定义了一个complex的类{private:double real; //复数的实部double imag; //复数的虚部public:complex() //定义无参数的构造函数{real=imag=0;}complex(double rpart,double ipart) //重载并定义两个参数的构造函数{real=rpart;imag=ipart;}complex operator+(const complex &com) //重载操作符“+”{complex temp;temp.real=real+com.real;temp.imag=imag+com.imag;return temp;}complex operator-(const complex &com) //重载操作符“-”{complex temp;temp.real=real-com.real;temp.imag=imag-com.imag;return temp;}complex operator*(const complex &com) //重载操作符“×”{complex temp;temp.real=real*com.real-imag*com.imag;temp.imag=real*com.imag+imag*com.real;return temp;}complex operator/(const complex &com) //重载操作符“÷”{complex temp;temp.real=(real*com.real+imag*com.imag)/(com.real*com.real+com.imag*com.i mag);temp.imag=(imag*com.real-real*com.imag)/(com.real*com.real+com.imag*com. imag);return temp;}void display() //定义成员函数display,输出复数的标准形式{if(imag>=0)cout<<"("<<real<<"+"<<imag<<"i)";elsecout<<"("<<real<<imag<<"i)";}};int main(void){double a,b,c,d;cout<<"输入两个复数,即a,b,c,d的值:";cin>>a>>b>>c>>d;complex n1(a,b),n2(c,d);cout<<"两个复数值为:";cout<<"A="; //输出复数A的值n1.display();cout<<" B=";n2.display(); //输出复数B值cout<<endl;cout<<endl<<endl<<"两个复数的加法:"<<endl;complex result1;result1=n1+n2; //实现两个复数的加法运算n1.display();cout<<"+";n2.display();cout<<"=";result1.display(); //输出两个复数相加的结果cout<<endl<<endl<<"两个复数的减法:"<<endl;complex result2;result2=n1-n2; //实现两个复数的减法运算n1.display();cout<<"-";n2.display();cout<<"=";result2.display(); //输出两个复数相减的结果cout<<endl<<endl<<"两个复数的乘法:"<<endl;complex result3;result3=n1*n2; //实现两个复数的乘法运算n1.display();cout<<"×";n2.display();cout<<"=";result3.display(); //输出两个复数相乘的结果cout<<endl<<endl<<"两个复数的除法:"<<endl;if(c==0&&d==0)//判断除数是否为0,若为0则给出错误信息,不为0则进行相除运算cout<<"不能进行运算,除数不能为0"<<endl;else{complex result4;result4=n1/n2; //实现两个复数的除法运算n1.display();cout<<"÷";n2.display();cout<<"=";result4.display(); //输出两个复数相除的结果}cout<<endl;return 0;}四、结果及分析1. 除数不为零时:2.除数为零时:通过以上两组数据结果可知,该程序可以进行任意复数的四则运算,而且当除数为零时,会给出出错信息,可以更好的方便我们对复数的四则运算。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
计算机与电子工程系实训课任务单
课程名称:C/C++语言程序设计上课时间:周星期节教师姓名:蔡茜班级名称:11级软件班本任务课时安排:2课时
教学组织形式:任务驱动,理实结合,讲练结合、教学做一体化
任务十二:运算符的重载——复数运算
任务要求:
1、理解运算符重载的概念
2、掌握运算符重载的定义(双目运算符和单目运算符的重载)
3、掌握运算符重载的形式(作为类的成员函数和友元函数)
4、掌握常见运算符的重载方式
任务描述:
1、定义复数类CComplex
2、为复数类添加“+”运算符重载函数作为成员函数
3、在主函数中测试“+”运算符的功能
4、修改“+”运算符重载函数作为复数类的友元函数
5、在主函数中重新测试“+”运算符的功能相关知识点
任务环境:
Windows系统电脑,Visual C++ 6.0,IE 6.5以上浏览器
任务实施:
步骤一定义一个复数类CComplex
//CComplex.h
class CComplex
{
private:
//定义复数的实部和虚部
double real;
double imag;
public:
CComplex(double x=0.0,double y=0.0);//定义带默认参数的构造函数
void print();
};
//CComplex.cpp
CComplex::CComplex(double x,double y)
{
real=x;
imag=y;
}
CComplex CComplex::operator +(CComplex &c)
{
CComplex t;
t.real= real+c.real;//等价于t.real=this->real+c.real;
t.imag= imag+c.imag;//等价于t.imag=this->imag+c.imag;
return t;
}
void CComplex::print()
{
cout<<'('<<real<<','<<imag<<')'<<endl;
}
步骤二定义“+”运算符重载函数为成员函数
CComplex operator+(CComplex &c)//定义“+”运算符重载函数为成员函数,只带一个参数{
CComplex t;
t.real=this->real+c.real;
t.imag=this->imag+c.imag;
return t;
}
步骤三在主函数测试复数类的“+”运算符重载
#include "Complex.h"
void main()
{
CComplex a(3.0,4.0),b(10.5,20.5),c;
c=a+b//等价于c=a.operator +(b);
c.print();
}
步骤四修改“+”运算符重载函数为类的友元函数
//Complex.h文件
class CComplex
{
private:
//定义复数的实部和虚部
double real;
double imag;
public:
CComplex(double x=0.0,double y=0.0);
friend CComplex operator+(CComplex &x,CComplex &y);
void print();
};
//Complex.cpp文件
修改原来的运算符重载函数为:
CComplex operator +(CComplex &x,CComplex &y)//两个参数
{
CComplex t;
t.real=x.real+y.real;
t.imag=x.imag+y.imag;
return t;
}
注意:双目运算符重载作为友元函数时需要指定两个参数,而作为成员函数时只需要指定一个参数。
任务总结:
(1)运算符重载的定义:
函数类型 operator运算符(参数列表)
{ 函数体 }
(2)在对运算符进行重载过程中应遵循如下规则:
●用户不可以自己定义新的运算符,只能对已有的C++运算符进行重载。
●重载不能改变运算符运算对象(即操作数)的个数,即单目运算符只能重载为单目运算符,多目运算符只能重载为多目运算符。
●重载不能改变运算符的优先级和结合性。
●重载运算符的功能应与该运算符作用于标准类型数据时所实现的功能类似,否则会影响程序的可读性。
(3)双目运算符重载作为友元函数时需要指定两个参数,而作为成员函数时只需要指定一个参数。
拓展实训内容(安排学时:2学时)
实训一教研室的人员们
任务描述:
定义点坐标类Point,重载++(自增)运算符实现横纵坐标值均加1,重载--(自减)实现横纵坐标值均减1。
具体要求:
(1)坐标类Point包含数据成员有横坐标值和纵坐标值;
(2)坐标类Point包含能够初始化横纵坐标值的构造函数,在没有给定坐标点的横纵坐标值时,默认都
为0;
(3)坐标类Point包含能够显示出横纵坐标值的函数show( );(4)在main函数中测试坐标类对象执行++,--运算后的值。