2.1 函数重载
c语言函数重载
c语言函数重载C语言是一种广受欢迎的计算机语言，以简单易学及其灵活的特性著称。
它不仅是一种编程语言，还是一种编程范式，用于更好地完成计算机程序的设计和开发。
在计算机程序设计和开发中，函数重载是一个灵活的方法，它可以有效地显示代码的可读性和可扩展性。
本文将介绍C语言函数重载的一般概念，并介绍如何使用它来提高代码可读性和可扩展性。
首先，让我们了解一下什么是函数重载。
函数重载是指在C语言中，允许不同参数引用同一个函数名称，而函数实现不同。
函数名称相同，但参数类型不同，就可以实现函数重载，这样可以提高代码的可读性和可扩展性。
函数重载的主要优势是提高代码的可读性和可扩展性。
由于函数的名称是唯一的，使用者可以更容易地理解函数的功能。
同时，使用者也可以更容易地添加新功能，而不必改变已经存在的函数，提高代码的可扩展性和可维护性。
函数重载还可以提高代码的可重复使用性。
如果两个函数做类似的功能，可以使用函数重载，用一个函数名称，实现不同功能，这样可以大大减少代码量，提高代码的可重复使用性。
函数重载也可以在多个不同的程序中使用，即跨程序函数重载。
函数可以在两个或多个不同的程序中被重载，共享相同的函数名称，这样，可以提高代码的可复用性，以及改进程序可维护性和可扩展性。
函数重载有其局限性。
首先，函数重载只能用于相同参数列表的函数，也就是说，函数重载不能用于不同参数列表的函数。
其次，函数重载只能用于同一个文件中的函数，跨文件的函数重载是不允许的。
最后，只有当参数列表不同时，函数重载才是有效的，如果参数列表相同的函数重载是无效的。
总而言之，C语言函数重载是一种灵活的编程范式，可以显示代码的可读性和可扩展性。
它有很多优势，如提高代码可读性、可重复使用性、可扩展性和可维护性等，但也有一些局限性。
可以重载的运算符
可以重载的运算符随着程序设计语言的发展，越来越多的重载运算符的机会出现。
通过重载运算符，可以方便地对自定义类型进行操作，并提高代码的可读性和可维护性。
以下是一些可以重载的运算符：1. 一元运算符：重载一元运算符可以改变一个对象的状态或值。
常见的一元运算符包括：+（正号）、-（负号）、*（指针）、&（取地址符）、~（按位取反）等。
2. 二元运算符：重载二元运算符可以改变两个对象之间的运算方式。
常见的二元运算符包括：+（加号）、-（减号）、*（乘号）、/（除号）等。
在C++中，还可以重载操作符用于比较操作，如==、!=、<=、>=等。
3. 赋值运算符：重载赋值运算符可以对自定义类型进行赋值操作。
默认的赋值运算符只是简单地复制对象的值，而且会存在浅拷贝和深拷贝的问题。
4. 下标运算符：重载下标运算符可以通过对象数组形式来访问对象中的元素。
这种运算符对于自定义容器和数据结构非常有用。
5. 函数调用运算符：重载函数调用运算符可以让对象具有函数行为。
通过这种方式，可以实现自定义类型的函数调用和参数传递。
6. 前置/后置增量运算符：重载前置/后置增量运算符可以使得对象的值增加或减少。
前置增量运算符在对象的值被使用之前首先递增对象的值，而后置增量运算符在对象的值被使用后递增对象的值。
7. 强制类型转换运算符：重载强制类型转换运算符可以将自定义类型转换为其他数据类型，例如将一个类的对象转换为bool值或整数值等。
通过重载运算符，可以轻松地实现自定义类型的强类型检查和操作。
但是，在重载运算符时应该注意保持一致性和正确性，以确保代码的正确性和可维护性。
什么叫方法的重载
什么叫方法的重载方法的重载是指在一个类中定义多个同名的方法，但它们的参数列表不同。
也就是说，参数的个数、类型、顺序不同，或者参数的返回类型不同。
当调用方法时，根据不同的参数列表选择合适的方法进行执行。
方法的重载有以下特点：1. 方法名相同：方法的重载需要使用相同的方法名，这样才能区分同名的方法，并且方便编程。
2. 参数列表不同：方法的重载通过对参数列表的不同进行区分，可以有不同的参数类型、参数个数、参数顺序，甚至可以有不同的返回类型。
3. 方法的重载与方法的返回类型和访问修饰符无关：方法的重载与方法的返回类型和访问修饰符无关，只与方法的参数列表有关。
为什么需要方法的重载？方法的重载可以提高程序的灵活性和可读性。
因为在不同的情况下，我们可能需要执行相同的操作，但是输入的数据类型或者数量可能不同。
使用方法的重载，我们可以根据不同的参数选择相应的方法进行执行，而不需要定义多个方法来实现相同的功能。
这样，避免了方法名的混乱和代码冗余，提高了代码的可读性和可维护性。
举例来说明方法的重载：假设我们要设计一个计算器类Calculator，其中有两个方法add() 和addAll()，用于相加两个数和多个数的和。
我们可以通过方法的重载来实现这个功能。
javapublic class Calculator {相加两个数public int add(int a, int b) {return a + b;}相加多个数public int addAll(int... nums) {int sum = 0;for (int num : nums) {sum += num;}return sum;}在上面的例子中，add() 方法用于计算两个数的和，参数列表为int a 和int b。
addAll() 方法用于计算多个数的和，参数列表为int... nums，表示可变参数列表，可以传入任意数量的整数。
这样，当我们需要计算两个数的和时，调用add() 方法；当需要计算多个数的和时，调用addAll() 方法。
多型现象 名词解释
多型现象一、多型现象的概念和背景1.1 多型的定义多型（Polymorphism）是面向对象程序设计中的一个重要概念，指的是同一种操作符或函数可以在不同的数据类型上执行不同的操作。
1.2 多型的背景和起源多型概念最早出现在20世纪60年代的编程语言Simula中，被认为是面向对象程序设计的基本特性之一。
它使得程序具有更高的可重用性和灵活性。
二、实现多型的方法2.1 静态多型静态多型是指在编译时确定具体执行的函数或操作符，是传统的多态实现方式。
在静态多型中，函数的重载和运算符重载是主要的实现方式。
2.1.1 函数重载函数重载指的是在同一个作用域内定义了多个同名函数，但参数类型、参数个数或返回值类型不同。
编译器根据函数调用时传递的实参来确定具体调用哪个函数。
2.1.2 运算符重载运算符重载指的是为类的对象定义了与某个运算符关联的函数，使得该运算符可以用于该类的对象。
运算符重载可以实现类似于加法、减法、赋值等操作。
2.2 动态多型动态多型是指在运行时根据对象的实际类型确定具体执行的函数或操作符。
实现动态多型的方式主要有虚函数和接口。
2.2.1 虚函数虚函数是定义在基类中的函数，可以在派生类中被覆盖（重写）。
当通过基类的指针或引用调用虚函数时，根据指针或引用实际指向的对象类型来确定执行的函数。
2.2.1.1 纯虚函数纯虚函数是没有实际的函数实现的虚函数，在基类中只有函数的声明，派生类必须实现该函数。
纯虚函数可以使得基类成为抽象类，只能用于派生其他类而不能实例化。
2.2.2 接口接口是一种规范，用于定义类的行为。
一个类可以实现一个或多个接口，实现接口的类必须提供接口中声明的所有方法。
通过接口，可以实现多个类之间的统一调用。
三、多型实例分析3.1 图形类的多型假设有一个图形类，其中包含一个计算面积的虚函数calcArea()。
派生类圆形类和矩形类分别实现了该虚函数。
程序可以通过图形类的指针来调用这两个派生类的calcArea()函数，实现了动态多态。
C 的高级特性---函数重载,重写,覆盖
C++语言采用重载机制的另一个理由是：类的构造函数需要重载机制。因为C++规定构造函数与类同名（请参见第9章），构造函数只能有一个名字。如果想用几种不同的方法创建对象该怎么办？别无选择，只能用重载机制来实现。所以类可以有多个同名的构造函数。
8.1.2 重载是如何实现的？
int x = Function ();
则可以判断出Function是第二个函数。问题是在C++/C程序中，我们可以忽略函数的返回值。在这种情况下，编译器和程序员都不知道哪个Function函数被调用。
所以只能靠参数而不能靠返回值类型的不同来区分重载函数。编译器根据参数为每个重载函数产生不同的内部标识符。例如编译器为示例8-1-1中的三个Eat函数产生象_eat_beef、_eat_fish、_eat_chicken之类的内部标识符（不同的编译器可能产生不同风格的内部标识符）。
{
void foo(int x, int y);
… // 其它函数
}或者写成
extern “C”
{
#include “myheader.h”
… // 其它C头文件
}
这就告诉C++编译译器，函数foo是个C连接，应该到库中找名字_foo而不是找_foo_int_int。C++编译器开发商已经对C标准库的头文件作了extern“C”处理，所以我们可以用＃include 直接引用这些头文件。注意并不是两个函数的名字相同就能构成重载。全局函数和类的成员函数同名不算重载，因为函数的作用域不同。例如：
示例8-2-1中，函数Base::f(int)与Base::f(float)相互重载，而Base::g(void)被Derived::g(void)覆盖。
第7章 函数重载和运算符重载
7.3 运算符重载
•7.3.2 单目运算符的重载 单目运算符重载时参数只有一个。
class Matrix{ public: Matrix operator –( ); //其他成员 //成员函数，参数表为空
}; Matrix Matirx::operator –( ) { Matirx m(rows,cols); //临时对象 for(int i=0;i<rows;i++) for(int j=0;j<cols;j++) m(m,j)= –(*this)(i,j); return m; }
7.3 运算符重载
Matrix & Matrix::operator=(Matrix &src) { //将 src 的所有元素都复制过来 for(int i=0;i<rows*cols;i++) mem[i]=src.mem[i]; return *this; }
7.3 运算符重载
3. 插入抽取运算符的重载 我们可以通过重载插入和抽取运算符来 获得这种效果。重载的运算符形式如下：
7.3 运算符重载
•7.3.4 特殊运算符的重载 1. 自增自减运算符的重载 如果将自增自减运算符定义为类的成员函数， 则应该没有参数。但是为了区分前缀和后缀， C++规定：后缀自增自减运算符定义时带有一 个整型参数，而前缀自增自减运算符时不带 参数，这样在编译时，系统就知道所重载的 是前缀还是后缀运算符了。
7.3 运算符重载
运算符的重载形式有两种，一种是重载为类 的成员函数，另一种是重载为独立的运算符 函数，一般是作为类的友元函数。运算符重 载的语法形式如下： <函数类型> operator <运算符> (<形参表>) { <函数体> }
重载函数——精选推荐
重载函数出现在相同作⽤域中的两个函数，如果具有相同的名字⽽形参表不同，则称为重载函数。
函数重载和重复声明的区别如果两个函数声明的返回类型和形参表完全匹配，则将第⼆个函数声明视为第⼀个的重复声明。
如果两个函数的形参表完全相同，但返回类型不同，则第⼆个声明是错误的：Record lookup(const Account&);bool lookup(const Account&); // error: only return type is different函数不能仅仅基于不同的返回类型⽽实现重载。
值得注意的是，形参与 const 形参的等价性仅适⽤于⾮引⽤形参。
有 const 引⽤形参的函数与有⾮ const 引⽤形参的函数是不同的。
类似地，如果函数带有指向 const 类型的指针形参，则与带有指向相同类型的⾮ const 对象的指针形参的函数不相同。
重载与作⽤域在函数中局部声明的名字将屏蔽在全局作⽤域（内声明的同名名字。
这个关于变量名字的性质对于函数名同样成⽴.⼀般的作⽤域规则同样适⽤于重载函数名。
如果局部地声明⼀个函数，则该函数将屏蔽⽽不是重载在外层作⽤域中声明的同名函数。
由此推论，每⼀个版本的重载函数都应在同⼀个作⽤域中声明。
⼀般来说，局部地声明函数是⼀种不明智的选择。
函数的声明应放在头⽂件中。
函数匹配与实参转换函数重载确定，即函数匹配是将函数调⽤与重载函数集合中的⼀个函数相关联的过程。
通过⾃动提取函数调⽤中实际使⽤的实参与重载集合中各个函数提供的形参做⽐较，编译器实现该调⽤与函数的匹配。
匹配结果有三种可能：1. 编译器找到与实参最佳匹配的函数，并⽣成调⽤该函数的代码。
2. 找不到形参与函数调⽤的实参匹配的函数，在这种情况下，编译器将给出编译错误信息。
3. 存在多个与实参匹配的函数，但没有⼀个是明显的最佳选择。
这种情况也是，该调⽤具有⼆义性。
⼤多数情况下，编译器都可以直接明确地判断⼀个实际的调⽤是否合法，如果合法，则应该调⽤哪⼀个函数。
【C++】C++函数重载的总结
【C++】C++函数重载的总结函数重载： 出现在相同作⽤域中的两个函数，如果具有相同的名字⽽形参表不同，则称为重载函数(overloaded function)。
⼀定要注意函数重载的两个关键词：形参列表和作⽤域。
任何程序有且仅有⼀个main函数的实例，main函数不能重载。
对于函数重载来说，它们应该在形参数量和形参类型上有所不同。
下⾯论述形参列表和作⽤域对函数重载的影响。
函数重载与形参列表 函数重载和函数声明的区别： 如果两个函数声明的返回类型和形参表完全匹配，则将第⼆个声明视为第⼀个的重复声明。
如果两个函数的形参列表相同（参数个数和类型）相同但是返回类型不同，那么第⼆个函数的声明将会出现编译错误。
函数不能仅仅基于不同的返回类型⽽实现重载。
基于const形参的重载： 当参数是⾮引⽤形参时，形参与const形参的两个同名函数不能构成函数重载。
下⾯的第⼆个函数只是第⼀个函数的重复声明。
1 A func(B);2 A func(const B); // 重复声明 仅当形参是引⽤或指针是，形参是否为const才有影响。
A func(B&);A func(const B&) //基于const引⽤形参的重载A func(B*);A func(const B*); //基于const指针形参的重载可基于函数的引⽤形参是指向const对象还是指向⾮const对象，实现函数重载。
将引⽤形参定义为const来重载函数是合法的，因为编译器可以根据实参是否为const确定调⽤哪⼀个函数。
如果实参为const对象，那么将调⽤const引⽤形参的版本。
如果实参为⾮const对象，⾮const对象既可以⽤于初始化const引⽤，也可以⽤于初始化⾮const引⽤。
但是将const引⽤初始化为⾮const对象，需要转换，因为⾮const形参的初始化则是精确匹配。
对于指针形参也是如出⼀辙。
如果实参是const对象，则调⽤带有const*类型形参的函数。
重载的概念(精)
重载
} vector vector::operator -( vector v1) {
vector v;
v.x = - v1.x; v.y = - v1.y;
return v;
} void main() { vector v1(4.5,-7.8),v2(-1.5,1.2);
v1.print();
重载
Increase & operator ++(); Increase operator ++(int); void display() {cout <<"the value is"<<value<<endl;} //前缀方式
重载
protected:
int value; }; Increase & Increase::operator ++() {
重载
例1 求绝对值函数abs()的重载。 int abs(int x) {
return(x>=0?x:-x);
} float abs(float x) { return(x>=0?x:-x); } long abs(long x)
{
重载
return(x>=0?x:-x);
} double abs(double x) { return(x>=0?x:-x);
v2.print();
重载
}
运行结果为： 4.5 -7.8 -1.5 1.2 3 -3 -6.6 6.6
重载运算符在调用时仍然是靠参数区分的。上例中 重载的运算符“-”，若出现在两个数据之间，只要这两 个数据为相同的基本数据类型、vector类型或其它重载 过的类型，都能正确调用相应的运算代码；若它单独出 现在某个基本数据类型或vector类型等重载过的数据前 面，则自动执行求“相反数”的运算。
没有与指定类型匹配的重载函数
没有与指定类型匹配的重载函数在软件开发领域里，重载函数是指在同一作用域下，函数名相同但参数列表不同的函数。
其目的是为了让同名函数能够处理不同类型或数量的参数，从而提高代码的灵活性和复用性。
然而，在实际开发中，我们有时会遇到“没有与指定类型匹配的重载函数”的情况，接下来让我们深入探讨这个主题。
1. 重载函数的概念重载函数是指在同一作用域下，函数名相同但参数列表不同的函数。
在调用函数时，编译器会根据实际参数类型的匹配来确定调用哪个重载函数。
这样一来，我们可以根据不同的参数类型来实现相同函数名的函数，提高代码的复用性和灵活性。
2. 遇到的问题然而，在实际开发中，我们有时会遇到“没有与指定类型匹配的重载函数”的情况。
这种情况通常出现在以下几种情况下：- 参数类型不匹配：当调用函数时传入的参数类型与任何已定义的重载函数都不匹配时，就会出现这种情况。
- 参数数量不匹配：当调用函数时传入的参数数量与任何已定义的重载函数都不匹配时，也会出现这种情况。
3. 解决办法针对参数类型不匹配的情况，我们可以考虑以下几种解决办法：- 定义新的重载函数：根据实际需求，定义新的重载函数，以适配传入的参数类型。
- 强制类型转换：在调用函数时，对参数进行相应的类型转换，从而使其匹配已定义的重载函数。
- 使用模板函数：使用模板函数可以避免参数类型不匹配的问题，因为模板函数可以根据传入的参数类型来生成对应的函数。
而针对参数数量不匹配的情况，我们可以考虑以下解决办法：- 可变参数：使用可变参数函数可以接受不定数量的参数，从而解决参数数量不匹配的问题。
- 函数重载：如果有必要，可以根据实际需要定义新的重载函数，以适配传入的参数数量。
4. 个人观点“没有与指定类型匹配的重载函数”在软件开发中是一个常见的问题，解决这个问题需要我们对函数重载的概念和原理有深入的理解。
在实际开发中，我们应该尽量避免出现这种情况，因为它可能会导致代码的不确定性和易错性。
简述运算符重载的规则。
简述运算符重载的规则。
运算符重载是指可以为自定义的类类型或枚举类型定义新的含义和功能。
在
C++中，运算符重载遵循以下一般规则：
1. 运算符重载必须至少有一个操作数是用户自定义的类类型或枚举类型的对象，否则将无法重载。
2. 运算符重载可以作为成员函数或非成员函数来实现。
3. 对于成员函数的运算符重载，操作数的数量为运算符的操作数减去1。
例如，重载双目运算符时（如+、-、*等），成员函数需要接受一个参数，用于表示另一个操作数。
4. 对于非成员函数的运算符重载，所有操作数都作为参数传递给函数。
可以通过将重载运算符函数声明为友元函数来访问类的私有成员。
5. 对于重载一元运算符（如++、），如果是成员函数，则返回一个修改后的对象；如果是非成员函数，则返回一个新的对象。
6. 对于重载二元运算符（如+、-、*等），如果是成员函数，则一个对象被修改，另一个对象不变；如果是非成员函数，则返回一个新的对象。
7. 运算符重载不能改变原有运算符的优先顺序和结合性。
8. 运算符重载遵循函数重载的规则，即可以根据参数类型和参数数量进行重载，实现不同的功能。
需要注意的是，运算符重载应该遵循语义上的合理性并不滥用。
第2章 C++基础
const double minWage = 9.60; –上面的例题中，cptr是一个指向double类型的const对象的指针 上面的例题中， 不能通过pc修改minWage 上面的例题中 cptr是一个指向double类型的 //正确 正确： 是一个指向double类型的const pc修改minWage的值 pc = &minWage; //正确：不能通过pc修改minWage的值const对象的指针 可以从右往左把这个定义读为“cptr是一个指向double类型的 是一个指向double类型的、 double(可以从右往左把这个定义读为“cptr是一个指向double类型的、 dval = 3.14; 被定义成const对象的指针 修改dval 本身不是常量， const对象的指针 被定义成正确：不能通过pc修改dval，虽然dval本身不是一个常量 const //正确 对象的指针” dval，虽然dval pc修改 cptr本身不是常量 dval本身不是一个常量 pc = &dval; //正确：不能通过pc”)。cptr本身不是常量，可以重新给 cptr赋值，//正确 赋值 使其指向不同的对象，但不能修改cptr所指向的对象 cptr dval =cptr赋值，//正确 3.14159; 使其指向不同的对象，但不能修改cptr所指向的对象 //错误 *pc = 的值，例如： 3.14159; //错误 的值，例如：
int ival = 1024; int 一旦引用已经定义，就不能再指向其他的对象， &refVal = ival; • 一旦引用已经定义，就不能再指向其他的对象，所以引用必须初始 int 化，例如： min_val = 0; 例如： //refVal并没有引用到min_val上 而是ival被设置为min_val 并没有引用到min_val ival被设置为min_val的值 refVal = min_val; //refVal并没有引用到min_val上，而是ival被设置为min_val的值
函数笔记知识点总结
函数笔记知识点总结一、函数的定义和作用1.1 定义：函数是一段完成特定任务的代码块，它接受输入参数、处理数据并返回结果。
1.2 作用：函数能够提高代码的模块化程度，增强代码的可读性和可维护性，同时也能够提高代码的复用性。
二、函数的基本结构2.1 函数的声明：函数的声明包括函数名、参数列表和返回值类型。
2.2 函数的实现：函数的实现包括函数体和返回语句。
2.3 示例代码：```C// 函数的声明int add(int a, int b);// 函数的实现int add(int a, int b) {return a + b;}```三、函数的调用3.1 函数的调用：在程序中使用函数时，需要通过函数名和实参来调用函数。
3.2 示例代码：```Cint result = add(2, 3);```四、函数的参数4.1 形参和实参：形参是在函数声明或定义中定义的变量，实参是在函数调用中传入的值。
4.2 默认参数：C++中的函数可以有默认参数，简化函数的调用。
4.3 示例代码：```C// 带有默认参数的函数void greet(string name, string msg = "Hello") {cout << msg << " " << name << "!" << endl;}// 调用带有默认参数的函数greet("Alice"); // 输出：Hello Alice!greet("Bob", "Hi"); // 输出：Hi Bob!```五、函数的返回值5.1 返回值类型：函数可以返回不同类型的值，比如整数、浮点数、字符、布尔值等。
5.2 无返回值函数：如果函数不需要返回值，可以使用void作为返回值类型。
5.3 多返回值：C++中函数可以返回多个值，通过引用类型或指针实现。
函数重载(overload)、函数覆盖(override)
函数重载(overload)、函数覆盖(override)“overload”翻译过来就是：超载，过载，重载，超出标准负荷；“override”翻译过来是：重置，覆盖,使原来的失去效果。
先来说说重载的含义，在日常生活中我们经常要清洗一些东西，比如洗车、洗衣服。
尽管我们说话的时候并没有明确地说用洗车的方式来洗车，或者用洗衣服的方式来洗一件衣服，但是谁也不会用洗衣服的方式来洗一辆车，否则等洗完时车早就散架了。
考试大提示我们并不要那么明确地指出来就心知肚明，这就有重载的意思了。
在同一可访问区内被声名的几个具有不同参数列的（参数的类型、个数、顺序不同）同名函数，程序会根据不同的参数列来确定具体调用哪个函数，这种机制叫重载，重载不关心函数的返回值类型。
这里，“重载”的“重”的意思不同于“轻重”的“重”，它是“重复”、“重叠”的意思。
例如在同一可访问区内有：① double calculate(double);② double calculate(double，double);③ double calculate(double, int);④ double calculate(int, double);⑤ double calculate(int);⑥ float calculate(float);⑦ float calculate(double);六个同名函数calculate，①②③④⑤⑥中任两个均构成重载，⑥和⑦也能构成重载，而①和⑦却不能构成重载，因为①和⑦的参数相同。
覆盖是指派生类中存在重新定义的函数，其函数名、参数列、返回值类型必须同父类中的相对应被覆盖的函数严格一致，覆盖函数和被覆盖函数只有函数体（花括号中的部分）不同，当派生类对象调用子类中该同名函数时会自动调用子类中的覆盖版本，而不是父类中的被覆盖函数版本，考试大,提示这种机制就叫做覆盖。
下面我们从成员函数的角度来讲述重载和覆盖的区别。
成员函数被重载的特征有：1) 相同的范围（在同一个类中）2) 函数名字相同3) 参数不同4) virtual关键字可有可无覆盖的特征有：1) 不同的范围（分别位于派生类与基类）2) 函数名字相同3) 参数相同4) 基类函数必须有virtual关键字比如，在下面的程序中：#includeusing namespace std;class Base{public:void f(int x){ cout << "Base::f(int) " << x << endl; }void f(float x){ cout << "Base::f(float) " << x << endl; }virtual void g(void){ cout << "Base::g(void)" << endl;}};class Derived : public Base{public:virtual void g(void){ cout << "Derived::g(void)" << endl;}};void main(void){Derived d;Base *pb = &d;pb->f(42); // 运行结果: Base::f(int) 42pb->f(3.14f); // 运行结果: Base::f(float) 3.14pb->g(); // 运行结果: Derived::g(void)}函数Base::f(int)与Base::f(float)相互重载，而Base::g(void)被Derived::g(void)覆盖。
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++程序设计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;
第七章 函数的重载
7
实现函数重载
函数重载是通过在类中定义两个或更多的同名的函 数来实现函数重载。 数来实现函数重载。 在函数重载中， 在函数重载中，函数的每个定义必须在函数签名中 不同。 不同。
8
函数签名
函数的签名被下面的部分定义： 函数的签名被下面的部分定义：
参数的数量 参数的类型 参数的顺序 返回类型不是函数签名的一部分
public class DaysInYear { private int days; public DaysInYear(int days) 1.DaysInYear DIY = new DaysInYear(); { 2.DaysInYear DIY = new DaysInYear(5); this.days = days; 3.DaysInYear DIY = new DaysInYear("5"); } public DaysInYear(String dayOne) 4.DaysInYear DIY = new DaysInYear(‘5’); 5.DaysInYear DIY； { days =Convert.ToInt32(dayOne); } 1.错误 错误 public void setDay(int newDays) 2.调用int构造函数 调 构造函数 { 3.调用string构造函数 调 构造函数 days = newDays; 4.调用int构造函数 调 构造函数 } 5.没有对象生成，需要 没有对 或者让 没有 象生成，需要new或者让它指向一 或者 … 个DaysInYear对象 对 }
函数重载： 函数重载：这个方法允许为两个或更多函数使用同样 的名字。 的名字。函数的每个重新定义必须使用不同的参数类 参数顺序或多个参数。 型、参数顺序或多个参数。 操作符重载： 操作符重载：这个方法允许用户定义的类型例如结构 和类，为使它们的对象易于操作而使用重载操作符。 和类，为使它们的对象易于操作而使用重载操作符。
C++程序设计语言 揣锦华 第2章 函数
}
第2章 函数
输入符合要求时（仅有字符0和1）的程序运行结
果为 输入一个8位的二进制数：11010011 十进制值：211 输入不符合要求时（含有除0和1以外的任何字符）
的程序运行结果为
输入一个8位的二进制数：110lao11 这不是一个二进制数! 不能正确转换
第2章 函数 iCount--;
} if(bFlag)
cout<<"十进制值为："<<iValue<<endl;
} double power(double dDishu,int iMi)
{
int iCount; double dResult = 1.0;
for(iCount=1;iCount<=iMi;iCount++)
{
第2章 函数 float fHuashi;
cout<<endl<<"输入一个华氏温度值:"; cin>>fHuashi;
cout<<"华氏"<<fHuashi
<<"度对应摄氏温度"<<hstoss(fHuashi)<<"度"<<endl; //函数调用作为一个表达式出现在输出语句中
}
float hstoss(float fHuashi) {
{ bFlag=true;
第2章 函数
break;
} } if(bFlag==false) return 1;
运算符重载详解
运算符重载详解1.运算符重载定义：C++中预定义的运算符的操作对象只能是基本数据类型。
但实际上，对于许多⽤户⾃定义类型（例如类），也需要类似的运算操作。
这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够⽤于特定类型执⾏特定的操作。
运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引⼈的特性之⼀。
运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进⾏的操作。
运算符函数的定义与其他函数的定义类似，惟⼀的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。
运算符函数定义的⼀般格式如下：<返回类型说明符> operator <运算符符号>(<参数表>){<函数体>} 2.运算符重载时要遵循以下规则：(1) 除了类属关系运算符"."、成员指针运算符".*"、作⽤域运算符"::"、sizeof运算符和三⽬运算符"?:"以外，C++中的所有运算符都可以重载。
(2) 重载运算符限制在C++语⾔中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。
(3) 运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。
(4) 重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。
(5) 运算符重载不能改变该运算符⽤于内部类型对象的含义。
它只能和⽤户⾃定义类型的对象⼀起使⽤，或者⽤于⽤户⾃定义类型的对象和内部类型的对象混合使⽤时。
(6) 运算符重载是针对新类型数据的实际需要对原有运算符进⾏的适当的改造，重载的功能应当与原有功能相类似，避免没有⽬的地使⽤重载运算符。
（7）重载运算符的函数不能有默认的参数，否则就改变了运算符的参数个数，与前⾯第3点相⽭盾了；（8）重载的运算符只能是⽤户⾃定义类型，否则就不是重载⽽是改变了现有的C++标准数据类型的运算符的规则了，会引会天下⼤乱的；（9）⽤户⾃定义类的运算符⼀般都必须重载后⽅可使⽤，但两个例外，运算符“=”和“&”不必⽤户重载；（10）运算符重载可以通过成员函数的形式，也可是通过友元函数，⾮成员⾮友元的普通函数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
（4）计时工人的月工资 ＝ 工作小时 × 小时报酬；
输入：职工类别。管理人员输入月薪和缺勤天数；销售人员输入底薪、销售金额
和提成比例；计件工人输入产品件数和每件报酬；计时工人输入工作小时
和小时报酬。
输出：员工月工资。
输入样例： 1 〈－－职工类别
cout << getEarning(salary, absenceDays);
break;
case 2:
cin >> baseSalary >> salesSum >> rate;
cout << getEarning(baseSalary, salesSum, rate);
break;
case 3:
cin >> workPieces >> wagePerPiece;
cout << getEarning(workPieces, wagePerPiece);
break;
case 4:
{
return ( salary-absenceDays*salary/22 );
}
double getEarning(double baseSalary, double salesSum, double rate)
{
return ( baseSalary+salesSum*rate );
cin >> hours >> wagePerHour;
cout << getEarning(hours, wagePerHour);
break;
default:
break;
}
return 0;
}
{
return ( hours*wagePerHour );
}
int main()
{
int sel, absenceDays, workPieces;
double salary, baseSalary, salesSum, rate, hours, wagePerPiece, wagePerHour;
cout << "Please select..." << endl;
cout << "1: Manager." << endl;
cout << "2: Sales Man." << endl;
cout << "3: Pieces Worker." << endl;
double getEarning(int workPieces, double wagePerPiece);
double getEarning(double hours, double wagePerHour);
using namespace std;
double getEarning(double salary, int absenceDays)
cout << "4: Hour-Worker." << endl;
cout << "Others: Quit" << endl;
cin >> sel;
switch(sel)
{
case 1:
cin >> salary >> absenceDays;
}
double getEarning(int workPieces, double wagePerPiece)
{
return ( workPieces*wagePerPiece );
}
double getEarning(double hours, double wagePerHour)
5000.0 1〈－－月薪和缺勤天数
输出样例： 4772.73 */
#include <iostream>
//计算管理人员、销售人员、计件工人、计时工人的月工资的函数原型
double getEarning(double salary, int absenceDays);
double getEarning(double baseSalary, double salesSum, double rate);
/*标题： 1. 函数重载
描述：设计一菜单程序，利用函数重载实现员工月工资的计算，计算方法如下：
（1）管理人员的月工资 ＝ 月薪 － 缺勤天数 × 月薪 ÷ 22；
（2）销售人员的月工资 ＝ 底薪 + 销售金额 × 提成比例；
（3）计件工人的月工资 ＝ 产品件数 × 每件报酬；