c++ 运算符重载的写法

合集下载

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

• 不确定目数运算符是操作数个数不确定，可根据需要重载为不同的操作数个数，不确定目数运算符只包括函数调用运算符“（）”
• 在中只能重载单目运算符、双目运算符及不确定目数运算符“()”
4.2.1 运算符重载为类的成员函数
• 通过该类的对象来调用运算符函数，由于对象本身将作为一个操作数，因此要求第一个操作数的类型为用户自ቤተ መጻሕፍቲ ባይዱ义类，参数表中的参数个数比操作数个数少一。
• 运算符重载的方法在实质上就是定义一个重载运算符的函数，在执行被重载的运算符时，系统将调用此函数实现相应的运算。运算符重载本质就是函数的重载。
• 重载运算符的函数的原型如下：
• 返回值类型运算符(形参表);
• 例如将“＋”用于类的加法运算运算符重载的函数原型可以为：
• ( 1, 2);
例4.2 通过运算符重载实现复数相加的示例。
例4.1 通过函数实现复数相加示例。声明复数数
{
:
数据成员
;
实部
;
虚部
:
公有函数
( r = 0, i = 0): (r), (i){ } 构造函数
() ;
输出复数
( 1, 2);
复数加法
};
()
输出复数
{
( < 0) << << << "i" << ;
虚部为负
( 0) << << ;
虚部为0
<< << “+” << << “i” << ;
z1();
象的过程中调用输了出构z1造函数，语句将此临时对象作为函

总结运算符重载的形式。

运算符重载是C++中的一个重要特性，它允许程序员自定义数据类型的运算符行为。

通过运算符重载，程序员可以有更多的灵活性和简洁性来表达对自定义数据类型的操作。

运算符重载需要特定的形式来定义重载函数，下面是一些常见的形式：1. 非成员函数形式：```返回类型 operator 运算符(参数列表){//重载函数体}```这种形式中，运算符重载函数是一个普通的非成员函数，通过参数列表中的参数来传递操作数。

在函数体中，程序员需要手动实现操作符的具体行为。

2. 成员函数形式：```class MyType{public:返回类型 operator 运算符(参数列表){//重载函数体}};```这种形式中，运算符重载函数是一个MyType类的成员函数。

和非成员函数一样，通过参数列表中的this指针传递操作数，但此时操作数是MyType类对象的一个成员，成员函数中可以访问该成员函数的私有数据和成员函数。

3. 可转换成成员函数形式：```class MyType{public:返回类型 operator 运算符(参数列表) const{ //重载函数体}};```这种形式中，运算符重载函数是一个MyType类的成员函数，但是在函数后面添加了const，表示该重载函数不会修改MyType类对象。

在函数体内部，可以访问MyType类的成员变量，但是不能修改。

运算符重载是C++中强大特性之一，通过自定义数据类型的运算符行为，我们可以方便地对数据类型进行操作。

程序员在使用运算符重载时一定要注意运算符重载的形式，以确保正确使用。

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运算符重载其实就是定义⼀个函数，在函数体内实现想要的功能，当⽤到该运算符时，编译器会⾃动调⽤这个函数，它本质上是函数重载。

重载运算符顺序

重载运算符的顺序是由编程语言的语法规则和编程者的设计决定的。

在C++中，重载运算符的一般格式为：cpp复制代码
返回类型operator@(参数表) {
重载函数体;
}
对于重载运算符的顺序，C++并没有规定特定的顺序。

你可以根据需要，按照你的编程逻辑和设计要求，来决定先重载哪个运算符，后重载哪个运算符。

然而，有一些规则是需要注意的：
1.不允许定义新的运算符。

2.不能改变该运算符操作数（对象）的个数。

3.不能改变该运算符的优先级别和结合性。

4.应该符合实际需要，重载的功能应该与运算符原有的功能相似，避免没有目的的使用重载运算符。

此外，运算符重载可以是成员函数，也可以是友元函数。

如果运算符重载为友元函数，需要在相应的类中声明为该类的友元函数。

因此，重载运算符的顺序并没有固定的规则，而是由编程者的设计需求和编程逻辑决定的。

同时，还需要注意遵守上述的运算符重载规则。

运算符重载模板写法

运算符重载模板写法运算符重载写为成员函数还是全局函数的格式，取决于你所要达到的⽬的。

重载为成员函数，那么该运算符的左边必须是某个类的对象实例。

重载为全局函数，可以⾃定义该运算符的左边是什么东西，右边是什么东西。

左边接受范围是第⼀个参数类型，右边接受范围是第⼆个参数类型。

运算符重载的注意点：⼀些常见的运算符重载模板：#include <iostream>using namespace std;class Point {int x;int y;public:Point(int x1 = 0, int y1 = 0) :x(x1), y(y1) {}Point(const Point& p) :x(p.x), y(p.y) {}// 输⼊输出运算符重载friend ostream& operator<<(ostream& output, const Point& p);friend istream& operator>>(istream& input, Point& p);// 第⼀个const保证了返回值不可被再次修改// 第三个const保证了const变量也能调⽤该操作符，也可保证成员变量不被修改const Point operator+ (const Point &p) const {return Point(x + p.x, y + p.y);}const Point operator- (const Point& p) const {return Point(x - p.x, y - p.y);}Point& operator+= (const Point& p) {x += p.x;y += p.y;return *this;}// 逻辑运算符bool operator== (const Point& p) const {return (x == p.x) && (y == p.y);}bool operator!= (const Point& p) {return (x != p.x) || (y != p.y);}// 负号，取反运算符const Point operator-() const {return Point(-x, -y);}//前置++Point& operator++() {x++;y++;return *this;}//后置++（括号内的int不可省略，不可更改）const Point operator++(int) {Point old = *this;x++;y++;return old;}void info() {cout << "(" << x << "," << y << ")" << endl;}};ostream& operator<<(ostream& output, const Point& p) { output << "(" << p.x << "," << p.y << ")";return output;}istream& operator>>(istream& input, Point& p) {input >> p.x >> p.y;return input;}int main() {Point p1(10, 20);Point p2(20, 30);Point p3;cout << p1 << endl;cin >> p3;cout << p3 << endl;return0;}。

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重载输入与输出操作符_C教程

C++重载输入与输出操作符_Java教程C++重载输入与输出操作符在C++中，系统已经对左移操作符“<<”和右移操作符“>>”分别进行了重载，使其能够用作输入输出操作符，但是输入输出的处理对象只是系统内建的数据类型。

系统重载这两个操作符是以系统类成员函数的形式进行的，因此cout<< var语句可以理解为：cout.operator<<( var )如果我们自己定义了一种新的数据类型，需要用输入输出操作符去处理，则需要重载这两个操作符。

在前面我们已经定义了complex类，如果我们需要直接输入输出复数的话我们可以对这两个操作符进行重载。

下面将以complex为例说明重载输入输出操作符的方法。

我们可以重载输入操作符，使之读入两个double类型数据，并且将之转换为一个复数，并存入到一个复数类对象中。

我们采用顶层函数的形式来实现输入操作符的重载。

istream & operator>>(istream & in, complex & A){in >> A.real >> A.imag;return in;}在上面函数中istream是指输入流，这个将会在后面讲到。

因为重载操作符函数需要用到complex类的私有成员变量，为了方便，我们将这个函数声明为complex类的友元函数。

其声明形式如下：friend istream & operator>>(istream & in , complex & a);该函数可以按照如下方式使用：complex c;cin>> c;有了这两个语句后，我们输入（↙表示用户按下enter键）1.452.34↙之后这两个数据就分别成立复数类对象c的实部和虚部了。

“cin>> c;”这一语句其实可以理解为：operator<<(cin , c);在重载输入操作符时，我们采用的是引用的方式进行传递参数的，输入的参数里面包含一个istream流的引用，返回值仍然为该引用，因此我们仍然可以使用输入操作符的链式输入。

C++中运算符重载的规则语法实例

C++中运算符重载的规则语法实例运算符重载，就是对已有的运算符重新进⾏定义，赋予其另⼀种功能，以适应不同的数据类型。

之前就知道运算符的重载就是将它重新定义，给它新的功能，为的式符合程序员的要求，⼀个例⼦就是，要将坐标相加，但是电脑不知道怎么相加，于是聪明的⼈就赋予了“+”新的定义。

然⽽⼀些严格意义上的⽤法还不是很清楚。

现在就在这总结⼀下。

⾸先运算符重载的规则如下：①、 C++中的运算符除了少数⼏个之外，全部可以重载，⽽且只能重载C++中已有的运算符。

不能重载的运算符只有五个，它们是：成员运算符“.”、指针运算符“*”、作⽤域运算符“：：”、“sizeof”、条件运算符“？：”。

②、重载之后运算符的优先级和结合性都不会改变。

③、运算符重载是针对新类型数据的实际需要，对原有运算符进⾏适当的改造。

⼀般来说，重载的功能应当与原有功能相类似，不能改变原运算符的操作对象个数，同时⾄少要有⼀个操作对象是⾃定义类型。

运算符重载为类的成员函数的⼀般语法形式为：函数类型 operator 运算符（形参表）{函数体；}⼲脆将⼀些运算符重新列出下⼀下：可以⽤作重载的运算符:算术运算符：+,-,*,/,%,++,--;位操作运算符：&,|,~,^,＜＜,＞＞逻辑运算符：!,&&,||;⽐较运算符：＜,＞,＞=,＜=,==,!=;赋值运算符：=,+=,-=,*=,/=,%=,&=,|=,^=,＜＜=,＞＞=;其他运算符：[],(),-＞,,(逗号运算符),new,delete,new[],delete[],-＞*下列运算符不允许重载：.,.*,::,?:（上⾯也说了的）下⾯给例⼦Boxoperator+(const Box&, const Box&);声明加法运算符⽤于把两个 Box 对象相加，返回最终的 Box 对象。

⼤多数的重载运算符可被定义为普通的⾮成员函数或者被定义为类成员函数。

C 运算符重载实例

1.赋值函数的重载示例程序代码如下#include "stdafx.h"#include <malloc.h>class stack{private:int *sp, top, max;void inflate();public:stack(int size = 10){sp = (int *)malloc(sizeof(int) * size); max = size;top = 0;}int pop();void push(int value);stack & operator=(stack & rightValue); };//栈的容量增倍void stack::inflate(){int index, *tp;tp = (int *)malloc(sizeof(int) * max * 2); for(index = 0; index < top; index++){tp[index] = sp[index];}max += max;free(sp);sp = tp;}//出栈int stack::pop(){if(top <= 0)throw 1;return sp[--top];}//入栈void stack::push(int value){if(top == max)inflate();sp[top++] = value;}//赋值函数stack & stack::operator=(stack & rightValue){top = rightValue.top;max = rightValue.max;sp = (int *)malloc(sizeof(int) * max);for(int index = 0; index < max; index++){sp[index] = rightValue.sp[index];}return *this;}void main(){stack x(100), y, z;z = y = x;}这里要注意的是赋值函数的返回值是stack &，这是为了实现链式表达式，如z = y = x;。

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
函数的重载所谓函数的重载是指完成不同功能的函数可以具有相同的函数名。 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++中，重载等号运算符（operator=）允许你定义当两个对象进行赋值操作时的行为。

默认情况下，编译器会为类提供一个基本的赋值运算符实现，但通常情况下，你可能需要自定义赋值运算符以满足特定的需求。

重载等号运算符的函数原型通常如下：cpp复制代码ClassName& operator=(const ClassName& other);这个函数返回一个对调用对象的引用（通常使用ClassName&），并接受一个常量引用参数（通常是const ClassName&），它表示要被复制的对象。

以下是一个简单的示例，演示如何重载等号运算符：cpp复制代码class MyClass {private:int value;public:MyClass(int v) : value(v) {}// 重载等号运算符MyClass& operator=(const MyClass& other) {// 防止自赋值if (this == &other) {return *this;}// 执行赋值操作value = other.value;// 返回调用对象的引用return *this;}// 获取value的值int getValue()const {return value;}};int main() {MyClass obj1(10);MyClass obj2(20);// 使用重载的等号运算符obj2 = obj1;// 输出obj2的value，应该为10std::cout << obj2.getValue() << std::endl;return0;}在这个例子中，MyClass类重载了等号运算符，以便在obj2 = obj1;这样的语句执行时，obj2的value成员变量会被设置为obj1的value成员变量的值。

c 重载运算符

c 重载运算符C++中的重载运算符是一种非常有用的功能，可以让开发者自定义类的行为，使其更符合自己的需求。

重载运算符可以让类对象像基本类型一样进行运算，比如加、减、乘、除等。

这些运算符重载函数在类中被定义，它们使用特殊的语法来表示运算符的操作。

在C++中，有些运算符必须要被重载，比如等于、不等于、小于等等。

其他的运算符可以根据需求进行重载。

重载运算符的参数和返回值可以是任意类型，但是它们的语法必须要遵循一定的规则。

重载运算符的函数名以'operator'开头，后面跟着要重载的运算符，比如'operator+'表示重载加运算符。

重载运算符函数可以是类的成员函数，也可以是全局函数。

需要注意的是，重载运算符函数必须至少有一个参数，但是几乎所有的运算符都只需要一个参数。

举个例子，如果我们要重载'+'运算符，我们可以在类中定义如下函数：class MyClass {public:MyClass operator+(const MyClass& other) {//重载'+'运算符}};这个函数将两个MyClass对象相加并返回一个新的MyClass对象。

这样我们就可以像下面这样使用加法运算符：MyClass a, b, c;c = a + b;除了基本运算符，我们还可以重载一些其他的运算符，比如()、[]、->等等。

重载这些运算符可以让我们自定义对象的操作，使得代码更加简洁易懂。

总之，重载运算符是C++中非常有用的一个功能，可以让我们自定义对象的行为，使得代码更加灵活、可读性更高。

需要注意的是，重载运算符函数必须遵循一定的规则，才能正确地使用。

C++运算符重载（简单易懂）

C++运算符重载（简单易懂）运算符重载，就是对已有的运算符重新进⾏定义，赋予其另⼀种功能，以适应不同的数据类型。

你可以重定义或重载⼤部分 C++ 内置的运算符。

例如 + 、 - 、 * 、 / 、++、--、>>、<<等，这样，你就能使⽤⾃定义类型的运算符。

运算符重载的基本格式重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。

与其他函数⼀样，重载运算符有⼀个返回类型和⼀个参数列表。

Point operator+(const Point &);运算符重载有两种⽅式：⼀种是类内重载（运算符重载函数作为类的成员函数），另⼀种是类外重载（运算符重载函数作为类的友元函数）类内重载#include <iostream>using namespace std;class Point{public:Point(){};Point (int x, int y): x(x),y(y) {};Point operator+(const Point &a){ //类内重载，运算符重载函数作为类的成员函数Point ret;ret.x = this->x + a.x;ret.y = this->y + a.y;return ret;}int x,y;};int main() {Point a(2,4),b(5,3);Point c = a + b;cout<< "x :" << c.x << endl;cout<<"y :" << c.y << endl;}当上⾯的代码被编译和执⾏时，它会产⽣下列结果：x : 7y: 7运算符重载是类内重载时，运算符重载函数作为类的成员函数，以上述代码为例 a + b 相当于 a 对象调⽤+⽅法并且传⼊参数时 b 对象类外重载#include <iostream>using namespace std;class Point{public:Point(){};Point (int x, int y): x(x),y(y) {};friend Point operator+(const Point &, const Point &);int x,y;};Point operator+(const Point &a,const Point &b){//类外重载,运算符重载函数作为类的友元函数Point ret;ret.x = a.x + b.x;ret.y = a.y + b.y;return ret;}int main() {Point a(2,4),b(5,3);cout<< "x :" << c.x << endl;cout<<"y :" << c.y << endl;}当上⾯的代码被编译和执⾏时，它会产⽣和上⾯⼀样的结果各种运算符重载实例下⾯将进⾏各种运算符重载实例的代码演⽰，演⽰⼏种基本的运算符重载。

c程序设计课件第7章运算符重载

类型的操作数上面。
2
class Money
{public: Money(int y = 0, int j = 0, int f = 0)
构造函数
{ yuan = y; jiao = j; fen = f; optimize( ); }
void Display(string);
private:
Money cost1(10, 3, 5);
if ( jiao >= 10 ){ yuan++; jiao -=10; } }
void Money::Display(string str)
{ cout << str << " = " << yuan << "." << jiao << fen << "￥" <<
endl; } 3
class Money {public: Money(int y = 0, int j = 0, int f = 0) { yuan = y; jiao = j; fen = f; optimize( ); } void Display(string);
调用：total1 = cost1 + cost2; 形参的顺序任意，不要求第一个参数必须为类对象。要
求运算符左侧的操作数与第一个参数对应，运算符右侧
的操作数与第二个参数对应。
13
7.3 重载运算符的规则
❖（1）C++不允许用户自己定义新的运算符，只能对C++语言中已有的运算符进行重载。例如，虽然在某些程序设计语言中用双字符“**” 作为求幂运算符，但是在使用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重载赋值运算符C++中的赋值运算符（=）是一种特殊的运算符，用于将一个对象的值赋给另一个对象。

在C++中，我们可以通过重载赋值运算符来定义自己的赋值操作。

重载赋值运算符可以使得对象之间的赋值更加灵活和方便，同时也可以避免浅拷贝带来的问题。

重载赋值运算符的语法如下：```class ClassName{...ClassName& operator=(const ClassName& other){// 赋值操作的具体实现return *this;}...};```在重载赋值运算符时，我们需要注意以下几点：1. 返回类型应为类的引用，这样可以实现连续赋值（例如`a = b = c`）；2. 参数应为常量引用，以避免不必要的拷贝构造函数调用；3. 在赋值操作中，应先判断是否为自我赋值，避免出现问题；4. 在赋值操作中，应先释放原有内存，再进行深拷贝；5. 赋值操作应返回赋值后的对象。

下面通过一个示例来说明重载赋值运算符的使用。

```cpp#include <iostream>using namespace std;class MyString{private:char* str;public:MyString(const char* s = ""){// 构造函数，实现字符串初始化int size = strlen(s) + 1;str = new char[size];strcpy(str, s);}MyString(const MyString& other){// 拷贝构造函数，实现深拷贝int size = strlen(other.str) + 1;str = new char[size];strcpy(str, other.str);}MyString& operator=(const MyString& other){ // 重载赋值运算符，实现赋值操作if(this == &other){ // 自我赋值检测return *this;}delete[] str; // 释放原有内存int size = strlen(other.str) + 1;str = new char[size];strcpy(str, other.str);return *this;}void print(){cout << str << endl;}~MyString(){// 析构函数，释放内存delete[] str;}};int main(){MyString s1("Hello");MyString s2("World");MyString s3;s3 = s2 = s1; // 连续赋值s3.print(); // 输出"Hello"s2.print(); // 输出"Hello"s1.print(); // 输出"Hello"return 0;}```在上面的示例中，我们定义了一个简单的字符串类`MyString`，并重载了赋值运算符。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

c++ 运算符重载的写法
在C++中，运算符重载允许我们重新定义已有的运算符，使其适用于自定义的数据类型。

这样可以使得我们的自定义类型具有与内置类型相似的行为。

运算符重载的写法如下：
1. 成员函数形式：
返回类型 operator运算符(参数列表) {。

// 实现运算符重载的逻辑。

}。

这里的operator运算符是要重载的运算符，参数列表是运算符操作的参数。

返回类型是运算符操作的结果类型。

2. 友元函数形式：
friend 返回类型 operator运算符(参数列表) {。

// 实现运算符重载的逻辑。

}。

在这种形式下，operator关键字后面紧跟要重载的运算符，然后是参数列表和实现运算符重载的逻辑。

需要注意的是，不是所有的运算符都可以被重载，也不是所有
的运算符都可以以成员函数的形式进行重载。

例如，赋值运算符`=`, 成员访问运算符`->`和作用域解析运算符`::`不能被重载。

此外，在进行运算符重载时，需要注意避免对运算符的本质含
义进行过度改变，以免造成混淆。

另外，为了避免歧义，建议仅重
载已有含义的运算符，不要创建新的运算符。

最后，在实现运算符
重载时，需要考虑重载后的运算符操作是否符合常规的语义，以及
是否符合预期的行为。

总之，C++中的运算符重载为我们提供了一种非常灵活的方式，
可以使得自定义类型具有与内置类型相似的行为，但是在使用时需
要谨慎考虑，避免造成混淆和歧义。