复数类,运算符重载(赋值运算符等)
C++基础系列——运算符重载
C++基础系列——运算符重载1. 运算符重载简介所谓重载，就是赋予新的含义。
函数重载（Function Overloading）可以让⼀个函数名有多种功能，在不同情况下进⾏不同的操作。
同样运算符重载（Operator Overloading）可以让同⼀个运算符可以有不同的功能。
可以对 int、float、string 等不同类型数据进⾏操作<< 既是位移运算符，⼜可以配合 cout 向控制台输出数据也可以⾃定义运算符重载：class Complex{public:Complex();Complex(double real, double imag);Complex operator+(const Complex &a) const;void display() const;private:double m_real;double m_imag;};// ...// 实现运算符重载Complex Complex::operator+(const Complex &A) const{Complex B;B.m_real = this->m_real + A.m_real;B.m_imag = this -> m_imag + A.m_imag;return B;// return Complex(this->m_real + A.m_real, this->m_imag + A.m_imag);}int main(){Complex c1(4.3, 5.8);Complex c2(2.7, 3.7);Complex c3;c3 = c1 + c2; // 运算符重载c3.display();return 0;}运算结果7 + 9.5i运算符重载其实就是定义⼀个函数，在函数体内实现想要的功能，当⽤到该运算符时，编译器会⾃动调⽤这个函数，它本质上是函数重载。
运算符重载
// 顺序错误
.
27
由于使用友元会破坏类的封装，要尽量将运算 符重载函数定义为成员函数。
除非有特殊需要，才使用友元函数重载运算符。
.
28
4.5重载双目运算符
双目的意思是运算符左边和右边的操作数均参 加运算。
如果要重载 B 为类的成员函数，使之能够实 现表达式 oprd1 B oprd2，其中 oprd1 为A 类 对象，则 B 应被重载为 A 类的成员函数，形 参类型应该是 oprd2 所属的类型。
.
24
加法运算符重载为友元函数，C++ 在编译时将表达式 c1+c2解释为
operator + ( c1, c2) 即相当于执行以下函数
Complex operator + ( Complex & c1, Complex & c2 ) {
return Complex( c1.real + c2.real , c1.imag + c2.imag ) ; }
.
3
运算符重载的实质
运算符重载是对已有的运算符赋予多重含义。
必要性：C++中预定义的运算符其运算对象只 能是基本数据类型，而不适用于用户自定义类 型（如类）
实现机制
将指定的运算表达式转化为对运算符函数的调用， 运算对象转化为运算符函数的实参。
编译系统对重载运算符的选择，遵循函数重载的选 择原则。
friend Complex operator + ( int & i , Complex & c )
{
return Complex( c.real + i , c.imag ) ;
成人教育 《面向对象程序设计》期末考试复习题及参考答案
面向对象程序设计复习题二一、填空1.程序的三种常见结构是、、，其中结构是程序的默认结构。
2.同名方法给出不同的实现，并通过参数类型或个数进行区分，称为。
3.和“继承”匹配的概念是。
4.由类构建对象的过程称为。
5.抽象类是含有的类。
6.实现软件复用有两种方式，分别为、、。
7.有定义const int *p，p称为。
8.通过继承产生的类称为。
9.virtual关键字在C++中有两个用处，分贝是，和。
10.方法重载和实现了多态性。
11.请给出C++外的另外一种支持面向对象设计语言。
12.类的三个要素是、、。
13.对象释放前执行的函数是。
二、名词解释1、构造函数2、对象3、运算符重载4、析构函数5. 面向对象6. 继承三、简答1.比较类和结构体？2.重载的意义？3.抽象类的作用和意义？4.组合与继承的区别？四、辩析1.任何父类对象都可以被子类对象替代。
2.public修饰符号破坏了数据的开放性。
3.private继承方式不能产生子类。
4.不能实例化的类一定是抽象类。
五、综合回答1．简述多态的实现机制。
2．谈谈多态的意义。
3．面向对象程序设计思想的优点和缺点。
面向对象程序设计复习题二答案一、填空（1）顺序（2）选择（3）循环（4）顺序（5）函数重载（6）抽象（7）实例化（8）纯虚函数（9）继承(10) 组合（9）和（10）不区分顺序（11）常量指针（12）派生类（13）虚函数（14）虚拟继承（13）和（14）不区分顺序（15）覆盖（16）Java或者C#（17）类的标识（18）类的状态（19）类的操作（17）（18）（19）不区分顺序（20）析构函数二、名词解释1、当类实例化时自动调用的成员函数，负责实现对象的初始化2、按照数据类型分配的内存空间，可以实现方法的调用3、将系统定义的运算符操作对象的类型扩展的过程，一般针对自定义类型4、对象空间释放之前自动调用的函数5、是程序设计思想，相对面向过程而言更加强调封装性6、两个类之间的一种关系，其中一个类的某个成员类型是另一个类三、简答1、C++中类和结构体具有同等的功能，唯一区别是类缺省成员属性是private，而结构体缺省为public2、重载的意义在于丰富了动作的多样性，但是并不加重程序员的负担。
编写复数类Complex
编写复数类Complex。
要求：1）类里面需要重载运算符函数，包括：复数加法+（二元），复数减法-（二元），复数求负-（一元）和复数赋值=（二元）。
2）类里面有输出该复数的函数print。
3）类的声明写在Complex.h中，类的实现写在Complex.cpp中。
4）写出以上两个文件即可，无需客户代码。
5）在思考以上问题时，可参考如下客户代码（假设类已编写好）：#include "complex.h"#include <iostream.h>int main(){COMPLEX c1(1, 2); // 定义一个值为1 + 2i的复数c1COMPLEX c2(2); // 定义一个值为2的复数c2COMPLEX c3(c1); // 用拷贝构造函数创建一个值同c1的新复数c3.print(); // 打印c3的值c1 = c1 + c2 + c3; // 将c1加上c2再加上c3赋值给c1c2 = -c3; // c2等于c3求负c3 = c2 - c1; // c3等于c2减去c1c3.print(); // 再打印运算后c3的值return 0;}#include "iostream.h"class complex{public:complex(){real=imag=0.0;}complex(double r){real=r;imag=0.0;}complex(double r,double i){real=r;imag=i;}complex(complex&cp){real=cp.real;imag=cp.imag;}friend complex operator+(const complex&c1,const complex&c2); friend complex operator-(const complex&c1,const complex&c2); inline complex operator+=(const complex&c);inline complex operator-=(const complex&c);void print();private:double real,imag;};complex operator+(const complex&c1,const complex&c2){return complex(c1.real+c2.real,c1.imag+c2.imag);}complex operator-(const complex&c1,const complex&c2) {return complex(c1.real-c2.real,c1.imag-c2.imag);}inline complex complex::operator+=(const complex&c) {return(real+c.real,imag+c.imag);}inline complex complex::operator-=(const complex&c) {return(real-c.real,imag-c.imag);}void complex::print(){if (imag<0){cout<<real<<imag<<"i"<<endl;}else{cout<<real<<"+"<<imag<<"i"<<endl;}}int main(){complex c1(1, 2); // 定义一个值为1 + 2i的复数c1complex c2(2); // 定义一个值为2的复数c2complex c3(c1); // 用拷贝构造函数创建一个值同c1的新复数c3.print(); // 打印c3的值c1=c1 + c2 + c3; // 将c1加上c2再加上c3赋值给c1c2-=c3; // c2等于c3求负c3 = c2 - c1; // c3等于c2减去c1c3.print(); // 再打印运算后c3的值return 0;}。
可以重载的运算符
可以重载的运算符随着程序设计语言的发展，越来越多的重载运算符的机会出现。
通过重载运算符，可以方便地对自定义类型进行操作，并提高代码的可读性和可维护性。
以下是一些可以重载的运算符：1. 一元运算符：重载一元运算符可以改变一个对象的状态或值。
常见的一元运算符包括：+（正号）、-（负号）、*（指针）、&（取地址符）、~（按位取反）等。
2. 二元运算符：重载二元运算符可以改变两个对象之间的运算方式。
常见的二元运算符包括：+（加号）、-（减号）、*（乘号）、/（除号）等。
在C++中，还可以重载操作符用于比较操作，如==、!=、<=、>=等。
3. 赋值运算符：重载赋值运算符可以对自定义类型进行赋值操作。
默认的赋值运算符只是简单地复制对象的值，而且会存在浅拷贝和深拷贝的问题。
4. 下标运算符：重载下标运算符可以通过对象数组形式来访问对象中的元素。
这种运算符对于自定义容器和数据结构非常有用。
5. 函数调用运算符：重载函数调用运算符可以让对象具有函数行为。
通过这种方式，可以实现自定义类型的函数调用和参数传递。
6. 前置/后置增量运算符：重载前置/后置增量运算符可以使得对象的值增加或减少。
前置增量运算符在对象的值被使用之前首先递增对象的值，而后置增量运算符在对象的值被使用后递增对象的值。
7. 强制类型转换运算符：重载强制类型转换运算符可以将自定义类型转换为其他数据类型，例如将一个类的对象转换为bool值或整数值等。
通过重载运算符，可以轻松地实现自定义类型的强类型检查和操作。
但是，在重载运算符时应该注意保持一致性和正确性，以确保代码的正确性和可维护性。
c++学习资料第 06 章 运算符重载
第 6 章 运 算 符 重 载
{ return Complex( c.Real, c.Image ); } void Complex::print()const { cout << '(' << Real << " , " << Image << ')' << endl; } void main() { Complex c1( 2.5,3.7 ), c2( 4.2, 6.5 ) ; Complex c ; c = c1 c2 ; // operator(c1,c2) c.print() ; c = 25 + c2 ; // operator+(25,c2) c.print() ; c = c2 + 25 ; // operator+(c2,52) c.print() ; c = c1 ; // operator(c1) c.print() ; } 当一个运算符的操作需要修改类对象状态时，应该以成员函数重载。例如，需要左值操 作数的运算符（如 =，*=，++ 等）应该用成员函数重载。如果以友员函数重载，可以使用 引用参数修改对象。 当运算符的操作数（尤其是第一个操作数）希望有隐式转换，则重载算符时必须用友员 函数或普通函数。 C++中不能用友员函数重载的运算符有 = （） ［］ －> 6.3 几个典型运算符重载 本节讨论在数学类中常用的几个运算符重载的特点和应用。 6.3.1 重载 ++ 与 自增和自减运算符有前置和后置两种形式。每个重载运算符的函数都必须有明确的特 征，使编译器确定要使用的版本。C++规定，前置形式重载为一元运算符函数，后置形式重 载为二元运算符函数。 【例 64】例 62 中使用了成员函数重载++和运算符。本例用友员函数重载++运算符。 设有简单类定义 class Increase { public : Increase() ; … friend Increase operator ++ ( Increase & ) ; friend Increase operator ++ ( Increase & , int ) ; private : unsigned value ; } ; 则前置重载的实现为： Increase operator++ ( Increase & a ) { a.value ++ ;
4第四章 运算符重载
const complex operator - (const complex &c) const; void display(); //输出复数 private: //私有数据成员 1.是为了堵塞a+b=c的漏洞。 double real; //复数实部 2. 3.是为了扩大适应性。 double imag; //复数虚部 };
17
[ ]运算符重载为成员函数
下标运算符［］可以重载： 重载形式为：operator［］(int); 当 X x; 隐含调用。 x[y] 可被解释为： 显式调用。 x. operator [ ](y)； 只能重载为成员函数，不能使用友元函数。 这个类显然是个‚数组类‛。
18
前置++和后置++重载为成员函数
9
使用
void main(){
complex c1(5,4),c2(2,10),c3; //三个复数类的对象 cout<<"c1="; cout<<"c2="; c1.display(); c2.display();
c3=c1-c2; //使用重载运算符完成复数减法 cout<<"c3=c1-c2="; c3.display(); 程序输出结果为：
这三个运算符是许多 教课书没有提到的。
唯一的一个三目运 算符不能重载。
3
运算符重载的基础
设计运算符重载函数，首先要了解运算符原本的运算语义。重
载函数要忠实遵守该运算符作用于基本数据类型时的语义，
并表现出自身所特有的性质。 例如：+ 、+= 、=、++(前)、++(后) ....
C++运算符重载讲解与经典实例 (2)
5.重载运算符有哪些限制:
(1)不可臆造新的运算符。必须把重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中。
(c1+c2)*(c1-c2)*c2/c1=9.61538+25.2308i
在程序中，类complex定义了4个成员函数作为运算符重载函数。将运算符重载函数说明为类的成员函数格式如下：
＜类名＞operator＜运算符＞(＜参数表＞)
其中，operator是定义运算符重载函数的关键字。
程序中出现的表达式：
位操作运算符：&,|,~,^,＜＜,＞＞
逻辑运算符：!,&&,||;
比较运算符：＜,＞,＞=,＜=,==,!=;
赋值运算符：=,+=,-=,*=,/=,%=,&=,|=,^=,＜＜=,＞＞=;
其他运算符：[],(),-＞,,(逗号运算符),new,delete,new[],delete[],-＞*。
double real;
double imag;
};
complex a(10,20),b(5,8);
“a+b”运算如何实现？这时候我们需要自己编写程序来说明“+”在作用于complex类对象时，该实现什么样的功能，这就是运算符重载。运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据导致不同类型的行为。
运算符重载形式有两种，重载为类的成员函数和重载为类的友元函数。
运算符重载为类的成员函数的一般语法形式为：
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);
operator用法
operator用法operator是C++中的一个关键字，表示操作符的重载函数。
操作符重载可以使得类类型的对象可以像基本数据类型一样使用运算符进行操作。
以下是operator的用法：1.重载算术运算符：可以重载+、-、*、/等算术运算符。
例如：```c++。
public:。
double real, imag;。
}。
};。
```。
这个重载函数将实现复数相加的运算。
2.重载比较运算符：可以重载==、!=、>、<等比较运算符。
例如：```c++。
class String 。
public:。
bool operator==(const String& t) const 。
//比较字符串是否相等。
}。
};。
```。
这个重载函数将实现字符串相等比较的运算。
3.重载逻辑运算符：可以重载&&、||、！等逻辑运算符。
例如：```c++。
class MyBool 。
public:。
bool operator!() const 。
//取反运算。
}。
};。
```。
这个重载函数将实现MyBool类型的取反运算。
4.重载赋值运算符：可以重载=运算符。
例如：```c++。
class String 。
public:。
String& operator=(const String& t) 。
//字符串赋值运算。
return *this;。
}。
};。
```。
这个重载函数将实现字符串的赋值运算。
5.重载下标运算符：可以重载[]运算符。
例如：```c++。
class Array 。
public:。
int& operator[](int i) 。
//返回第i个元素的引用。
}。
};。
```。
这个重载函数将实现数组的下标运算。
6.重载函数调用运算符：可以重载()运算符。
例如：```c++。
class Function 。
public:。
int operator()(int x, int y) 。
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++实验报告之静态成员、运算符重载
题目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++运算符重载复数加减乘除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)```以上是一个简单的复数运算符重载示例，可以根据需要进行扩展和优化。
C++程序设计04737 第4章 运算符重载
~myComplex(){ }
myComplex addCom(myComplex c1);//成员函数，调用对象与参数对象c1相加
void outCom();
//成员函数
void outCom(string s); //成员函数
void changeReal(double r);//成员函数
friend myComplex operator+(const myComplex &c1,const myComplex &c2); //c1+c2
4.1 运算符重载的概念
例4-2 重载为友元函数
#include <iostream>
using namespace std;
class myComplex
{private: double real,imag;
public:
myComplex();
myComplex(double r,double i);
class myComplex
//复数类
{
private: double real,imag;
public: myComplex();
//构造函数
myComplex(double r,double i);
//构造函数
void outCom();
//成员函数
myComplex operator-(const myComplex &c);//成员函数
4.1 运算符重载的概念
三、重载运算符为友元函数
例4-1 重载为成员函数的限制
1. #include <iostream>
2. using namespace std;
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类中声明它为友元函数。
面向对象程序设计作业参考答案
面向对象程序设计作业参考答案习题一5、分析下面程序运行的结果。
#using namespace std;int main(){cout<<”This”<<”is”;cout<<”a”<<”C++”;cout<<”program.”<<endl;< p="">return 0;}输出结果：ThisisaC++program.6、分析下面程序运行的结果。
#includeusing namespace std;int main(){int a,b,c;a = 10;b = 23;c = a + b;cout<<'a + b =";cout<<c;< p="">cout<<endl;< p="">return 0;}输出结果：a + b = 338、在你所用的C++系统上，输入以下程序，进行编译，观察编译情况，如果有错误，请修改程序，在进行编译，直到没有错误，然后进行连接和运行，分析运行结果。
修改后的程序如下：#includeusing namespace std;int main(){int a, b;a =b = 0;int c = a + b;cout<<”a + b =”<return 0;}9、输入以下程序，进行编译，观察编译情况，如果有错误，请修改程序，在进行编译，直到没有错误，然后进行连接和运行，分析运行结果。
修改后的程序如下：#includeusing namespace std;int add(int x,int y);int main(){int a = 0, b = 0;int c = add(a,b);cout<<" a + b ="<<c<<endl;< p="">return 0;}int add(int x,int y){int z = x + y;return z;}习题二1、请检查下面的程序，找出其中的错误（先不要上机，在纸面上作人工检查），并改正之。
运算符重载详解
运算符重载详解1.运算符重载定义：C++中预定义的运算符的操作对象只能是基本数据类型。
但实际上，对于许多⽤户⾃定义类型（例如类），也需要类似的运算操作。
这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够⽤于特定类型执⾏特定的操作。
运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引⼈的特性之⼀。
运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进⾏的操作。
运算符函数的定义与其他函数的定义类似，惟⼀的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。
运算符函数定义的⼀般格式如下：<返回类型说明符> operator <运算符符号>(<参数表>){<函数体>} 2.运算符重载时要遵循以下规则：(1) 除了类属关系运算符"."、成员指针运算符".*"、作⽤域运算符"::"、sizeof运算符和三⽬运算符"?:"以外，C++中的所有运算符都可以重载。
(2) 重载运算符限制在C++语⾔中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。
(3) 运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。
(4) 重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。
(5) 运算符重载不能改变该运算符⽤于内部类型对象的含义。
它只能和⽤户⾃定义类型的对象⼀起使⽤，或者⽤于⽤户⾃定义类型的对象和内部类型的对象混合使⽤时。
(6) 运算符重载是针对新类型数据的实际需要对原有运算符进⾏的适当的改造，重载的功能应当与原有功能相类似，避免没有⽬的地使⽤重载运算符。
（7）重载运算符的函数不能有默认的参数，否则就改变了运算符的参数个数，与前⾯第3点相⽭盾了；（8）重载的运算符只能是⽤户⾃定义类型，否则就不是重载⽽是改变了现有的C++标准数据类型的运算符的规则了，会引会天下⼤乱的；（9）⽤户⾃定义类的运算符⼀般都必须重载后⽅可使⽤，但两个例外，运算符“=”和“&”不必⽤户重载；（10）运算符重载可以通过成员函数的形式，也可是通过友元函数，⾮成员⾮友元的普通函数。
c++复数类
c++复数类写⼀个简单的类完成默认函数和简单的运算符重载1.完成四个默认成员函数2.⽐较运算符3.前置后置++和+/+=的实现#ifndef __COMPLEX_H__#define __COMPLEX_H__#define _CRT_SECURE_NO_DEPRECATE 1#include<iostream>#include<stdlib.h>using namespace std;class Complex{public:Complex (int x,int y) //列表初始化:_real(x),_img(y){}Complex(const Complex& d) //拷贝构造{this->_real = d._real;this->_img = d._img;}~Complex() //析构函数{cout<<"~Complex()"<<endl;}Complex& operator=(const Complex& d) //赋值运算符的重载 {if(&d != this){this->_real = d._real;this->_img = d._img;}return *this;}bool operator>(const Complex & d);Complex& operator+=(const Complex& d);Complex& operator++();Complex operator++(int);void Print_Complex();private:int _real;int _img;};#endif // !__COMPLEX__H_#include"Complex.h"void Complex::Print_Complex(){if(_img<0)cout<<_real<<_img<<"i"<<endl;elsecout<<_real<<"+"<<_img<<"i"<<endl;}bool Complex::operator>(const Complex& d) //⽐较运算符（复数实不能这样⽐较⼤⼩的，这只是为实现>符号的重载才这样做）{return (this->_real)>d._real && ((this->_img) >d._img || (this->_img) == d._img);}Complex& Complex::operator++() //前置++，默认给实部加1；{this->_real+=1;return *this;}Complex Complex::operator++(int) //后置++，默认给实部加1；{Complex tmp = *this;this->_real += 1;return tmp;}Complex& Complex::operator+=(const Complex& d) //预算符+=重载；{this->_real += d._real;this->_img += d._img;return *this;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Complex(Complex &c)
{
real=c.real ;
imag=c.imag ;
}
Complex operator +(double x)
{
Complex temp;
temp.real = real+x;
temp.imag = imag;
return temp;
}
Complex operator +(Complex &c)
*/
#include<iostream.h>
class Complex
{
private :
double real;
double imag;
public:
Complex(double r=0,double i=0)
{
real=r;
imag=i;}vo Nhomakorabead display()
{
cout<<real<<"+"<<imag<<"i"<<endl;
{
Complex temp;
temp.real =c.real -real;
temp.imag =c.imag -imag;
return temp;
}
};
void main()
{
Complex a(2,3),b(4,5),c,d,f,g;
cout<<"a=";
a.display();
cout<<"b=";
{
Complex temp;
temp.real =c.real +real;
temp.imag =c.imag +imag;
return temp;
}
Complex operator =(Complex & c)
{
real=c.real ;
imag=c.imag ;
return *this;
}
Complex operator -(Complex & c)
b.display();
c=a;
cout<<"c=a=";
c.display ();
f=a+b;
cout<<"f=a+b=";
f.display();
d=a+4;
cout<<"d=a+4=";
d.display ();
g=a-b;
cout<<"g=a-b=";
g.display();
}
结果：
a=2+3i
b=4+5i
c=a=2+3i
f=a+b=6+8i
d=a+4=6+3i
g=a-b=2+2i
Press any key to continue
/*定义复数类Complex，
（1）定义私有数据成员，实部和虚部；
（2）定义带默认值的构造函数，给数据成员赋值，默认值为0；
（3）定义输出函数void display()，输出格式如“3+4i”或“-3-4i”；
（4）定义复数与复数的加、减运算符重载；复数加实数运算符重载；赋值运算符重载；
（5）定义主函数，对上述成员函数进行测试。