下载文档原格式
介绍C#中的运算符重载.介绍 C# 中的运算符重载周融，2007 年 5 ⽉(C) 2001-2007 保留所有权利。
重载是⾯向对象中的⼀个重要概念，它是对象多态性的⼀种不完全体现，⼈们通常所说的重载，往往指的是函数的重载。
本⽂向读者介绍⼀种新的重载模型——运算符重载。
在本⽂中的内容：1、为什么需要运算符重载2、C# 运算符重载决策⽰例3、C# 运算符重载⼀览表4、结论为什么需要运算符重载函数的重载为⼀个对象上的相同⾏为提供不同的参数⽅式，这样，开发⼈员便可以使⽤这些不同的参数实现类似的功能。
⼀组函数重载决策⼀般实现的功能是相同的，例如对 Object 对象上的 ToString() ⽅法就有⼏个重载版本，虽然它们接受的参数不同，但却都表达同⼀个⾏为的最终结果。
参数的不同导致函数重载版本的签名不同，这样编译器很容易知道需要调⽤那⼀个重载版本。
这种技术给开发⼈员带来了⽅便。
现在我们试图对重载的定义进⾏推⼴。
先让我们看看最简单的例⼦，我们通常需要像这样声明并初始化⼀个值类型的变量：int digit = 5;string sayHello = "Hello, World";这⾥的“=”运算符，就是将右边的值传递给左边变量的赋值运算符。
这⾥，5 的类型为 int，“Hello, World”的类型为 string，这与左边被赋值的变量类型完全⼀致。
但对于上述的解释，我们还可以这样认为：5 的类型为 uint 或 byte，"Hello, World"的类型为 char[]，那么如此⼀来，赋值运算左边和右边的类型就不在等同，那么编译器如何处理呢？有⼈会说，这就是“隐式类型转换”，这个答案确实很好，但隐式类型转换的规则已经被编译器确定，如果赋值运算的两端不遵循隐式类型转换规则，则需要显式类型转换，例如：char c = '2';string s = (string)c;int i = (int)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. 算术运算符重载算术运算符包括加号、减号、乘号和除号。
每个算术运算符都有一组默认的行为,可以通过运算符重载来自定义它们的行为。
例如,重载加号运算符可以使函数接受一个整数参数,并返回一个新的整数。
下面是一个简单的例子,演示了如何重载加号运算符:```c++struct MyStruct {int value;};MyStruct operator+(const MyStruct& other, int value) {return MyStruct(value + other.value);}int main() {MyStruct mystruct1 = { 10 };MyStruct mystruct2 = { 20 };int result = mystruct1 + mystruct2;std::cout << "result = " << result << std::endl;return 0;}```在上面的例子中,我们定义了一个名为`MyStruct`的结构体类型,其中包含一个整数类型。
然后,我们定义了一个重载加号运算符的函数,该函数接受一个整数类型的参数,并返回一个新的`MyStruct`对象。
在`main`函数中,我们定义了两个`MyStruct`对象`mystruct1`和`mystruct2`,并将它们相加,结果存储在`result`变量中。
2. 逻辑运算符重载逻辑运算符包括条件运算符和逻辑非运算符。
每个逻辑运算符都有一组默认的行为,可以通过运算符重载来自定义它们的行为。
c语言重载赋值运算符【原创版】目录1.概述 C 语言中的运算符重载2.赋值运算符重载的规则和注意事项3.示例：实现一个简单的赋值运算符重载正文一、概述 C 语言中的运算符重载C 语言是一种广泛应用的编程语言，其功能丰富，可以实现各种复杂的操作。
在 C 语言中，运算符重载是一种重要的语言特性，它允许程序员根据需要自定义运算符的行为。
运算符重载可以让代码更加简洁，提高程序的可读性。
在 C 语言中，赋值运算符重载是最常用的一种运算符重载方式。
二、赋值运算符重载的规则和注意事项赋值运算符重载是指对 C 语言中的赋值运算符“=”进行重载，以实现特定的功能。
在实现赋值运算符重载时，需要遵循以下规则：1.运算符重载函数必须有一个参数，即要赋值的对象。
2.运算符重载函数不能有返回值。
赋值运算符的功能是将右侧表达式的值赋给左侧的对象，因此不能有返回值。
3.运算符重载函数的函数名以“operator”开头，后跟赋值运算符“=”。
例如，实现一个整数类型的赋值运算符重载，函数名应为“operator=”。
4.在运算符重载函数中，不能修改左侧的对象。
只能通过拷贝构造函数或赋值运算符来修改对象的值。
5.运算符重载函数的参数类型必须与左侧对象的类型匹配。
三、示例：实现一个简单的赋值运算符重载下面是一个简单的示例，实现了一个整数类型的赋值运算符重载。
在这个示例中，我们定义了一个名为“Int”的整数类，并在其中实现了赋值运算符重载。
```c#include <iostream>using namespace std;class Int {public:// 构造函数Int(int value) {this->value = value;}// 拷贝构造函数Int(const Int& other) {this->value = other.value;}// 重载赋值运算符void operator=(const Int& other) {if (this == &other) {return; // 禁止自我赋值}this->value = other.value;}// 打印函数void print() {cout << "Value: " << value << endl;}private:int value;};int main() {Int a, b;a = 10;b = a;b = 20;a.print(); // 输出：Value: 20return 0;}```在这个示例中，我们定义了一个名为“Int”的整数类，并在其中实现了赋值运算符重载。
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类中声明它为友元函数。
运算符重载内容安排1 运算符重载2 运算符重载的规则3 重载为类的成员函数4 重载为类的友元函数5 典型运算符的重载1 运算符重载在C++中，所有系统预定义的运算符都是通过运算符函数来实现的。
a+boperator+(a,b)operator+(int,int)int a,b;运算符重载是指对已有的运算符赋予它新的含义，是通过运算重载函数来实现的，本质上也是属于函数重载，是C++实现静态多态的重要手段。
在用户自定义的新类中可以重载这些函数。
2 C++运算符重载的规则不允许定义新的运算符，只能对已有预定义运算符进行重载。
不能改变运算符操作数（对象）的个数。
不能改变该运算符的优先级别和结合性。
运算符重载应该符合实际需要，重载的功能应该与运算符原有的功能相似。
大多数预定义的运算符都可以被重载（除成员访问运算符“.”、成员指针运算符“.*”、作用域运算符“::”、条件运算符“？：”、sizeof外）。
在类中对运算符进行重载的方式（对该类对象进行运算）：▪可重载为类的成员函数▪可重载为类的友元函数在类中定义一个同名的运算符函数来重载该函数。
运算符函数的原型声明格式如下：TYPE operator@（形参表）;关键字@代表被重载的运算符运算符函数的返回值类型函数名Complex operator+(Complex&);形参表为参与运算的数据即操作数，可以是0个或1个，分别对应单目运算符和双目运算符两种。
重载为类的成员函数：：参数个数＝操作数个数－1由于将运算符函数重载为类的成员函数，所以，操作的一方当然是当前对象：▪如果重载单目运算符（例如++，--），就不必另设置参数，参数为0个；▪如果是重载双目运算符（例如+，-，*，/），只设置一个参数作为右侧运算量，而左侧运算量就是该对象本身。
Complex operator++();Complex a;++a;Complex operator+(Complex&);Complex a,b;a=a+b;a=a.operator+(b);a.operator++();【例4-1】定义一个表示复数的类Complex，并在该类中对运算符“+”进行重载，以实现两个复数的加运算，要求将运算符重载为类的成员函数。
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;}当上⾯的代码被编译和执⾏时，它会产⽣和上⾯⼀样的结果各种运算符重载实例下⾯将进⾏各种运算符重载实例的代码演⽰，演⽰⼏种基本的运算符重载。
第6课运算符重载一、运算符重载的含义重载是C++语言的一个特点，在第2课中我们讨论了函数重载，在本课中，我们来学习运算符重载。
首先来看一下，运算符重载的含义。
看下面的例子：--------------------------------------------------------------------- #include <iostream>using namespace std;int main(){int a1,a2;a1=10;a2=20;int a3=a1+a2;cout<<"a3="<<a3<<endl;return 0;}--------------------------------------------------------------------- 在“a3=a1+a2”这个表达式中，有一个加法运算，使用“+”号对两个变量进行运算。
那么，能否使用“+”号对类的两个对象进行运算呢？像下面这样：--------------------------------------------------------------------- #include <iostream>using namespace std;class A{…}int main(){A a1,a2,a3;…a3=a1+a2;…return 0;}--------------------------------------------------------------------- 回答是肯定的。
C++语言通过对“+”运算符进行重载，就可以实现这样的功能。
运算符重载，就是赋予运算符新的含义（功能），使之能够对类的对象进行运算，从而让程序更加简洁、更加直观。
运算符重载，是通过编写运算符的重载函数来实现的。
运算符重载函数的格式如图8-1所示。
运算符重载详解1.运算符重载定义：C++中预定义的运算符的操作对象只能是基本数据类型。
但实际上，对于许多⽤户⾃定义类型（例如类），也需要类似的运算操作。
这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够⽤于特定类型执⾏特定的操作。
运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引⼈的特性之⼀。
运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进⾏的操作。
运算符函数的定义与其他函数的定义类似，惟⼀的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。
运算符函数定义的⼀般格式如下：<返回类型说明符> operator <运算符符号>(<参数表>){<函数体>} 2.运算符重载时要遵循以下规则：(1) 除了类属关系运算符"."、成员指针运算符".*"、作⽤域运算符"::"、sizeof运算符和三⽬运算符"?:"以外，C++中的所有运算符都可以重载。
(2) 重载运算符限制在C++语⾔中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。
(3) 运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。
(4) 重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。
(5) 运算符重载不能改变该运算符⽤于内部类型对象的含义。
它只能和⽤户⾃定义类型的对象⼀起使⽤，或者⽤于⽤户⾃定义类型的对象和内部类型的对象混合使⽤时。
(6) 运算符重载是针对新类型数据的实际需要对原有运算符进⾏的适当的改造，重载的功能应当与原有功能相类似，避免没有⽬的地使⽤重载运算符。
（7）重载运算符的函数不能有默认的参数，否则就改变了运算符的参数个数，与前⾯第3点相⽭盾了；（8）重载的运算符只能是⽤户⾃定义类型，否则就不是重载⽽是改变了现有的C++标准数据类型的运算符的规则了，会引会天下⼤乱的；（9）⽤户⾃定义类的运算符⼀般都必须重载后⽅可使⽤，但两个例外，运算符“=”和“&”不必⽤户重载；（10）运算符重载可以通过成员函数的形式，也可是通过友元函数，⾮成员⾮友元的普通函数。
