重载函数

一、重载运算符 在C++中，不只是函数可以重载，某些运算符也是可以重载的，即可以自定义运算符的功能，可以重载的运算符如下： 运算符 名称 类型 , 逗号 二进制 ! 逻辑“非” һԪ != 不相等 二进制 % ȡģ 二进制 %= 取模赋值 二进制 & 按位“与” 二进制 & address-of һԪ && 逻辑“与” 二进制 &= 按位“与”赋值 二进制 ( ) 函数调用 ― ( ) 强制转换运算符 һԪ * 乘法 二进制 * 指针取消引用 һԪ *= 乘法赋值 二进制 + 添加 二进制 + 一元加 һԪ ++ 递增 1 һԪ += 加法赋值 二进制 - 减法 二进制 - 一元求反 һԪ -- 递减 1 һԪ -= 减法赋值 二进制 -> 成员选择 二进制 ->* 指向成员的指针选定内容 二进制 / 除法 二进制 /= 除法赋值 二进制 < 小于 二进制 << 左移 二进制 <<= 左移赋值 二进制 <= 小于或等于 二进制 = 赋值 二进制 == 相等 二进制 > 大于 二进制 >= 大于或等于 二进制 >> 右移 二进制 >>= 右移赋值 二进制 [ ] 数组下标 ― ^ 异或 二进制 ^= 异或赋值 二进制 | 按位“与或” 二进制 |= 按位“与或”赋值 二进制 || 逻辑“或” 二进制 ~ 二进制反码 һԪ delete Delete ― new New ―

1. 不改变运算符的优先级 2. 不改变运算符的结合性 3. 不改变运算符所需要的操作数 4. 不能创建新的运算符 5. 运算符函数可以重载为成员函数或者友元函数 } 类型 类名 默认版本 一元运算符 Object.operator op() 二元运算符 Objectl op objectr Objectl.operator op (objectr) 用成员函数重载运算符 Class x }; 此时当前对象作为运算符的左操作数，它时通过 this 指针隐含的传递给函数的。 { public: Complex( ) {real=0,imag=0;} Complex(double r,double i) {real=r; imag=i;} void display( ); private: double real; double imag; }; ComplexComplex:: operator + (Complex &c2) { return Complex(real+c2.real, imag+c2.imag);} void Complex::display( ){ cout<<"("<<real<<","<<imag<<"i)"<<endl;} int main( ){ Complex c1(3,4),c2(5,-10),c3; c3=c1+c2; cout<<"c1=";c1

//重载与模板 //函数模板可以被另一个或普通非模版函数重载，名字相同的函数必须具有不同数量或类型的参数 template < typename T > string debug_rep( const T &) { /**/ } template < typename T > string debug_rep( T * p ) { /**/ } string debug_rep( const string &) { /**/ } //编译器会先选择非模板函数版本。 debug_rep< string >( const string &) //使用模板函数 debug_rep( const string &) //使用非模板函数 //模板特例化 //一个特例化版本就是模板的一个独立的定义，在其中一个或多个模版参数被指定为特定的类型 //函数模板特例化 //当我们特例化一个函数模板时，必须为原模板中的每个模板参数都提供实参 //定义一个特例化版本时，函数参数类型必须与一个先前声明的模板中对应的类型匹配。 //使用关键字template后跟一个空尖括号，空尖括号指出我们将为原模板的所有模板参数提供实参 template < typename T > int compare( const T &, const T &); template <> int compare( const

函数重载（静多态） 函数重载的命名规则 函数重载的调用规则 函数重载的原理 倾轧(mangling) 函数默认参数 默认参数的定义规则 默认参数的使用规则 引用 引用的特性 date: 2019-9-13 title: 函数重载（静多态） 函数重载的命名规则 通过判断函数形参的类型、个数和顺序来区分多个相同函数名的函数 函数的返回值类型，不是区分函数重载的条件 函数重载的调用规则 参数类型符合时，严格按照上述要求调用 参数类型不符合时，编译系统会对参数进行隐式转换后，寻找对应的重载函数。 隐式转换的原则：低精度数据会自动转成高精度数据后，寻找对应的重载函数，如上述条件不满足，无高精度参数的函数，则会降低精度进行转换，此时可能会出现函数调用的歧义（ambiguous）现象，如数据为 int类型，但是重载函数参数只有double和float类型，或者数据为double类型，但是重载函数只有int和float类型的，再或者是，数据为long int，但是 重载数据只有int，double， float类型的。 因此总结，若函数重载时涉及参数隐式类型转换的，同时数据为高精度向低精度转换，则极有可能会出现歧义，编译器可能将其转换为任意一种低精度的数据。 函数重载的原理 倾轧(mangling) 倾轧的本质就是对函数的重命名 倾轧技术发生在两个阶段，.cpp编译阶段，和.h的声明阶段

new operator 我们平时使用的new是new操作符(new operator)，就像sizeof一样是语言内置的，不能改变它的含义，功能也是一样的 比如： string * ps = new string ( "Memory Management" ); 相当于 void * memory = operator new ( sizeof ( string )); // 得到未经处理的内存，为String对象 call string :: string ( "Memory Management" ) on * memory ; // 调构造函数将字符串放到内存 string * ps = static_cast < string *>( memory ); // 使ps指针指向新的对象 new操作符总是做两件事： 1.调用相应的operator new分配内存 2.调用相应的构造函数 如下代码： class T { public : T (){ cout << "构造函数。" << endl ; } ~ T (){ cout << "析构函数。" << endl ; } void * operator new ( size_t sz ){ T * t = ( T *) malloc ( sizeof ( T )); //operator new就是简单的分配内存即可

https://stackoverflow.com/questions/8777845/overloading-member-access-operators-c struct client { int a ; }; struct proxy { client * target ; client * operator ->() const { return target ; } }; struct proxy2 { proxy * target ; proxy & operator ->() const { return * target ; } }; void f () { client x = { 3 }; proxy y = { & x }; proxy2 z = { & y }; std 并非如普通操作符一样在class内部定义一个函数做重载,而是通过一个代理类. 来源：博客园 作者： sdu20112013 链接：https://www.cnblogs.com/sdu20112013/p/11440680.html

函数重载（函数重名）： 1、构成重载的条件：参数类型不同或者参数个数不同（不严谨的）， 与返回值无关 。 2、函数重载：同名的两个 函数的签名（参数的类型、顺序、个数） 不能完全一致，否则就会异常。当两个函数同名但签名不一样时，两个都可以正常使用，即函数重载。函数重载是正确的也是常用的。和参数名无关。函数名拼写一样只是大小写不一样时，属于函数不同名，C#大小写敏感。 3、 两个函数是否可以重名，跟函数的返回值类型无关。只要函数的签名，即参数的类型、顺序、个数不一样就行 。只要参数的类型、顺序、个数不一致才能函数重名，函数返回值类型一致与否无关。 4、例1： static void Main(string[] args) { SayHello(); SayHello(5); SayHello("张三"); SayHello("张三","二秃子"); SayHello("二秃子"); int i = SayHello("李四"); Console.ReadKey(); } static void SayHello() { Console.WriteLine("你好"); } static void SayHello(int age) { Console.WriteLine("我{0}岁了", age); } static void SayHello(string name) {

1.定义一个复数类Complex，重载运算符“+”、“-”、“*”、“-”“==”，使之能用于复数的加、减、乘、求反以及比较的等运算。要求分别重载运算符函数为Complex类的成员函数和非成员函数（友元函数）。在主函数中进行测试。 #include <iostream> #include <cstdio> using namespace std ; class Complex { public : Complex (){} Complex ( double r , double i ){ real = r ; img = i ;} Complex operator +( const Complex & a ); Complex operator -( const Complex & a ); bool operator ==( const Complex & a ); void display () { printf ( " %f%+fi\n" , real , img ); } friend Complex operator *( const Complex & a , const Complex & b ); friend Complex operator -( const Complex & a ); private : double real ; double img ;

重写 重写是指子类重写父类的成员方法。子类可以改变父类方法所实现的功能， 但子类中重写的方法必须与父类中对应的方法具有相同的方法名。也就是说 要实现重写，就必须存在继承。 #重写：子类实现父类的同名方法。 实例1： class Person(): def print_info(self): print("*************") class ChinesePerson(Person): def print_info(self): #子类重写父类的print_info方法 print("________") p= ChinesePerson() #子类实例 p.print_info() #子类调用重写方法 p1=Person() #父类实例 p1.print_info() #父类调用重写方法 E:\>py -3 a.py ________ ************* 实例2： class Person(): def __init__(self,name): self.name = name def get_name(self): return self.name def set_name(self,name): if len(name)>5: return self.name = name class ChinesePeople(Person): def __init__

多态的类型 ：分为4类，重载多态，强制多态，包含多态，参数多态。 以前所学过的普通函数的重载也属于重载多态。强制多态是指将一个变元的类型加以变化，以符合一个函数或操作的要求，比如int型与float型相加，要先进行类型转换。 多态的实现 ：分为两类，编译时的多态与运行时的多态。 前者在编译的过程中确定了同名的具体操作对象，而后者是在程序运行过程中才多态地确定操作所指向的对象。这种确定操作具体对象的过程就是绑定。绑定工作在编译连接阶段完成的情况为 静态绑定 ，在程序运行过程中完成的情况是 动态绑定 。 运算符重载 运算符重载时对已有的运算符赋予多重含义，使同一个运算符作用于不同的数据类型时有不同的行为。 重载形式 重载为类的非静态成员函数，重载为非成员函数。 两种重载方式的声明语法形式一般相同 都为 返回类型 operator 运算符（形参表） { 函数体 } 非成员函数一般定义为友元函数。 **实现‘+’的重载** #include<iostream> using namespace std; class counter { private: float a; public: counter(float a=0):a(a){} counter operator+(counter& c)const { **//定义为类的非静态成员函数** return counter(a + c.a