C++教程第07章 类与对象-2成员函数的重载

合集下载

面向对象的程序设计语言――C++(第二版)-习题参考答案

面向对象的程序设计语言――C++(第二版)-习题参考答案

面向对象的程序设计语言――C++(第二版)-习题参考答案课后习题答案以及代码习题参考答案第1章1.填空题C++语言概述(1)函数说明,函数体(2)声明区,主程序区,函数定义区(3)多态性(4)namespace,using(5)std(6)cin,(7)//(8)对数据的操作2.判断题(1)对(2)错(3)错(4)错(5)错3.改错题(1)没有函数体,应改为void main() {};(2)语句没有分号,应改为using namespace myspace;(3)cout和操作符共同完成输出的功能,应改为cout“ Input your name:";(4)应改为#include iostream.h4.简答题5.编程题(略)(略)第2章1.选择题基本数据类型、运算符与表达式(1)B (2)D (3)B (4)D (5)B课后习题答案以及代码2.简答题(1)(a)、(c)(e)、(f)、(g)、(h)、(i)(2)(a)、(g)、(i)、(j)(3)(a)5.5(b)0(c)20(d)0,0(e)1(f)1,2(g)3(h)-40(i)2(j)3(k)s1='0's1='9'(l)N!=03.读程序写结果(1)0,15(2)(1、1、1),(-1、-1、-1)(3)(a)a*a+2*a*b+b*b(b)4.0/3.0*3.__-__R*R*R(c)5.0/9.0*(F-32)(d)b=ab=c(4)364143(5)x=14.编程题(略)第3章1.选择题(1)B (2)A (3)A (4)C2.判断题(1)错(2)对(3)对(4)错3.读程序写结果(1)C++的控制语句5)A 5)错((课后习题答案以及代码12 23 3 34 4 4 45 5 5 5 5(2)11 2 11 2 3 2 11 2 3 4 3 2 11 2 3 4 5 4 3 2 1(3)j的值为0;i的值为2;4.编程题(略)第4章1.填空题函数(1)void(2)静态全局变量,static(3)函数重载(4)inline(5)递归函数(6)宏定义命令,文件包含命令,条件编译命令2.判断题(1)错(2)错(3)错(4)错(5)错(6)对(7)错(8)错(9)对(10)对3.读程序写结果(1)x=7,y=4x=9,y=5(2)34.56101(3)162228(4)12 15 18 21 24课后习题答案以及代码(5)2,1,4,1,3,2,1,4.简答题5.编程题(略)(略)第5章1.选择题构造数据类型(1)C (2)D (3)A (4)B (5)C 2.判断题(1)错(2)对(3)对(4)错(5)错3.读程序写结果(1)153(2)422 5 6 8 10(3)__,21(4)419(5)6904(6)43214.编程题(略)第6章1.填空题(1)类,对象,类(2)数据成员,成员函数(3)不能(4)private,protected,public,private (5)成员函数类和对象课后习题答案以及代码(6)friend(7)类名,作用域运算符(8)对象名.成员名,指针变量名-成员名,(*指针变量名).成员名(9)构造,析构,构造,析构(10)常量数据,引用数据(11)全局,数据类型,所属的类(12)常成员,只读(13)成员,友元(14)类数据成员,类成员函数(15)this(16)浅拷贝2.选择题(1)C (2)C (3)B (4)C (5)B(6)C (7)D (8)B (9)C (10)D(11)A (12)C (13)D (14)D (15)B3.改错题(1)man1.salary=1000.00; 不能在类外访问类的私有成员(2)float r=0;和float c=0; 类本身是抽象的,不能在类的定义体中给其数据成员赋值}后缺少分号“;”(3)成员函数void setdata(float x1,float y1,float r);没有实现(4)构造函数名point()应与类名同名,为Point没有头文件包含#include iostream.h4.读程序写结果题(1)x=0,y=0x=100,y=200(2)x=100,y=200x=1000,y=2022年t=3.14(3)Sta::fun2()=10s.fun2()=11r.a=20(4)Constructor1 called!x=0Constructor2 called!x=100Destructor called!Destructor called!(5)课后习题答案以及代码575.简答题6.编程题(略)(略)第7章1.填空题(1)继承(2)基类,派生类(3)private,protected,public,private (4)不可访问,保护,公有(5)私有(6)单(一),多(重)(7)赋值兼容规则(8)静态,动态(9)抽象类2.选择题继承和派生(1)B (2)A (3)B (4)C (5)B (6)A (7)D (8)B (9)B (10)B(11)D (12)B3.改错题(1)本题的错误主要是数据成员的访问权限问题:基类的私有成员在派生类中不可访问,如fb()函数中的a3=30;语句;类的私有和保护成员在类外不能访问,如main函数中的x.a2 =20;.a3=30; ,y.a2=200; ,y.a3=300; ,y.b2=2022年;和y.b3=3000;语句。

《类与对象》课后习题(含答案)

《类与对象》课后习题(含答案)

问题一:程序执行结果是
问题二:本程序中,y、z 是 class Test{ public: static int Data; }; int Test::Data=100; //A void main(void) { Test t1,t2; t1.Data=200; t2.Data=300; //B //C
2、写出程序的输出结果。 #include <iostream> #include <cstring> using namespace std; class SomeClass { int One , Two; public: SomeClass(int a = 1, int b = 1) { One = a; Two = b; cout << "Structor" << endl; } SomeClass(SomeClass &obj) { { cout<<NumA<<'\t'<<"is Destructor."<<endl; } }; int main() { MyTestClass Myclass1(5), Myclass2.Print(); return 0; } 程序的运行结果为: Myclass2(Myclass1);
,第二行是
A.show( ); } 15 10 三、程序填空题
B.show( );
1、完成如下的类,在横线中填写合适的内容。 #include <iostream> #include <cstring> using namespace std; enum Esex{mid , man , woman};//枚举请自学 2.7 class Person { int Num; //编号 char Name[12]; //姓名 Esex Sex; //性别 float Weight; //体重 public: Person(int , char * , Esex , float); Person(); ~Person() {} void PrintInfo(); int Workdays(); }; Person::Person( { Num = id; int id ,char *name , Esex s , float w)

C++类成员函数的重写、重载和隐藏

C++类成员函数的重写、重载和隐藏

C++类成员函数的重写、重载和隐藏重载(overload)重载的定义为:在同⼀作⽤域中,同名函数的形式参数(参数个数、类型或者顺序)不同时,构成函数重载。

例如:class A{public: int func(int a); void func(int a, int b); void func(int a, int b, int c); int func(char* pstr, int a);};以上的四个函数均构成重载。

需要注意的是: 1.函数返回值类型与构成重载⽆任何关系 2.类的静态成员函数与普通成员函数可以形成重载 3.函数重载发⽣在同⼀作⽤域,如类成员函数之间的重载、全局函数之间的重载这⾥还需要注意⼀下 const重载:class D{public: void funcA(); //1 void funcA() const; //2 void funcB(int a); //3 void funcB(const int a); //4};在类D 中 funcA 与 const funcA是合法的重载,⽽两个 funcB 函数是⾮法的,不能通过编译。

原因是:顶层const不影响重载性,因为值传递的拷贝特性,想函数内传递的值类型形参的变化不会影响实参,所以有⽆const 对其⽽⾔是没有意义的。

调⽤规则:const对象默认调⽤const成员函数,⾮const对象默认调⽤⾮const成员函数;隐藏(hiding)隐藏定义:指不同作⽤域中定义的同名函数构成隐藏(不要求函数返回值和函数参数类型相同)。

⽐如派⽣类成员函数隐藏与其同名的基类成员函数、类成员函数隐藏全局外部函数。

例如:void hidefunc(char* pstr){ cout << "global function: " << pstr << endl;}class HideA{public: void hidefunc(){ cout << "HideA function" << endl; } void usehidefunc(){ //隐藏外部函数hidefunc,使⽤外部函数时要加作⽤域 hidefunc(); ::hidefunc("lvlv"); }};class HideB : public HideA{public: void hidefunc(){ cout << "HideB function" << endl; } void usehidefunc(){ //隐藏基类函数hidefunc,使⽤外部函数时要加作⽤域 hidefunc(); HideA::hidefunc(); }};隐藏的实质是;在函数查找时,名字查找先于类型检查。

C 的高级特性---函数重载,重写,覆盖

C  的高级特性---函数重载,重写,覆盖
示例8-1-1 重载函数Eat
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)覆盖。

c++类重载函数

c++类重载函数

c++类重载函数一、概述C类重载函数是一种在C++类中定义多个同名的函数,每个函数具有不同的参数列表。

这种技术允许我们在同一类中为同一个操作定义多个行为,从而提高了代码的可读性和可维护性。

C类重载函数通常用于实现类的不同行为,或者根据不同的参数组合执行不同的操作。

二、重载函数的规则在C++中,函数可以通过两种方式进行重载:参数的数量或类型不同。

以下是一些重载函数的基本规则:1. 参数的数量:如果两个函数有不同数量的参数,那么它们可以被视为不同的函数。

例如,下面的代码将有两个不同的max()函数:```cppclass MyClass {public:int max(int a, int b) { ... }double max(double a) { ... } // 重载函数,因为参数类型不同};```2. 参数的类型:如果两个函数的参数类型不同,那么它们也可以被视为不同的函数。

例如,下面的代码将有两个不同的max()函数:```cppclass MyClass {public:int max(int a, int b) { ... } // int类型参数double max(double a, double b) { ... } // double类型参数};```注意:如果两个函数的参数类型不同,且参数数量也不同,那么编译器将无法确定应该调用哪个函数,这可能导致编译错误。

三、使用重载函数重载函数的调用规则与普通函数的调用规则相同。

你可以通过直接调用函数名来调用它们,或者使用“->”运算符通过对象调用它们。

请注意,使用直接调用的方式可能更为方便,特别是在小型和简单的程序中。

在大型和复杂的程序中,建议使用对象调用方式,因为它更符合面向对象的设计原则。

四、注意事项在使用C类重载函数时,有一些注意事项需要牢记:1. 确保你的类是公有或保护的,以便外部代码可以访问和使用这些重载函数。

默认的访问控制属性(即私有)将阻止外部代码访问这些函数。

c++教程类与对象-自定义类中的运算符

c++教程类与对象-自定义类中的运算符
运算符重载也是函数名重载的一种特殊情况,即将运算符看成是一种特殊的函数,但其实现和使用与函数重载的实现和使用有一定的差别.
下面详细介绍运算符重载的基本方法.
7. 8.1.1基本概念和方法
1.运算符重载概念
重载运算符时,可以将该运算符看成是函数名(不是真正的函数名,因为它不符合标识符的要求),然后在相应的类中定义一个与该运算符同名的函数,并告诉编译器,当遇到该重载运算符的调用时,由这个函数来完成该运算符应该完成的操作.这种函数称为运算符重载函数.它通常是类的成员函数或者友元函数..
{……} //函数体
其中:
1)<类型>:为该函数的返回的类型,可以是用户自定义类型或基本数据类型,也可以是
任一导出数据类型.
2)operator:是关键字,它与其后的运算符一起构成函数名.
3)@:为要重载的运算符;
4)<参数表>:为函数的形参表
①当使用类的公有成员函数重载运算符时
总以当前调用者对象(*this)作为该成员函数的隐式第一运算分量,若所定义的运算多于一个运算对象时,才将其余运算对象显式地列在该成员函数的参数表中.
{- - - } //函数体
其中
①运算符重载函数为类X的友元.
②前置和后置的区别为:
后置运算符重载函数比前置运算符重载函数多了一个整数参数.该参数没什么特别的意义,只是标识重载的是后置运算符.
③当用友元函数重载时,X类型的参数必须为指针类型或引用类型.
7. 8.1.2运算符重载示例
1)二目运算符重载
②当使用类的友元函数重载运算符时
所有运算分量必须显式地列在本友元函数的参数表中,而且这些参数类型中至少要有一个应该是说明该友元的类类型或是对该类的引用.

C++运算符重载三种形式(成员函数,友元函数,普通函数)详解

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::只是指定了成员函数所属类名。

【习题】类与对象(2)

【习题】类与对象(2)

类和对象(2)【实验目的】:1.掌握类的构造函数和析构函数的使用方法。

2.掌握类的拷贝构造函数的使用方法。

【实验内容】:1.读以下程序,为下列程序添加注释,并给出程序运行结果。

并解释为什么得到这样的结果。

上机验证你的结果是否正确。

2.完成下列要求。

1)读以下程序,为下列程序添加注释,并给出程序运行结果。

并解释为什么得到这样的结果。

上机验证你的结果是否正确。

2)将Coordinate类中带有两个参数的构造函数进行修改,在函数体内添加下述语句:cout << “Constructor is called.\n“;写出程序的运行结果,并解释输出的结果。

3)按下列要求进行调试:在主函数体内,添加下述语句:Coordinate p4;Coordinate p5(2);调试程序时会出现什么错误?为什么?如何对已有的构造函数进行适当的修改?4)经过以上2)和3)步的修改后,结合运行结果分析:创建不同的对象时会调用不同的构造函数。

3.假使在程序中已经声明了类point,并建立了其对象p1和p4。

请回答一下几个语句有什么区别?1)point p2, p3;建立point类的p2和p32)point p2 = p1;拷贝p2为p13)point p2(p1);同上4)point p2;建立point类的p2p2 = p1;将p1赋给p25)p4 = p1;将p1赋给p44.定义一个矩形(Rectangle)类,私有数据成员为矩形的长度(len)和宽度(wid),构造函数置len和wid为0,有参构造函数置len和wid为对应形参的值,有能够放大长度和宽度一倍的拷贝构造函数,还包括求矩形周长、求矩形面积、矩形长度和宽度的共有成员函数,另外还有一个能够输出矩形长度、宽度、周长和面积等公有成员函数。

5.编写一个程序,实现按输入字符串相反的顺序,输出字符串。

如输入字符串:Merry Christmas and Happy New Year则输出字符串:Year New Happy and Christmas Merry6.编写一个程序,设计一个满足如下要求的CDate类,用数据进行调试,并输出结果:1)用日/月/年格式输出日期。

c++中的函数重载、函数重写、函数重定义

c++中的函数重载、函数重写、函数重定义

c++中的函数重载、函数重写、函数重定义⽬录为了更加深刻的理解函数重载、重写、重定义,我们可以带着如下这两个问题去思考:1、⼦类中是否可以定义⽗类中的同名成员?为什么? 可以,因为⼦类与⽗类的命名空间不同;2、⼦类中定义的函数是否可以重载⽗类中的同名函数? 不可以,因为函数重载必须在同⼀个作⽤域中。

⼀、函数重载(Function Overloading) 1、什么是函数重载 在同⼀个类中(同⼀个作⽤域中/在类的内部),存在⼀组函数名相同,函数的参数列表不同(参数的个数、类型、顺序),函数有⽆ virtual 关键字都可以,我们把这组函数称为函数重载。

2、为什么使⽤函数重载(函数重载的好处) 由于函数重载可以在同⼀个作⽤域内,使⽤同⼀个函数名命名⼀组功能相似的函数,这样做减少了函数名的数量,避免了程序员因给函数名命名所带来的烦恼,从⽽提⾼程序的开发的效率。

3、函数重载的条件 1. 必须在同⼀作⽤域下 2. 函数名相同但是参数列表不同(参数列表的类型 or 个数 or 顺序不同) 3. 返回值的类型不会影响重载 4. const属性相同4、函数重载的原理(本质:c++编译器对同名函数进⾏重命名) 编译器在编译.cpp⽂件中当前使⽤的作⽤域⾥的同名函数时,根据函数形参的类型和顺序会对函数进⾏重命名(不同的编译器在编译时对函数的重命名标准不⼀样); 但是总的来说,他们都把⽂件中的同⼀个函数名进⾏了重命名;在vs编译器中: 根据返回值类型(不起决定性作⽤)+形参类型和顺序(起决定性作⽤)的规则重命名并记录在map⽂件中。

在linux g++ 编译器中: 根据函数名字的字符数+形参类型和顺序的规则重命名记录在符号表中;从⽽产⽣不同的函数名,当外⾯的函数被调⽤时,便是根据这个记录的结果去寻找符合要求的函数名,进⾏调⽤; 为什么c语⾔不能实现函数重载? 编译器在编译.c⽂件时,只会给函数进⾏简单的重命名; 具体的⽅法是给函数名之前加上”_”;所以加⼊两个函数名相同的函数在编译之后的函数名也照样相同;调⽤者会因为不知道到底调⽤那个⽽出错;1 #include<stdio.h>23int Add(int a, int b)4 {5return a + b;6 }789float Add(float a, float b)10 {11return a + b;12 }1314void testFunc()15 {16 Add(10, 20);17 Add(20.0f, 30.0f);18 }1920int main(int argc, char *argv[])21 {22 testFunc();2325 }案例分析1. 将上述代码保存到.c⽂件中 若上述代码⽤c编译器编译,由于c语⾔中⽆函数重载,所以,在程序运⾏时出错。

《C++程序设计》电子教案第7章 运算符重载

《C++程序设计》电子教案第7章  运算符重载
第7章 运算符重载 章
7.1 7.2 7.3 7.4 7.5 运算符重载概述 运算符重载的实现 一元运算符重载 二元运算符重载 特殊运算符重载
7.1 运算符重载概述
运算符重载是对已有的运算符赋予多重含义, 运算符重载是对已有的运算符赋予多重含义, 同一个运算符作用于不同类型的数据导致不同 类型的行为。 类型的行为。 运算符重载的实质就是函数重载。 运算符重载的实质就是函数重载。在实现过程 中,首先把指定的运算表达式转化为对运算符 函数的调用, 函数的调用,运算对象转化为运算符函数的实 参,然后根据实参的类型来确定需要调用的函 这个过程是在编译过程中完成的。 数,这个过程是在编译过程中完成的。
返回首页
算符有前缀和后缀两 如同 “ ++ ” 运 算符有前缀和 后缀两 种 使用形式 一样 , 运算符有前缀和后缀两 种使用形式 “++”和“--”重载运算符也有前缀和后缀两种运算符 ” ” 重载形式, 重载形式 , 以 “ ++” 重载运算符为例 , 其语法格式如 ” 重载运算符为例, 下: <函数类型 operator ++(); 函数类型> ( //前缀运算 前缀运算 函数类型 <函数类型 operator ++(int); //后缀运算 函数类型> 函数类型 ( ) 后缀运算 使用前缀运算符的语法格式如下: 使用前缀运算符的语法格式如下: ++<对象 对象>; 对象 使用后缀运算符的语法格式如下: 使用后缀运算符的语法格式如下: <对象 对象>++; 对象
static char* str; String String::operator+(const String& a) { strcpy(str,name); strcat(str,); return String(str); } void main() { str=new char[256]; String demo1("Visual c++"); String demo2("6.0"); demo1.display(); demo2.display();

C++实验3成员函数的重载

C++实验3成员函数的重载

实验3 成员函数的重载1.实验目的及要求:1)掌握普通函数重载的方法;2)掌握成员函数重载的方法;2.实验内容:2.1分析下面的程序,指出程序运行的结果:class ListClass{int *List ;unsigned nMax ;unsigned nElem ;public:void Init (int n=10){List=new int [n] ;nMax=n ;nElem=0 ;}int Elem(int);int &Elem(unsigned n){return List [n] ;}unsigned Elem(void) {return nElem ;}unsigned Max (void){return nMax ;}void Print (void) ;int GetElem(int i){if((i>=0)&&(i<=nElem))return List [i] ;else return 0;}void Destroy (void) {delete [nMax]List ;}};int ListClass ::Elem(int elem){if(nElem<nMax){List[nElem++]=elem;return nElem ;}else{int*list ;list=new int [nMax+1];for(int i=0 ; i<nElem ; i++) list [i]=List[i] ;delete [nMax]List ;nMax++ ;List=list;List[nElem++]=elem ;return nElem ;}}void ListClass ::Print(void){for(int i=0 ;i<nElem ; i++) cout <<List[i]<<'\t';cout<<'\n';}void main (void ){ ListClass list ,list1;list.Init(10);list1.Init(20);for (int i=0 ; i<10 ; i++)list1.Elem(i) ;cout<<"线性表list的元素的个数为:"<<list.Elem()<<'\n' ;cout<<"线性表list长度为:"<<list.Max()<<'\n' ;cout<<"线性表list1的元素的个数为::"<<list1.Elem()<<'\n' ;cout<<"线性表list1长度为:"<<list1.Max()<<'\n';list1.Print();list1.Elem(3u)=100 ;cout<<"现在线性表list1中的第三个值为:"<<list1.Elem(3u)<<'\n' ;list1.Elem(20);list1.Elem (200);cout<<"现在线性表list1中元素的个数为:"<<list1.Elem()<<'\n' ;list1.Print();cout<<"现在线性表list1中的最后一个元素为:"<<list1.GetElem(list1.Elem()-1)<<'\n' ;list.Destroy();list1.Destroy();}程序执行过程如下:程序运行情况和结果如下:3.2 编写并调试程序:1) 使用函数重载的方法定义两个重名函数,分别求出整型数的两点间距离和实型数的两点间距离。

c 函数重载原理

c  函数重载原理

c 函数重载原理
函数重载是指在同一个作用域中,可以定义多个同名函数,但它们的参数类型、数量或顺序必须不同。

通过函数重载,可以根据不同的参数来调用不同的函数。

实现函数重载的原理是函数的参数和返回值不是函数的唯一标识,而是函数的签名。

函数的签名由函数的名称、参数的类型、参数的数量和参数的顺序组成。

当调用一个函数时,编译器会根据参数的签名匹配最合适的函数进行调用。

在编译阶段,编译器会根据函数调用的参数类型和数量来确定函数的重载版本。

如果有多个函数的参数类型或数量符合调用时的参数,则编译器会选择最匹配的函数进行调用。

如果找不到合适的重载函数,则会报错。

函数重载的优势在于提高了代码的可读性和灵活性。

通过使用同名函数进行重载,可以将功能相似的函数统一命名,使代码更加清晰易懂。

同时,函数重载也可以根据不同的参数类型来执行不同的操作,提供更多的选择和灵活性。

总之,函数重载是通过函数的参数类型、数量和顺序来区分同名函数,从而实现不同的功能。

这种机制提高了代码的可读性和灵活性,使函数的调用更加方便和简洁。

第七章 函数的重载

第七章 函数的重载

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对象 对 }
函数重载: 函数重载:这个方法允许为两个或更多函数使用同样 的名字。 的名字。函数的每个重新定义必须使用不同的参数类 参数顺序或多个参数。 型、参数顺序或多个参数。 操作符重载: 操作符重载:这个方法允许用户定义的类型例如结构 和类,为使它们的对象易于操作而使用重载操作符。 和类,为使它们的对象易于操作而使用重载操作符。

第7章 类与对象

第7章 类与对象
休息 7
抽象实例——人
OOP
数据抽象:
的 基 本 特 点
char *name,char *sex,int age,int id
代码抽象:
生物属性角度: GetCloth(), Eat(), Step(),… 社会属性角度: Work(), Study() ,…
休息 8
前一页
封装
OOP 的 基 本 特 点
inline int Point::GetY() { return Y; }
对象
类 和 对 象

类的对象是该类的某一特定实体,即 类类型的变量。
声明形式: 类名
例:
对象名;

Clock myClock;
前一页
休息
29
类中成员的访问方式
类 和 对 象

类中成员互访
– 直接使用成员名

类外访问
– 使用“对象名.成员名”方式访问 public 属性的成员
为了提高运行时的效率,对于较简单的函 数可以声明为内联形式。
函 数 成 员 的 定 义
定义方式二:
将成员函数定义为内联成员函数。 两种格式: (1)显式定义:在类外定义,用inline关键 字. (2)隐式定义:直接将函数体的定义放在类 的声明内。

休息 23
前一页
显 式 定 义 内 联 函 数 成 员
Eg: 课本P195-196
inline void Clock :: SetTime(int NewH, int
NewM,int NewS) { } Hour=NewH; Second=NewS; Minute=NewM;
Inline void Clock :: ShowTime()

C++第7章 运算符重载

C++第7章 运算符重载

西北民族大学计算机科学与信息工程学院
complex operator +(complex a,complex b) { complex temp; temp.real=a.real+b.real; temp.imag=a.imag+b.imag; return temp; } complex operator-(complex a,complex b) { complex temp; temp.real=a.real-b.real; temp.imag=a.imag-b.imag; return temp; } complex operator*(complex a,complex b) { complex temp; temp.real=a.real*b.real-a.imag*b.imag; temp.imag=a.real*b.imag+a.imag*b.real; return temp; }
西北民族大学计算机科学与信息工程学院
7.1运算符重载概述
7.1.1 运算符重载的好处
int sum_i; float sum_f; int i1=123, i2=456; float f1=3.45, f2=56.78; sum_i= i1+i2; cout<<"i1+i2 ="<< sum_i; sum_f= f1+f2; cout<<"f1+f2 ="<< sum_f; sum_f= i1+i2+f1; cout<<"i1+i2+f1 ="<<sum_f; i1+i2 =579 f1+f2 =60.23 i1+i2+f1 =582.45 Press any key to continue

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

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++学习笔记(⼋):函数重载、函数指针和函数对象函数重载函数重载是指在同⼀作⽤域内,可以有⼀组具有相同函数名,不同参数列表的函数,这组函数被称为重载函数。

重载函数通常⽤来命名⼀组功能相似的函数,这样做减少了函数名的数量,避免了名字空间的污染,对于程序的可读性有很⼤的好处。

1. 试想如果没有函数重载机制,如在C中,你必须要这样去做:为这个print函数取不同的名字,如print_int、print_string。

这⾥还只是两个的情况,如果是很多个的话,就需要为实现同⼀个功能的函数取很多个名字,如加⼊打印long型、char*、各种类型的数组等等。

这样做很不友好!2. 类的构造函数跟类名相同,也就是说:构造函数都同名。

如果没有函数重载机制,要想实例化不同的对象,那是相当的⿇烦!3. 操作符重载,本质上就是函数重载,它⼤⼤丰富了已有操作符的含义,⽅便使⽤,如+可⽤于连接字符串等!两个重载函数必须在下列⼀个或两个⽅⾯有所区别:1. 函数有不同参数。

2. 函数有不同参数类型。

返回值不作为判断两个函数区别的标志。

C++运算符重载的相关规定如下:1. 不能改变运算符的优先级;2. 不能改变运算符的结合型;3. 默认参数不能和重载的运算符⼀起使⽤;4. 不能改变运算符的操作数的个数;5. 不能创建新的运算符,只有已有运算符可以被重载;6. 运算符作⽤于C++内部提供的数据类型时,原来含义保持不变。

总结⽰例:(1)普通函数(⾮类成员函数)形参完全相同,返回值不同,如:1void print();2int print(); //不算重载,直接报错(2)普通函数形参为⾮引⽤类型,⾮指针类型,形参⼀个带const,⼀个不带const1void print(int x);2void print(const int x); //不算重载,直接报错重定义(3)普通函数形参为引⽤类型或指针类型,⼀个形参带const,⼀个不带const1void print(int *x);2void print(const int *x); //算重载,执⾏正确,实参为const int *时候调⽤这个,为int* 的时候调⽤上⾯⼀个34void print(int &x);5void print(const int &x); //算重载,执⾏正确,实参为const int &时候调⽤这个,为int& 的时候调⽤上⾯⼀个(4)类的成员函数,形参完全相同,⼀个函数为const成员函数,⼀个函数为普通成员函数1void print();2void print() const; //算重载。

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

第7章类与对象
7.1 类和对象
7.2成员函数的重载
1.成员函数重载的原则与普通函数重载的原则相同,即重载函数之间靠所包含的参数的类型或个数之间的差异进行区分。

2.成员函数的重载只是针对同一个类中的成员函数,对于不同类中的成员函数之间以及成员函数与不属于任何类的普通函数之间则不存在重载关系。

因为它们属于不同的作用域,因此它们不仅函数名可以相同,而且它们的参数也可以完全一样。

例7.2.1成员函数的重载:处理一个数组构成的线性表,动态产生线性表,并输出线性表中的数据
#include<iostream.h>
class ListClass
{ int *List ;//指向线性表的指针
unsigned nMax ;//线性表中最大长度
unsigned nElem ;//表中当前元素的个数
public:
void Init (int n=10) //初始化线性表,最大长度的默认值为10
{ List=new int [n] ;//动态分配存储空间
nMax=n ;
nElem=0 ;//表中当前元素的个数为0
}
int Elem(int) ;
int &Elem(unsigned n){return List [n] ;} //返回线性表中第n个元素的引用
unsigned Elem(void) {return nElem ;} //获取当前元素的个数
unsigned Max (void){return nMax ;} //获取线性表的长度
void Print (void) ;
int GetElem(int i) //获取线性表中第i个元素的值
{
if((i>=0)&&(i<=nElem))return List [i] ;
else return 0;
}
void Destroy (void) {delete [nMax]List ;} //释放线性表占用的存储空间};
int ListClass ::Elem(int elem) //在线性表的末尾增加一个元素,返回当前元素的个数{
if(nElem<nMax){ //线性表未满,向末尾加一个元素
List[nElem++]=elem;
return nElem ;
}
else{ //线性表已满,重新申请一个新的线性表int*list ;
list=new int [nMax+1];
for(int i=0 :i<nElem ; i++) list [i]=List[i] ;//将线性表的数据保存在list中
delete [nMax]List ;//将原来的线性表所占用的空间释放
nMax++ ;//将线性表的最大长度加1
List=list ;
List[nElem++]=elem ;
return nElem ;
}
}
void ListClass ::Print(void) //输出线性表的所有元素
{
for(int i=0 :i<nElem ;i++) cout <<List[i]<<'\t' ;
cout<<'\n' ;
}
void main (void )
{ ListClass list ,list1;
list.Init(10) ;
list1.Init(20) ;
for (int i=0 ;i<10 ;i++)
list1.Elem(i) ;
cout<<"线性表list的元素的个数为:"<<list.Elem( )<<'\n' ;
cout<<"线性表list长度为:"<<list.Max()<<'\n' ;
cout<<"线性表list1的元素的个数为:"<<list1.Elem()<<'\n' ;
cout<<"线性表list1长度为:"<<list1.Max()<<'\n' ;
list1.Print() ;
list1.Elem(3u)=100 ;
cout<<"现在线性表list1中的第三个值为;"<<list1.Elem(3u)<<'\n' ;
list1.Elem(20) ;
list1.Elem (200) ;
cout<<"现在线性表list1中元素的个数为:"<<list1.Elem()<<'\n' ;
list1.Print() ;
cout<<"现在线性表list1中的最后一个元素为:"<<list1.GetElem(list1.Elem()-1)<<'\n' ;
list.Destroy();
list1.Destroy();
}
运行结果:
线性表list的元素的个数为:0
线性表list长度为:10
线性表list1的元素的个数为: 10
线性表list1长度为:20
0 1 2 3 4 5 6 7 8 9
现在线性表list1中的第三个值为:100
现在线性表list1中元素的个数为:12
0 1 2 100 4 5 6 7 8 9 20 200
现在线性表list1中的最后一个元素为:200
例7.2.2 成员函数与非成员函数之间的函数名可以相同
# include <iostream.h>
class CAdd
{
public:
int Add (int a ,int b) //A
{return a+b ;}
double Add(double x ,double y) //B
{return x+y ;}
};
int Add (int a , int b)
{ return a - b ;} //C
return a+b ;
void main ()
{ CAdd c;
cout<<"5+3="<<c.Add(5 ,3)<<endl;//调用A行定义的函数cout<<"3.5+6.1="<<c.Add(3.5,6.1)<<endl ;//调用B行定义的函数
cout<<"5+10="<<Add(5,10)<<endl ;//调用C行定义的函数cout<<"10 - 5="<<Add(10,5)<<endl ;
}
运行结果:
5+3=8
3.5+6.1=9.6
5+10=15
10 – 5 = 5。

相关文档
最新文档