C++知识点总结及习题

一、C++入门与基本数据类型

1.C++中，一个函数必须在函数声明后才能使用（被调用）。
2.C++函数声明总是由函数原型构成。
3.参数声明时，要指出其类型。
4.函数定义中的参数称为形式参数，简称形参。
5.调用函数时实际传递的值称为实际参数，简称实参。
6.在大多数计算机上，short int 表示2个字节长。short 只能修饰int，short int 可以省略为short。
7.long 只能修饰 int 和 double 。修饰为 long int（可以省略为long）时，一般表示4个字节，修饰 long double 时，一般表示10个字节。
8.unsigned 和 signed 只能修饰 char 和 int。一般情况下，默认的 char 和 int 为signed。实型数 float 和 double 总是有符号的，不能用 unsigned 修饰。
9.用 typeof(数据类型) 可以确定某数据类型的字节长度。
10.命名变量名的规则：
（1）不能是C++关键字。
（2）第一个字符必须是字母或下划线。
（3）不要超过31个字符。
（4）中间不能有空格。
（5）不能包含“ . ; , " ’ + - ” 之类的特殊符号。变量名中除了能使用26个英文大小写字母和数字外，只能使用下划线“ _ ”。
（6）变量名不要与C++中的库函数名、类名和对象名相同。

11.八进制以0开头，十六进制以0x开头。
12.十进制数有正负之分，八进制和十六进制数只能表示无符号整数。
13.指数形式：E或e的前面必须要有数字，且E后面的指数必须为整数。
14.字符是用单引号括起来的一个字符。’ \ddd ’ 表示1 ~ 3位八进制数， ’ \xhh ’ 表示1 ~ 2位十六进制数。
例：“\x07operating\tsystem\n” 中有18个字符。
15.C++中，字符串总是以’\0’结束。
16.“0” 与 ‘0’ 是不同的。
17.printf(“%-5.3s”,“Hello”);负号表示左对齐，5表示格式宽度，3表示截取字符串中3个字符。

二、表达式和语法

1.操作符优先级：算术运算符>关系运算符>逻辑运算符>赋值运算符
2./ 对于整型数是取整，对于浮点数是通常意义的除法。
3.% 只能对整型数进行操作，意义为取余。
4.算术类型转换总是朝表达数据能力更强的方向，并且转换总是逐个运算符进行的。
5.数据运算过程中自动进行的类型转换称为隐式类型转换。
6.强制转换又称显示转换，其语法是在一个数值或变量前加上带括号的类型名。也可以类型名后跟带括号的数值或表达式。如果类型名是带类型修饰的，则要给类型名加括号。
7.条件运算符（条件表达式）？（条件为真时的表达式）：（条件为假时的表达式）。条件运算符可以嵌套。
8.if ( !n ) 等价于 if ( n == 0 )和if ( n ) 等价于 if ( n != 0 )
9.do-while循环中，while（继续条件）后面的分号不要忘记。
10.for语句的三个表达式都可省略，且表达式1，2，3都可以为任何表达式。
11.switch后面括号中的表达式只能是整型、字符型或枚举类型表达式。case后面的常量表达式类型必须与其匹配。
12.因为case语句起语句标号的作用，所以case与default并不改变控制流程。case常与break语句联用，以保证多路分支的正确实现。最后一个分支可以省略break语句。
各个case（包括default）的出现次序可以任意。在每个case分支都带有break的情况下，case次序不影响执行结果。
13.default语句是可选的。当default不出现时，则当表达式的值与所有常量表达式的值都不相等时，越过switch语句。
14.switch语句可以嵌套。
15.continue语句和break语句的区别是：continue语句只结束本次循环，而不是终止整个循环的执行；而break语句则是终止整个循环，不再进行条件判断。

三、函数

1.C++不允许函数定义嵌套，即在函数定义中再定义一个函数是非法。
2.一个程序将操作系统分配给其运行的内存块分为4个区域：代码区、全局数据区、堆区、栈区。
3.函数结束时，静态局部变量不会消失，每次该函数调用时，也不会为其重新分配空间。它始终驻留在全局数据区，直到程序运行结束。静态局部变量的初始化与全局变量类似，如果不为其显式初始化，则C++自动为其初始化为0。
4.内联函数也称内嵌函数，主要解决程序的运行效率。
5.重载函数至少在参数个数、参数类型或参数顺序上有所不同。
6.typedef定义的类型只能使之相同于一个已存在的类型，而不能建立新的类型，所以不能用typedef定义的类型名来区分重载函数声明中的参数。
7.默认参数在函数声明中提供，当又有声明又有定义时，定义中不允许默认参数。如果函数只有定义，则默认参数才可出现在函数定义中。
8.默认值可以是全局变量、全局常量，甚至是一个函数。但默认值不可以是局部变量，因为默认参数的函数调用是在编译时确定的，而局部变量的位置与值在编译时均无法确定。
9.内联函数是为了提高编程效率而实现的，它克服了用#define宏定义说带来的弊病。
10.goto和switch语句不应使控制从一个声明的作用域跳到该声明的作用域内，因为这种跳转越过了变量的声明语句，使变量不能被初始化。
11.全局变量、静态全局变量、静态局部变量都具有静态生命期。具有文件作用域的变量具有静态生命期。静态生命期的变量，若无显示初始化，则自动初始化为0。
12.在函数内部声明的变量或是块中声明的变量具有局部生命期。具有局部作用域的变量若为局部变量，则具有局部生命期，若为静态局部变量，则有静态生命期。具有局部生命期的变量驻在内存的栈区。具有局部生命期的变量若未初始化，则内容不可知。
14.三类编译预处理指令：#include，#define，#if。
#include包含指令：让预处理器把一个源文件嵌入到当前文件中该点处。
#define宏定义指令：建立常量，定义带参数的宏，还有一个有效的使用是在条件编译指令中。
15.条件编译指令有：#if，#else，#elif，#endif，#ifdef，#ifndef，#undef。
条件编译的一个有效使用时协调多个头文件。使用#undef可以取消符号定义，这样可以根据需要打开和关闭符号。

四、数组与指针

1.初始化数组的值的个数不能多于数组元素个数，初始化数组的值也不能通过跳过逗号的方式来省略。
2.初始化值的个数可少于数组元素个数。当初始化值的个数少于数组元素个数时，前面的按序初始化相应值，后面的初始化为0。
3.对于字符串的初始化，要注意数组实际分配的空间大小事字符串个数加上末尾的’\0’结束符。
4.数组的大小为n，而字符串的长度为n-1
5.在定义时，也可以只对部分元素赋初始值而省略第一维的大小，但应分行赋初始值。
函数调用时，数组参数的实参为整型变量的地址；函数原型中，数组参数的形参为整型数组的首地址。
6.有一种从数组尾部跳到其头部的技巧是“加1求模”。
7.用&操作可以获取变量的地址，指针变量用于存放地址。
8.放在可执行语句中的指针之前，称为间接引用操作符，而其放在指针定义中时，称指针定义符。
9.非指针变量是不能用间接引用操作符的，因为只能作用于地址。
间接引用既可以用于右值，也可以用于左值。
指针变量初始化的值是该指针类型的地址值。
指针在使用前，要进行初始化。指针忘赋值比整形变量忘了赋值要危险的多。
指针iPtr++不是后移一位，而是后移了一个单位。
只有加法和减法可用于指针运算。
10.a[i] 等价于 * (a+i) 等价于 iPtr[i] 等价于 * (iPtr+i)
&a[i] 等价于 a+i 等价于 iPtr+i 等价于 &iPtr[i]
11.数组名本身是一指针，它的类型是指向数组元素的指针。
12.数组名是指针常量，区别于指针变量。所以给数组名赋值是错误的。
13.常量指针（指向常量的指针）：在指针定义语句的类型前加const，表示指向的对象是常量。定义指向常量的指针只限制指针的间接访问操作，而不能规定指针指向的值本身的操作规定性。const int * pi = &a；不能通过pi来修改a的值，但可以把pi指向另外一个变量。
14.指针常量：在指针定义语句的指针名前加const，表示指针本身是常量。在定义指针常量时必须初始化。char * const pc = “asdf”；可以通过 * pc来修改其内容，但不能改变指针值即指向另外一个变量。
15.常量指针常量（指向常量的指针常量）：const int * const cpc = &b；其中cpc和 * cpc都是常量，不能作为左值进行操作。
16.指针数组：一个数组中每个元素都是一个指针。char * proname[] = { “Fortran”, “C”, “C++” }；
17.指针数组与二维数组是有区别的。字符指针数组的内存表示，指针所指向的字符串是不规则长度的。二维数组每一列的大小必须是一样的。
指针数组名是指向指针的指针（即二级指针）。
18.传递数组给函数就是传递指针给函数。传递指针数组给函数就是传递二级指针给函数。

五、类、构造函数、静态成员与友元

1.C++特点：抽象、封装、继承、多态。
2.::叫作用域区分符，指明一个函数属于哪个类或一个数据属于哪个类。::可以不跟类名，表示全局数据或全局函数（即非成员函数）。
3.不能对类的数据成员进行初始化。
4.由于类名是成员函数名的一部分，所以一个类的成员函数与另一个类的成员函数即使同名，也不能认为是重载。
5.成员函数必须用对象来调用。
6.一个类对象所占据的内存空间由它的数据成员所占据的空间总和说决定。类的成员函数不占据对象的内存空间。
7.类的作用域是指类定义和相应的成员函数定义范围。
8.如果一个非类型名隐藏了类型名，则类型名通过加前缀可用。如果一个类型名隐藏了一个非类型名，则用一般作用域规则即可。
9.C++规定，一个名字不能同时指两种类型。非类型名（变量名、常量名、函数名、对象名或枚举成员）不能重名。
10.C++规定与类同名的成员函数是构造函数，在该类的对象创建时，自动被调用。
11.构造函数没有返回类型，函数体中也不允许返回值，但可以有无值返回语句“return；”。
12.一个类定义中，类的数据成员可能为另一个类的对象。
13.如果一个类对象是另一个类的数据成员，则在那个类的创建所调用的构造函数中，对该成员（对象）自动调用其构造函数。
14.析构函数没有返回类型，没有参数，没有重载。只是在类对象生命期结束的时候，由系统自动调用。
15.析构函数以调用构造函数相反的顺序被调用。
16.无参的构造函数被称为默认构造函数。
17.C++规定，每个类必须有一个构造函数，没有构造函数，就不能创建任何对象。
18.若未提供一个类的构造函数（一个都未提供），则C++提供一个默认的构造函数，该默认构造函数是个无参构造函数，它负责创建对象，而不做任何初始化工作。
19.只要一个类定义了一个构造函数（不一定是无参构造函数），C++就不再提供默认的构造函数。即如果为类定义了一个带参数的构造函数，还想要无参构造函数，则需要自己定义。
20.静态对象和静态变量一样，文件作用域的静态对象在主函数开始运行前全部构造完毕。块作用域中的静态对象，则在首次进入到定义该静态对象的函数时，进行构造。
21.全局变量、静态数据、常量存放在全局数据区，所有类成员函数和非成员函数代码存放在代码区，为运行函数而分配的局部变量、函数参数、返回数据、返回地址等存放在栈区，余下的空间都被作为堆区。
22.从堆上分配对象数组，只能调用默认的构造函数，不能调用其它任何构造函数。如果该类没有默认构造函数，则不能分配对象数组。
23.如果你的类需要析构函数来析构资源，则它也需要一个拷贝构造函数。
可以直接调用构造函数产生无名对象。无名对象可以作为实参传递给函数，可以拿来拷贝构造一个新对象，也可以初始化一个引用的声明。
24.转换构造函数是定义含一个参数的构造函数。
25.运算符new分配堆内存，如果成功，则返回该内存的空间，如果失败，则返回NULL。所以每次使用运算符new动态分配内存时，都应测试new的返回指针值，以防分配失败。pName = new char[ strlen(pN) + 1 ]；if ( pName != 0 ) strcpy( pName, pN )；
26.声明为static的类成员便能在类范围中共存，称之为静态成员。
27.静态数据成员在类声明外分配空间和初始化。
28.公共静态数据成员可被类的外部访问，保护或私有静态数据成员只可被类的内部访问。
29.静态成员函数定义是类的内部实现，属于类定义的一部分。它的定义位置与一般成员函数一样。
30.一个静态成员函数不与任何对象相联系，故不能对非静态成员进行默认访问。
31.静态成员函数与非静态成员函数的根本区别：静态成员函数没有this指针，而非静态成员函数有一个指向当前对象的指针this。
32.在类里申明一个普通函数，标上关键字friend，就成了该类的友元，可以访问该类的一切成员。
33.友元声明的位置可在类的任何部位，既可以在public区，也可以在protected区，意义完全一样。友元函数定义则在类的外部，一般与类的成员函数定义放在一起。
34.一个类的成员函数可以是另一个类的友元。
35.整个类可以是另一个类的友元，该友元称为友类。友类的每个成员函数都可以访问另一个类中的保护或私有数据成员。
36.静态成员的static一词与静态存储类的static是两个概念，一个论及类，一个论及内存空间的位置以及作用域限定。所以要区分静态对象和静态成员。

六、多重继承与运算符重载

1.虚拟继承的虚拟和虚拟函数的虚拟没有任何关系。
2.多继承的构造顺序：一，任何虚拟基类的构造函数按照它们被继承的顺序构造。二，任何非虚拟基类的构造函数按照它们被继承的顺序构造。三，任何成员对象的构造函数按照它们声明的顺序调用。四，类自己的构造函数。
3.在继承关系中，基类的private成员不但对应用程序隐藏，甚至对派生类也隐藏。而基类的保护成员则只对应用程序隐藏，而对派生类则毫不隐瞒。
4.一个私有的或保护的派生类不是子类，因为非公共的派生类不能做基类能做的所有的事。
5.保护继承与私有继承类似，继承之后的类相对于基类来说是独立的。保护继承的类对象，在公开场合同样不能使用基类的成员。
6.当一个类是两个或多个基类的派生类时，必须在派生类名和冒号之后，列出所有基类的类名，基类间用逗号隔开。
7.派生类的构造函数必须激活所有基类的构造函数，并把相应的参数传递给它们。
8.在无继承的类中，protected和private控制符是没有差别的。在继承中，基类的private对所有的外界都屏蔽（包括自己的派生类），基类的protected控制符对应用程序是屏蔽的，但对其派生类是可访问的。
9.运算符是函数，除了运算顺序和优先级不能更改外，参数和返回类型是可以重新说明的，即可以重载。
10.C++规定了“ . 、:: 、. * 、-> 、？: ”这五个运算符不能重载，也不能创造新运算符。
11.operator++()是单目运算符，它含有一个参数。++d <=> d.operator++()； d++ <=> d.operator++(0)
12.C++规定： =，（），[ ]，-> 这四种运算符必须为成员形式。
13.使用前增量，对对象（操作数）进行增量修改，然后再返回该对象。所以前增量运算符操作时，参数与返回的是同一对象。
14.使用后增量，必须在增量之前返回原有的对象值。为此，要创建一个临时对象，存放原有的对象，以便操作数（对象）进行增量修改时，保存最初的值。
15.转换运算符：operator 类型名（）；它没有返回类型，因为类型名就代表了它的返回类型，故返回类型显得多余。

习题

一、单项选择题

1．在每个C++程序中都必须包含有这样一个函数，该函数的函数名为(A)。
A. main B. MAIN C. name D. function

2.如果class类中的所有成员在定义时都没有使用关键字public、private或protected，则所有成员缺省定义为（ C ）。
A） public B） protected C） private D）static

3．一个类的所有对象共享的是（ D ）。
A）私有数据成员 B）公有数据成员 C）保护数据成员 D）静态数据成员

4．动态联编所支持的多态性称为（ D ）。
A. 虚函数 B. 继承 C. 编译时多态性 D. 运行时多态性

5．下面有关重载函数的描述中，正确的是（ C ）。
A）重载函数必须具有不同的返回值类型 B）重载函数形参个数必须不同
C）重载函数必须具有不同的形参表 D）重载函数名可以不同

6．假定MyCIass为一个类，那么下列的函数说明中，（ D ）为该类的析构函数。
A）void~MyClass(); B）~MyClass(int n); C）MyClass( ); D）~MyClass( );

7．下列关于C++函数的说明中，正确的是（ C ）。
A）内联函数就是定义在另一个函数体内部的函数
B）函数体的最后一条语句必须是return语句
C）调用一个函数之前，如果还没有定义这个函数，必须先声明其原型
D）编译器会根据函数的返回值类型和参数表来区分函数的不同重载形式

8．假定MyCIass为一个类，那么下列的函数说明中，（ C ）为该类的无参构造函数。
A）void MyClass(); B）~MyClass(int n); C）MyClass( ); D）~MyClass( );

9．下列是重载加法运算符的函数原型声明，其中错误的是（ A ）。
A）MyClass operator+(double,double);
B）MyClass operator+(double,MyClass);
C）MyClass operator+(MyClass,double);
D）MyClass operator+(MyClass,MyClass);

10．下列对类的构造函数和析构函数描述正确的是（A）。
A)构造函数可以重载，析构函数不能重载 B)构造函数不能重载，析构函数可以重载
C)构造函数可以重载，析构函数可以重载 D)构造函数不能重载，析构函数不能重载

11．在函数定义前加上关键字“inline”，表示该函数被定义为（ B ）。
A）重载函数 B）内联函数 C）成员函数 D）普通函数

12．下列有关类与对象的说法中，( C ) 是不正确的。
A) 对象是类的一个实列 B) 任何一个对象只能属于一个具体的类
C) 一个类只能有一个对象 D) 类和对象的关糸和数椐类型与变量的关糸类似

13．类的析构函数的作用是( D )。
A) 作为类的一般成员函数 B) 类的初始化 C) 对象的初始化 D) 对象的删除

14．一个类的友元函数或友元类可以访问该类的( D )。
A) 私有成员 B) 保护成员 C) 公有成员 D) 所有成员

15．下列关于成员函数特征的描述中，( D ) 是错误的。
A) 成员函数一定是内联函数 B) 成员函数可以重载
C) 成员函数可以设置参数的默认值 D) 成员函数可以不设置参数的默认值

16．下列函数中，( C ) 不是类的成员函数。
A) 构造函数 B) 析构函数 C) 友元函数 D) 拷贝构造函数

17．下列的描述中，( B ) 是错误的。
A) 公有继承时基类中的public成员在派生类中仍是public的
B) 公有继承时基类中的private成员在派生类中是private的
C) 公有继承时基类中的protected成员在派生类中仍是protected的
D) 私有继承时基类中的public成员在派生类中仍是private的

18.class A
{
int i, j;
public:
A(int m, int n): i(m), j(n) { }
int Geti() { return i;}
};
class B: public A
{
int k;
public:
B(int m, int n, int u): A(m, n), k(u) {}
void Make( ) { k = i * j; }
};
int main()
{
B b(1, 2, 3);
return 0;
}则上述定义中，( A ) 是非法的表达式.
A) k=ij; B) int k; C) return i; D) void Make( )

19．假定CTest为一个类，并且有一无默认值的有参构造函数和一无参构造函数，则执行“CTest objTest;”语句时将自动调用该类的（ B ）。
A) 有参构造函数 B) 无参构造函数 C) 拷贝构造函数 D) 赋值重载函数

20、面向对象程序设计思想的主要特征中不包括（ D ）。
A. 封装性 B. 多态性 C. 继承性 D. 功能分解，逐步求精

21、考虑下面的函数原型声明：void testDefaulParam(int a,int b=7,char z=’’);
下面函数调用中，不合法的是（ C ）。
A. testDefaulParam(5); B. testDefaulParam(5,8);
C. testDefaulParam(5,’#’); D. testDefaulParam(0,0,’*’);

22、下列语句中，将函数int sum(int x, int y)正确重载的是（ C ）。
A. float sum(int x, int y); B. int sum(int a, int b);
C. float sum(float x, float y); D. double sum(int y, int x);

23、下列表示引用的方法中，（ A ）是正确的。
已知：int a=1000;
A. int &x=a; B. char &y; C. int &z=1000; D. float &t=&a;

24、已知X类，则当程序执行到语句：X array[3];时，调用了（ D ）次构造函数。
A. 0 B. 1 C. 2 D. 3

25、下面关于友元的描述中，错误的是（ D ）。
A. 友元函数可以访问该类的私有数据成员
B. 一个类的友元类中的成员函数都是这个类的友元函数
C. 友元可以提高程序的运行效率
D. 类与类之间的友元关系可以继承

26、有关析构函数的说法，不正确的是（ B ）。
A．析构函数有且仅有一个
B．析构函数和构造函数一样可以有形参
C．析构函数的功能是在系统释放对象之前作一些内存清理工作
D．析构函数无任何函数类型

27、可以在类外用p.a的形式访问派生类对象p的基类成员a，其中a是（ D ）。
A．私有继承的公用成员 B．公用继承的私有成员
C．公用继承的保护成员 D．公用继承的公用成员

28、在公有继承的情况下，基类非私有成员在派生类中的访问权限（B ）
（A） 受限制 （B）保持不变 （C）受保护 （D）不受保护

29.作用域运算符“：：”的功能是（B）
A. 标识作用域的级别的
B. 指出作用域的范围的
C. 给定作用域的大小的
D. 标识成员是属于哪个类的

30.关于const关键字说法错误的是（D）
A. const关键字可以修饰对象和成员函数
B. const对象不能被修改
C. const成员函数不能修改类数据成员
D. const可以用于说明类

31.下列描述错误的是（A）
A. 在创建对象前，静态成员不存在
B. 静态成员是类的成员
C. 静态成员不能是虚函数
D. 静态成员函数不能直接访问非静态成员

二、填空题

1．重载运算符“+”的函数名为operator+。
2．在C++中，如果类的名称是CTest，则此类的构造函数名称为CTest（）。
3．在类的对象被创建时，构造函数 函数会被自动调用。
4．对于派生类的构造函数，在定义对象时构造函数的执行顺序为：先执行 基类 的构造函数，再执行调用子对象类的构造函数，最后执行派生类的构造函数体中的内容。
5．类的具体表现是通过创建 对象 来操作的。
6．假定AB为一个类，则执行“AB a[10]；”语句时，系统自动调用该类的构造函数的次数为 10 。
7、在C++中，三种继承方式的说明符号为 private 、 public 和 protected，如果不加说明，则默认的继承方式为 private 。
8、若要把void fun( )定义为类A的友元函数，则应在类A的定义中加入语句friend void fun(A &a)。
9、运算符重载要求保持其原来的操作数个数、 优先级 、 结合性 。
10、列出C++中两种用户自定义的数据类型： 结构体 、 类 。
11、构造函数的作用是 在创建对象时为对象分配存储空间和初始化对象的数据成员。
12、C++类的组成包括数据成员和成员函数，友元不是该类的成员函数。
友员函数是用关键字friend修饰的非成员函数。

三、读程序写结果

1．若有以下程序:
class A
{
int a;
public:
A(int aa = 0 )
{
a = aa;
}
~A( )
{
cout << "Destructor A! " << a << endl;
}
};

class B: public A
{
int b;
public:
B(int aa = 0, int bb = 0): A(aa)
{
b = bb;
}
~B()
{
cout << "Destructor B! " << b << endl;
}
};
int main()
{
B x(5), y(6,7);
return 0;
}
上面程序的输出结果为：
Destructor B! 7
Destructor A! 6
Destructor B! 0
Destructor A! 5

2．若有以下程序:
#include <iostream.h>
class Point
{
int x, y;
public:
Point()
{
x = 0; y = 0;
}
void SetPoint(int x1, int y1)
{
x = x1;
y = y1;
}
void DisPoint()
{
cout << “x=” << x <<“,” << “y=” << y << endl;
}
};
int main()
{
Point P1;
P1.SetPoint(5, 12);
P1.DisPoint();
return 0;
}
上面程序的输出结果为：
x=5, y=12
3．若有以下程序:
#include <iostream.h>
class A
{
int a;
public:A(int aa = 0 )
{
a = aa;
cout << "A(): " << a << endl;
}
};
class B: public A
{
int b;
public:
B(int aa = 0, int bb = 0): A(aa)
{
b = bb;
cout << "B(): " << b << endl;
}
};
int main()
{
B x(5), y(6,7);
return 0;
}
输出结果为:
A( ): 5
B( ): 0
A( ): 6
B( ): 7

class Date
{
public:
Date(int,int,int);
Date(int,int);
Date(int);
Date();
void display();
private:
int month, day, year;
};
Date::Date(int m,int d,int y):month(m),day(d),year(y) { }
Date::Date(int m,int d):month(m),day(d) {year=2009;}
Date::Date(int m):month(m){day=1; year=2010; }
Date::Date( ) {month=1; day=1; year=2010; }
void Date::display(){ cout<<month<<“/”<<day<<“/”<<year<<endl; }
int main( )
{
Date d1(12,31,2009);
Date d2(12,31);
Date d3(1);
Date d4;
d1.display();
d2.display();
d3.display();
d4.display();
return 0;
}
输出结果为:
12/31/2009
12/31/2009
1/1/2010
1/1/2010
四、程序填空
1．请完成下面的程序
#include // 预处理命令
using namespace std; // 使用标准命名空间std
class Test
{
private:
int a; // 数据成员
public:
Test(int x = 0){ (1) } // 构造函数
void Show( ){ cout << “a:” << a << endl; } // 显示数据成员之值
};
int main( ) // 主函数main(void)
{
Test obj(168); // 定义对象
(2) // 显示数据成员之值
return 0;
}
2．请完成下面的程序
#include // 预处理命令
using namespace std; // 使用标准命名空间std
class Complex
{
private:
double realPart; // 实部
double imagePart; // 虚部
public:
Complex(double real = 0, double image = 0) // 构造函数
{
realPart=real;
imagePart=image;
}
double GetRealPart( ) { return realPart; } // 返回实部
double GetImagePart( ){ return imagePart; } // 返回虚部
Complex operator+( Complex &a) // 重载加法运算符+
{
return Complex( (3) ); // 返回和
}
};
int main( ) // 主函数main(void)
{
Complex a(1, 2), b(2, 6), c; // 定义复数对象
(4) // 复数加法运算
cout << “a=” << a.GetRealPart() << “+” << a.GetImagePart() << “i” << endl; // 显示a
cout << “b=” << b.GetRealPart() << “+” << b.GetImagePart() << “i” << endl; // 显示b
cout << “c=” << c.GetRealPart() << “+” << c.GetImagePart() << “i” << endl; // 显示c
return 0; // 返回值0, 返回操作系统
}
参考答案：(1) a=x ; (2) obj.Show( );
(3) realPart + a.realPart, imagePart + a.imagePart (4) c=a+b;

五、程序设计题

1、构造一个rectangle的矩形类，包含数据成员，左下角点的坐标（x1,y1）与右上角点的坐标（x2,y2）；包含成员函数getarea( )计算矩形的面积。完成类，并在主函数定义一个矩形对象，并计算输出该矩形对象的面积(10分)
2、定义一boat与car两个类，二者都有weight属性，定义二者的一个友元函数totalweight()，计算二者的重量和。(10分)

mooc错题

成员函数在类里面和外面实现的区别：
在类里面实现的也称为内联函数，内联函数在调用函数处用内联函数体的代码来替换，并不是像一般函数，转去执行被调用的函数体，执行完后再返回调用函数，这样会提高运行速度，内联函数和带参数的宏定义代码效率是一样的，但优于宏定义。
而在类外面实现的函数称为外联函数，其调用过程和普通函数相同，执行效率不如内联函数，但是外联函数可以转变为内联函数，只要在函数前面加上关键字inline就变成内联函数。
成员函数调用需要时间和空间开销，对于较长的函数，这种开销可以忽略不计，但对于函数体代码很短，又被频繁调用的函数，就不能忽视这种开销，引入内联函数正是为了解决这一问题，提高程序的运行效率
不适宜使用内联函数的场合：
(1)如果函数体内的代码比较长，使用内联函数将会导致内存消耗代价较高
(2)如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的 开销大。
类中函数重载
同一个作用域下
函数名称相同
函数参数类型不同或者个数不同
仅返回值不同不能是函数重载