C++教程第07章 类与对象-2成员函数的重载
面向对象的程序设计语言――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++类成员函数的重写、重载和隐藏重载(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++语言采用重载机制的另一个理由是:类的构造函数需要重载机制。因为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++中,函数可以通过两种方式进行重载:参数的数量或类型不同。
以下是一些重载函数的基本规则: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++教程类与对象-自定义类中的运算符

下面详细介绍运算符重载的基本方法.
7. 8.1.1基本概念和方法
1.运算符重载概念
重载运算符时,可以将该运算符看成是函数名(不是真正的函数名,因为它不符合标识符的要求),然后在相应的类中定义一个与该运算符同名的函数,并告诉编译器,当遇到该重载运算符的调用时,由这个函数来完成该运算符应该完成的操作.这种函数称为运算符重载函数.它通常是类的成员函数或者友元函数..
{……} //函数体
其中:
1)<类型>:为该函数的返回的类型,可以是用户自定义类型或基本数据类型,也可以是
任一导出数据类型.
2)operator:是关键字,它与其后的运算符一起构成函数名.
3)@:为要重载的运算符;
4)<参数表>:为函数的形参表
①当使用类的公有成员函数重载运算符时
总以当前调用者对象(*this)作为该成员函数的隐式第一运算分量,若所定义的运算多于一个运算对象时,才将其余运算对象显式地列在该成员函数的参数表中.
{- - - } //函数体
其中
①运算符重载函数为类X的友元.
②前置和后置的区别为:
后置运算符重载函数比前置运算符重载函数多了一个整数参数.该参数没什么特别的意义,只是标识重载的是后置运算符.
③当用友元函数重载时,X类型的参数必须为指针类型或引用类型.
7. 8.1.2运算符重载示例
1)二目运算符重载
②当使用类的友元函数重载运算符时
所有运算分量必须显式地列在本友元函数的参数表中,而且这些参数类型中至少要有一个应该是说明该友元的类类型或是对该类的引用.
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)【实验目的】: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++中的函数重载、函数重写、函数重定义⽬录为了更加深刻的理解函数重载、重写、重定义,我们可以带着如下这两个问题去思考: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章 运算符重载
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();
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 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。