C++语言程序设计知识点及示例.docx

C++语言程序设计知识点及示例.docx

《C++语言程序设计知识点及示例.docx》由会员分享，可在线阅读，更多相关《C++语言程序设计知识点及示例.docx（30页珍藏版）》请在冰豆网上搜索。

C++语言程序设计知识点及示例

C++语言程序设计知识点及示例

知识点1：

C++类的构造函数用于类的初始化。

示例1：

C++类的构造函数用于删除对象时对对象作相应的处理工作。

参考答案：

×

示例2：

C++类的（）用于类的初始化。

参考答案：

构造函数

知识点2：

C++类的析构函数用于对象删除时作相应处理工作。

示例3：

C++类的析构函数用于类的初始化。

参考答案：

×

示例4：

C++类的（）用于对象删除时作相应处理工作。

参考答案：

析构函数

知识点3：

一个类可以有多个构造函数（也就是可以重载构造函数），但只能有一个析构函数（也就是不能进行重载）。

示例5：

C++类的构造函数最多只有一个。

参考答案：

×

示例6：

设计一个类CTime，要求其满足下述要求：

（1）要求有一个无参的构造函数，其初始的时（hour），分（minute），秒（second）分别为：

24，59，59。

（2）要求有一个带参数的构造函数，其参数分别对应时（h），分（m），秒（s）。

（3）要求用一个成员函数实现时间的设置。

（4）要求用一个成员函数实现时间的获取。

参考答案：

具体类及相关测试程序如下：

#include

classCTime//时间类

{

private:

inthour,mimute,second;//时，分，秒

public:

CTime（）:

hour（24）,mimute（59）,second（59）{}//无参构造函数

CTime（inth,intm,ints）:

hour（h）,mimute（m）,second（s）{}//带参构造函数

voidSetTime（inth,intm,ints）//设置时间

{hour=h;mimute=m;second=s;}

voidGetTime（int&h,int&m,int&s）const//用参数返回时间

{h=hour;m=mimute;s=second;}

};

voidmain（）

{

CTimet;//时间对象

inth,m,s;//时分秒

t.GetTime（h,m,s）;//获取时间值

cout<

"<

"<

t.SetTime（6,8,18）;//设置时间值

t.GetTime（h,m,s）;//获取时间值

cout<

"<

"<

}

点评：

平时练习时所有类都应编写相应测试函数进行测试，但在答案中可只写出类的定义，不必写出测试程序。

示例7：

一个类可以有多个构造函数，但只能有一个析构函数。

参考答案：

√

知识点4：

内联函数指程序在编译时用函数的代码替换每一处函数调用的地方，内联函数的关键字是inline。

示例8：

类的成员函数都是内联函数。

参考答案：

×

示例9：

一个类的内联函数所用的关键字是（）。

参考答案：

inline

知识点5：

一个类的友元函数或友元类可以访问该类的所有成员，并且有友元类或友元函数所用的关键字是friend。

示例10：

类的友元可以访问类的私有成员。

参考答案：

√

示例11：

类的友元所用的关键字是（）。

参考答案：

friend

示例12：

友元函数是类的成员函数。

参考答案：

×

知识点6：

重载函数用于实现静态联编（编译时多态性），重载函数的函数名相同，但具有不同的形参列表。

示例13：

重载函数可以具有相同的函数名与形参列表，但具有不同的返回类型。

参考答案：

×

知识点7：

派生类中继承的基类成员的访问权限要受到派生类的继承方式的影响。

示例14：

派生类中继承的基类成员的访问权限不受继承方式的影响。

参考答案：

×

知识点8：

对象是类的具体化，一个对象只能属于一个类，一个类包含多个对象。

示例15：

一个类最多只包含一个对象。

参考答案：

×

知识点9：

声明常成员函数与常对象的关键字是const，并在声明常成员函数时，const应放在函数头的后面。

示例16：

声明常对象的关键字是（）。

参考答案：

const

示例17：

声明一个函数名是Show，无返回类型与参数的常成员函数声明为（）。

参考答案：

voidShow（）const;

知识点10：

公有派生，派生类中保持基类的成员特性，私有派生，派生类中基类公有和保护成员成为私有，保护派生时，基类中公有成员和保护成员在派生类中均变为保护。

示例18：

在公有派生中，基类的所有成员都变为派生类的公有成员。

参考答案：

×

示例19：

在保护派生中，基类的所有成员都变为派生类的保护成员。

参考答案：

×

点评：

基类的私有成员不能被继承。

知识点11：

类的构造函数的函数名为类名，无返回值类型，类的析构函数的函数名为“~类名”，无返回值类型与无参数。

示例20：

类MyClass的析构函数声明为（）。

参考答案：

~MyClass（）;

知识点12：

虚基类的声明是在定义派生类时，在继承方式的位置写上关键字virtual。

示例21：

virtualclassB:

publicA表明A为B的虚基类。

参考答案：

×

示例22：

classB:

virtualpublicA表明A为B的虚基类。

参考答案：

√

知识点11：

多继承可能产生多义（二义）性，可采用类作用域分辨运算符或虚基类加以解决。

示例23：

采用（）和（）解决多继承可能产生多义性问题。

参考答案：

作用域运算符虚基类

知识点12：

虚函数用于运行时多态性，使用的关键字是virtual。

示例24：

虚函数使用的关键字是（）。

参考答案：

virtual

知识点13：

cout是ostream类的（派生类的）标准输出流对象，对应屏幕；cin是istream类的（派生类的）标准输入流对象，对应键盘。

示例25：

cin是标准输入流对象。

参考答案：

√

示例26：

cin是（）类的（派生类的）对象。

参考答案：

istream

知识点14：

class类成员的缺省访问方式是private，struct类成员的缺省访问方式是public。

注：

只写类，则指class类。

示例27：

class类成员如果没有指定访问方式，则缺省的访问方式为（）。

参考答案：

private

知识点15：

模板使用的关键字是template。

示例28：

函数模板使用的关键字是template。

参考答案：

√

知识点16：

纯虚函数是无函数体的函数。

含纯虚函数的类称为抽象类，抽象类不能生成对象，只能作为基类派生出其它类。

示例29：

抽象类也可定义对象。

参考答案：

×

知识点17：

类的静态成员被类的所有对象所共享，可用类名直接引用（类名:

:

静态成员），并且静态成员函数无this指针。

示例30：

静态数据成员可用类名直接引用。

参考答案：

√

示例31：

如果在类MyClass中通过

MyClass:

:

f（）这种方式来调用函数，则函数f（）是类MyClass的（）。

参考答案：

静态成员函数

知识点18：

动态联编的使用方式是指向派生类对象基类指针或对派生类对象的基类引用去调用虚函数。

示例32：

使用指针或引用调用派生类的虚函数实现动态联编。

参考答案：

√

示例33：

要求用下面的程序实现动态多态性,但程序有错,请指出错误并改正之。

#include//1

classA//2

{//3

public:

//4

A（intx=0）:

a（x）{}//5

Show（）const{cout<<"a:

"<

private:

//7

inta;//数据成员//8

};//9

classB:

publicA//10

{//11

public:

//12

B（intx=0,inty=0）:

A（x）,b（y）{}//13

Show（）const{cout<<"b:

"<

private:

//15

intb;//数据成员//16

};//17

voidmain（void）//18

{//19

A*p=newB（5,18）;//定义对象//20

p.Show（）;//21

deletep;//22

}//23

参考答案：

笫6行基类中虚函数Show（）前应加关键字virtual修饰。

应将“Show（）const{cout<<"a:

"<

"<

第21行有错，p为指针，调用数据成员格式错。

应将“p.Show（）;”改为“p->Show（）;”。

示例34：

设A为基类，B为派生类，f（）为虚函数，则要实现动态联编，请填空：

Aa,*p;Bb;_________;

参考答案：

p=&b

知识点19：

如果类MyClass具有无参构造函数，则MyClassobj将调用无参构造函数。

示例35：

如果CTest没有无参构造函数，并且构造函数无缺省参值，对象定义“CTestobj;”将产生编译错误。

参考答案：

√

知识点20：

构造函数可以有默认参数。

但析构函数则无参数。

示例36：

构造函数不能定义默认参数。

参考答案：

×

知识点21：

函数模板是模板，而模板函数是函数，类模板是模板，而模板类是类。

示例37：

函数模板与模板函数意义完全相同。

参考答案：

×

知识点22：

常成员函数可以操作常对象或一般对象，而一般成员函数只能访问一般对象。

示例38：

常对象只能调用常成员函数。

参考答案：

√

知识点23：

重载运符算的函数名为：

operator运符算

示例39：

重载运算苻“*”的函数名为（）.

参考答案：

oprator*

示例40：

定义一个二维点类Point，具有二个数据成员为double型x,y，定义含两个参数的构造函数和一个Show（）函数用以输出x,y的值,另外作为成员函数重载的运算苻”+”的功能是将此类二个对象的数据成员x和y对应相加，这些成员函数的属性均为public.请用C++编写此程序,并编写测试程序进行测试

参考答案：

参考测试程序如下：

#include

classPoint

{

private:

doublex,y;//坐标值

public:

Point（doublea=0,doubleb=0）:

x（a）,y（b）{}//构造函数

voidShow（）const{cout<

Pointoperator+（constPoint&obj）//重载加法运算符

{returnPoint（this->x+obj.x,this->y+obj.y）;}

};

voidmain（）

{

Pointp1（3.5,4.5）,p2（2.5,5.5）,p3;//定义对象

p3=p1+p2;//对象求和

p3.Show（）;//显示坐标值

}

知识点24：

类的表现有两种,一是生成类的对象,另一种是通过继承派生出新的类来重用代码.。

示例41：

类能过（）来重用代码

参考答案：

继承

知识点25：

拷贝构造函数一般采用类的常引用作为参数。

示例42：

类MyClass的拷贝构造函数的参数类型一般为：

（）

参考答案：

constMyClass&

知识点26：

定义对象数组时，将自动调用无参构造函数来生成数组元素。

示例43：

类MyClass有对象数组定义“MyClassa[18];”，则将调用无参构造函数（）次。

参考答案：

18

知识点27：

用new生成的对象，应使用delete来释放。

示例44：

new与（）应配对使用。

参考答案：

delete

知识点28：

构函数的执行次序：

基类构造函数派生类构造函数；析构函数的执行次序与构造函数的执行次序相反：

派生类析构函数基类析构函数；构造函数一般按各对象生成的次序执行各对象的构造函数，而析构函数则按各对象生成顺序的相反次序执行各对象的构造函数。

示例45：

阅读如下程序，写出运行结果。

#include

classA//基类

{

private:

inta;

public:

A（intx）:

a（x）{cout<<"A（"<

};

classB:

publicA//派生类

{

private:

intb;

public:

B（intx,inty）:

A（x）,b（y）{cout<<"B（"<

};

voidmain（）

{

Bobj1（1,1）,obj2（2,2）;//派生类对象

}

运行结果：

参考答案：

A

（1）

B

（1）

A

（2）

B

（2）

点评：

构函数的执行次序：

基类构造函数派生类构造函数；构造函数一般按各对象生成的次序执行各对象的构造函数。

示例46：

阅读如下程序，写出运行结果。

#include

classA//基类

{

private:

inta;

public:

A（intx）:

a（x）{}//构造函数

~A（）{cout<<"~A（）:

"<

};

classB:

publicA//派生类

{

private:

intb;

public:

B（intx,inty=0）:

A（x）,b（y）{}//构造函数

~B（）{cout<<"~B（）:

"<

};

voidmain（）

{

Bobj1（1,1）,obj2

（2）;//派生类对象

}

运行结果：

参考答案：

~B（）:

0

~A（）:

2

~B（）:

1

~A（）:

1

点评：

析造函数的执行次序：

派生类析构函数基类析构函数；析构函数则按各对象生成顺序的相反次序执行各对象的构造函数。

示例47：

阅读如下程序，写出运行结果。

#include

classA//基类

{

private:

inta;

public:

A（intx）:

a（x）{cout<<"A（"<

~A（）{cout<<"~A（）:

"<

};

classB:

publicA//派生类

{

private:

intb;

public:

B（intx=0,inty=0）:

A（x）,b（y）{cout<<"B（"<

~B（）{cout<<"~B（）:

"<

};

voidmain（）

{

Bobj1,obj2（1,2）;//派生类对象

}

运行结果：

参考答案：

A（0）

B（0）

A

（1）

B

（2）

~B（）:

2

~A（）:

1

~B（）:

0

~A（）:

0

点评：

析构函数的执行次序与构造函数的执行次序相反。

知识点29：

类的私有数据成员不能过过对象直接修改，只能通过在对象中调用公有函数（方法）来间接修改私有数据成员的值。

示例48：

阅读如下程序，写出运行结果。

#include

classMyTest//测试类

{

private:

inta,b;//私有数据成员

public:

MyTest（intx=0,inty=0）:

a（x）,b（y）{}//构造函数

voidUpdate（intx,inty）{a=x;b=y;}//修改私有数据成员值

voidShow（）{cout<

};

voidmain（）

{

MyTestobj;//对象

obj.Update（5,18）;//修改私有数据成员值

obj.Show（）;//显示私有数据成员值

}

运行结果：

参考答案：

5,18

知识点30：

静态成员被类的所有对象所共享，特别是静态数据成员可用于累加构造函数提供的参数。

示例49：

阅读如下程序，写出运行结果。

#include

classA

{

private:

staticints;//静态数据成员

public:

A（inti）{s+=i;}//构造函数

staticvoidShow（）{cout<

};

intA:

:

s=0;//初始化静态数据成员

voidmain（）

{

Aa

（1）,b

（2）,c（4）;//定义对象

A:

:

Show（）;//显示静态数据成员

}

运行结果：

参考答案：

7

点评：

通过“类名:

:

静态函数名（实参）”方式来调用静态成员函数。

示例50：

阅读如下程序，写出运行结果。

#include

classA//类定义

{

intn;//数据成员

staticints;//静态数据成员

public:

A（inti）:

n（i）{}//构造函数

voidadd（）{s+=n;}//数据n加到s

voiddis（）{cout<

};

intA:

:

s=0;//初始化静态数据成员

voidmain（）

{

Aa（3）,b（7）,c（8）;//定义对象

a.add（）;//将a的n=3加到s

b.add（）;//将b的n=7加到s

c.dis（）;//显示s的值

}

运行结果：

参考答案：

10

知识点31：

动态多态性通过基类指针或类引用来实现。

示例51：

阅读如下程序，写出运行结果。

#include

classBase//基类

{

public:

virtualvoidShow（）{cout<<"1"<

};

classDerived:

publicBase

{

public:

voidShow（）{cout<<"2"<

};

voidmain（）

{

Deriveda;//派生类对象

Base*p=&a;//基类指针指向派生类对象

p->Show（）;//通过指向调用Show（）,体现动态联编，执行派生类的Show（）

a.Show（）;//通过派生类对象直接调用Show（）

}

运行结果：

参考答案：

2

2

示例52：

阅读如下程序，写出运行结果。

#include

classBase//基类

{

public:

voidShow（）{cout<<"1"<

};

classDerived:

publicBase//派生类

{

public:

voidShow（）{cout<<"2"<

};

voidmain（）

{

Deriveda;//派生类对象

Base*p=&a;//基类指针指向派生类对象

p->Show（）;//通过指针调用Show（）,执行基类的Show（）

a.Show（）;//通过派生类对象直接调用Show（）

}

运行结果：

参考答案：

1

2

知识点32：

常对象只能调常成员函数,而一般对象既可调常成员函数,也可调非常成员函数。

示例53：

阅读如下程序，写出运行结果。

#include

classMyTest

{

private:

intnum;//数据成员

public:

MyTest（inti）:

num（i）{}

voidPrint（）{cout<<"1:

num="<

voidPrint（）const{cout<<"2:

num="<

};

voidmain（）

{

MyTesta（5）;//一般对象

constMyTestb（18）;//常对象

a.Print（）;//一般对象优先调用一般函数

b.Print（）;//常对象只能调用常函数

}

运行结果：

参考答案：

1:

num=5,2:

num=18

示例54：

阅读如下程序，写出运行结果。

#include

classSample

{

intn;

public:

Sample（inti）{n=i;}

voidPrint（）{cout<<"1:

n="<

voidPrint（）c