《C++程序设计》复习资料.docx

资源描述

《C++程序设计》复习资料.docx

《《C++程序设计》复习资料.docx》由会员分享，可在线阅读，更多相关《《C++程序设计》复习资料.docx（44页珍藏版）》请在冰豆网上搜索。

《C++程序设计》复习资料.docx

《C++程序设计》复习资料

1、this指针可指向常量型数据、可指向成员函数，不可以指向静态成员函数。

this指针始终指向调用成员函数的对象。

2、宏定义语句：

#defineBUFSIZE100;== constintBUFSIZE100;

3、模板类的基类和派生类都可以是模板类或非模板类。

4、类A声明为类B的友元后，类A直接访问类B的公有成员。

5、对数据进行降幂和检索操作，需要包含头部文件functional。

对数据进行升幂等操作，需要包含头部文件algorithm。

对数组操作升幂排序的方法：

sort（a,a+len）。

6、虚函数只能是类中的一个成员函数，但不能是静态成员。

使用虚函数不一定产生多态性，也不一定使用动态联编，前提条件：

类之间的继承关系满足赋值兼容性规则，改写同名虚函数，根据赋值兼容性规则使用指针。

作为虚函数隐含参数的this指针，决定了虚函数调用时执行的代码。

7、C++编译指令：

所有编译指令都是以#开始的，每条指令单独占一行，同一行不能有其他编译指令和C++语句（注释除外）。

8、内联函数是通常与类一起使用。

如果一个函数是内联的，那么在编译时，编译器会把该函数的代码副本放置在每个调用该函数的地方。

对内联函数进行任何修改，都需要重新编译函数的所有客户端，因为编译器需要重新更换一次所有的代码，否则将会继续使用旧的函数。

如果想把一个函数定义为内联函数，则需要在函数名前面放置关键字inline，在调用函数之前需要对函数进行定义。

如果已定义的函数多于一行，编译器会忽略inline限定符。

在类定义中的定义的函数都是内联函数，即使没有使用inline说明符。

9、派生类可以继承多个基类。

派生类对象中包含基类对象，因此派生类对象在创建时，除了要调用自身的构造函数进行初始化外，还要调用基类的构造函数初始化其包含的基类对象。

因此，程序中任何能够生成派生类对象的语句，都要说明其包含的基类对象是如何初始化的。

如果对此不做说明，则编译器认为基类对象要用无参构造函数初始化——如果基类没有无参构造函数，则会导致编译错误。

在执行一个派生类的构造函数之前，总是先执行基类的构造函数。

和封闭类说明成员对象如何初始化类似，派生类说明基类对象如何初始化，也需要在构造函数后面添加初始化列表。

在初始化列表中，要指明调用基类构造函数的形式。

保护继承时，类成员的访问级别只能降低为保护模式，因此即使是基类的公有成员也被缩小为保护模式。

派生类对象消亡时，先执行派生类的析构函数，再执行基类的析构函数。

在C++中，派生可以是多层次的。

例如学生类派生出中学生类，中学生类又派生出初中生类和高中生类。

总之，类A派生类B，类B可再派生类C，类C又能派生类D，以此类推。

这种情况下，称类A是类B的直接基类，类B是类C直接基类，类A是类C的间接基类。

当然，类A也是类D的间接基类。

在定义派生类时，只写直接基类，不写间接基类。

派生类沿着类的层次自动向上继承它所有的间接基类。

派生类的成员包括派生类自己定义的成员、直接基类中定义的成员，以及所有间接基类的全部成员。

当派生类的对象生成时，会从最顶层的基类开始逐层往下执行所有基类的构造函数，最后再执行自身的构造函数；当派生类对象消亡时，会先执行自身的析构函数，然后从底向上依次执行各个基类的析构函数。

派生类构造函数进行初始顺序：

调用基类构造函数，调用子类对象的构造函数，执行派生类的构造函数。

析构函数进行操作顺序：

调用成员对象析构函数，对派生类新增的成员对象进行清理，调用基类析构函数，对基类进行清理。

类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。

类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。

成员函数可以在类体外定义。

成员函数可以定义在类定义内部，或者单独使用范围解析运算符:

来定义。

在类定义中定义的成员函数把函数声明为内联的，即便没有使用inline标识符。

所以可以按照如下方式定义 Volume（）函数：

classBox{

public:

doublelength;//长度

doublebreadth;//宽度

doubleheight;//高度

doublegetVolume（void）

{returnlength*breadth*height;

}

};

也可以在类的外部使用范围解析运算符:

定义该函数，如下所示：

doubleBox:

getVolume（void）

{returnlength*breadth*height;

}

在:

运算符之前必须使用类名。

调用成员函数是在对象上使用点运算符（.），这样它就能操作与该对象相关的数据。

（作用域运算符“：

：

”的功能是标识成员是属于哪个类的。

）

10、类的访问权限主要有public，protected和private。

11、在面向对象方法中，所谓多态性就是不同对象收到相同消息，产生不同的行为。

在C++程序设计中，多态性是指用一个名字定义不同的函数，这些函数执行不同但又类似的操作，这样就可以用同一个函数名调用不同内容的函数。

在程序设计中经常会使用到多态性。

最简单的例子就是运算符，例如我们使用运算符+，就可以实现整型数、浮点数、双精度类型之间的加法运算，这三种类型的加法操作其实是互不相同的，是由不同内容的函数实现的。

这个例子就是使用了多态的特征。

在C++中，多态性的实现和联编（也称绑定）这一概念有关。

一个源程序经过编译、链接，成为可执行文件的过程是把可执行代码联编（或称装配）在一起的过程。

其中在运行之前就完成的联编成为静态联编（前期联编）；而在程序运行之时才完成的联编叫动态联编（后期联编）。

静态联编支持的多态性称为编译时多态性（静态多态性）。

在C++中，编译时多态性是通过函数重载和模板实现的。

利用函数重载机制，在调用同名函数时，编译系统会根据实参的具体情况确定索要调用的是哪个函数。

动态联编所支持的多态性称为运行时多态（动态多态）。

在C++中，运行时多态性是通过虚函数来实现的。

12、每个C++程序中都要有且仅有一个主函数，该函数是程序的入口，而语句、预处理命令和函数及类在程序中都可以有多个。

13、在C++中，要实现动态联编，必须使用基类指针调用虚函数。

动态联编是以虚函数为基础的；动态联编是在运行时确定所调用的函数代码的；动态联编调用函数操作是指向对象的指针或对象引用。

C++的继承性允许派生类继承基类的部分成员，并允许增加新的成员或重定义基类的成员。

不加说明时，默认的继承方式是private。

14、在C++程序中的typename是都可以替换为class的，但class不能都替换为typename。

15、耦合性与内聚性是模块独立性的两个定性标准，耦合与内聚是相互关联的。

在程序结构中，各个模块的内聚性越强，则耦合性越弱。

一般较优秀的软件设计，应尽量做到高内聚、低耦合，即减弱模块之间的耦合性和提高模块内的内聚性，有利于提高模块的独立性。

16、如果在一个程序块中有两个变量具有相同的名字，并且都有效，只是它们的作用域不同，则优先访问作用域较小的那个变量。

17、C++允许为同一个函数定义几个版本，使其有多种功能，称为函数重载。

18、C++输入/输出操控符中，含义是设置转换基数为十进制是dec，含义是设置转换基数为八进制是oct，含义是设置转换基数为十六进制是hex，输出一个换行符并刷新流的是endl，设置输出数据字段宽度width是setw。

19、重载的运算符的实质是保持原有的运算符个数、优先级和结合性不变。

20、流类库ios_base:

out：

打开文件进行写操作。

ios_base:

binatry：

以二进制方式打开，默认为文本。

ios_base:

showpos：

在正数前添加一个“+”号。

21、指向常量的指针在非常量指针声明前使用const。

指向常量的指针：

constinty=23;constint*p=&y;常量指针：

intx=23;int*constp=&x;指向常量的常量指针：

intx=23;constint*constp=&x;

22、一个类可以说明多个纯虚函数，包含纯虚函数的类称为抽象类。

23、const定义常量数据成员、静态常数据成员和常引用。

24、在C++程序设计中，使用new代替malloc分配动态内存。

25、聚合是指复杂对象可以由简单对象构成。

26、利用向量类模板定义一个具有10个double的向量E，元素被置为1.5，其操作语句为：

vectorE（10,1.5）;。

27构造函数名和类名一样，且在定义构造函数不能有返回类型，即使void也不行。

28、C++预处理语句：

宏定义、文件包含、条件编译。

29、类可以不包括任何声明。

在同一个类中，说明访问特性的关键字可以多次使用。

30、二元运算符作为友元运算符重载，参数表中应有两个参数。

运算符重载为成员函数时，若参数表中无参数，重载的是一元运算符（可以作为成员函数重载，也可以作为友元函数重载）。

31、类A的复制构造函数的原型是：

A（constA&）

32、ios类是istream类和ostream类的虚基类。

33、在C++中使用流进行输入输出，其中用于屏幕输出的对象是cout。

34、C++通过类实现数据封装。

35、虚函数未定义，留给派生类去定义的虚函数称为纯虚函数。

实现动态绑定必须声明虚函数。

36、fun（）申明为纯虚函数的正确形式是virtualvoidfun（）=0;

dynamic_cast操作是专门针对有虚函数的继承结构的，将基类指针转换成想要的子类指针，做好操作的准备。

37、地址运算符&用来取对象存储的首地址值。

38、C++语言的标准模板库（STL）提供了与要操作的元素类型无关的算法。

泛型算法就是提供的操作与元素的类型无关。

39、C++函数分为库函数、用户自定义函数。

40、UML中实例连接反应对象之间的静态关系，消息连接描述对象之间的动态关系。

41、操控符setprecision（intn）的含义是设置浮点输出精度n。

36、统计数组中包含元素的个数：

n=sizeof（A）/sizeof（*A）。

42、关键字friend用于声明友元；一个类中的成员函数可以是另一个类的友元；友元函数访问对象的成员不受访问特性影响。

友元函数可以直接访问对象的私有成员，可以出现于类的私有、公有部分。

友元函数可以在类中声明时定义，也可以在类外定义，如果在类外定义，就不能使用friend关键字。

友元关系不能传递。

43、泛型算法就是提供的操作与元素类型无关。

44、简单的成员函数不包含const、static、volatil。

45、在C++程序设计中，函数返回类型可以是除数组和函数以外的任何类型。

46、如果形参是简单变量，则对应实参与形参之间的数据传递方式是单向值传递。

47、类的常成员函数，无返回值：

voidprint（）const。

48、调用函数时，需要改变实参或者返回多个值，应采取传值或传引用的方式。

49、友元函数语句：

friendvoidA:

fun（）;

50、字符型数据在内存中的存放形式：

ASCII。

51、友元提供了不同类或对象的成员函数之间、类的成员函数于一般函数之间进行数据共享的机制。

通过友元，一个普通函数或者类的成员函数可以访问到封装于某一类中的数据，友元函数可以通过对象名访问类的私有和保护成员。

友元函数的主要作用：

提供程序的效率。

52、不能作为函数重载的判断依据是：

返回类型。

53、C++源程序文件后缀是：

.cpp。

经过编译后，生成文件的后缀是：

.obj。

经过连接后，生成文件的后缀是：

.exe。

C++进行文件操作时需要包含的头文件fstream。

54、模板函数定义的一般形式如下所示：

templateret-typefunc-name（parameterlist）{//函数的主体}

在这里，type是函数所使用的数据类型的占位符名称。

这个名称可以在函数定义中使用。

函数模板的真正代码是在源程序中调用函数时产生的。

引用模板函数和引用一般函数在语法形式上基本相同。

说明一个函数模板后，当编译系统发现有一个对应的函数调用时，将根据实参中的类型来确认是否调用函数模板中的对应形参。

55、注释分为：

序言性注释和功能性注释。

56、C++允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。

重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。

当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。

选择最合适的重载函数或重载运算符的过程，称为重载决策。

重载函数必须有不同的形参列表。

57、派生类不可以继承基类中的构造函数和析构函数。

一个派生类可以作另一派生类的基类；派生类至少有一个基类；派生类的成员除了它自己的成员外，还包含了它的基类的成员。

58、在创建派生类对象时，构造函数的执行顺序是基类构造函数、对象成员构造函数、派生类本身的构造函数。

析构函数与构造函数相反，当对象结束其生命周期，如对象所在的函数已调用完毕时，系统自动执行析构函数。

它的名字与类名相同，但前面要加~，没有参数和返回值。

析构函数往往用来做类似清理善后的工作（例如在建立对象时用new开辟了一片内存空间，delete会自动调用析构函数后释放内存）。

C++当中的析构函数格式如下：

class <类名>

{

public:

~<类名>（）;

};

<类名>:

~<类名>（）

{

//函数体

}

如以下定义是合法的：

class T

{

public:

~T（）；

};

~T（）

{

//函数体

}

当程序中没有析构函数时，系统会自动生成以下析构函数：

<类名>:

~<类名>（）{}，即不执行任何操作。

C++语言中析构函数为符号“～”加类名，且析构函数没有返回值和参数

59、在定义类成员时，为体现对外的隐藏性，需要使用的关键字是private。

定义一个生日类，数据成员有年、月、日。

定义一个人员类，数据成员有姓名、性别、生日。

人员类中的生日是生日类的对象，两个类都有构造函数和显示函数。

在主函数中声明一个人员类对象，屏幕显示其数据。

60、静态成员变量是类的所有对象所共有的。

具有转换函数功能的构造函数，应该是带有一个参数的构造函数。

61、有一种只在循环语句或switch语句中使用的流程控制语句，表示该语句的关键字是break。

程序设计参考

　　1、程序1：

　　#include

　　inta=10;

　　classTC

　　{

　　public：

　　TC（）

　　{

　　a=b=0：

　　}

　　voiddisplay（）

　　{

　　cout<

　　}

　　voidfunc（inta）

　　{

　　this->a+=a;

　　}

　　voidfunc2（）

　　{

　　//******error******

　　a+=：

：

　　}

　　private：

　　inta，b;

　　};

　　voidmain（）

　　{

　　TCobj;

　　obj.func（3）;

　　obj.display（）;

　　obj.func2（）;

　　obj.display（）;

　　}

程序输出的结果为：

　　130

2、程序如下：

#include

usingnamespacestd;

classA

{

public:

virtualvoidshow（）

{cout<<"A";}

};

classB:

publicA

{

public:

voidshow（）

{cout<<"B";}

};

intmain（）

{

Aa1,*pa;

Bb1;

pa=&a1;

pa->show（）;

pa=&b1;

pa->show（）;

return0;

}

程序运行结果为：

3、程序如下

　　#include

　　intx=5;

　　intfun（inta）

　　{

　　intc：

　　c=X*a：

　　returnC;

　　}

　　voidmain（）

　　{

　　intx=3，a=4;

　　x=x+fun（a）;

　　cout<<"x="<

　　}

程序运行结果：

x=23

4、下面是关于复制构造函数的程序

#include

usingnamespacestd;

classA

{

pubic：

A（）

{cout<<”default”<

}

A（A&a）

{cout<<”copy”<

}

};

ClassB

{Aa;

};

intmain（）

{Bb1,b2（b1）;

return（）;

}

程序运行结果：

default

copy

5、下面是关于虚基类的程序

#include

classBase

{public:

Base（）{cout<<"Base"<

};

classBase2

{public:

Base2（）{cout<<"Base2"<

};

classLevel1:

virtualpublicBase2,virtualpublicBase

{public:

Level1（）{cout<<"Level1"<

};

classLevel2:

publicBase, virtualpublicBase2

{public:

Level2（）{cout<<"Level2"<

};

classLevel3:

publicLevel1

{public:

Level3（）{cout<<"Level3"<

};

classToplevel:

publicLevel3,virtualpublicLevel2

{public:

Toplevel（）{cout<<"TopLevel"<

};

voidmain（）{Toplevelt;}

程序运行结果：

Base2

Base

Level2

Level1

Level3

TopLevel

6、下面是关于虚函数的程序。

#include

classBase

{public:

virtualvoidf1（）{cout<<"f1..."<

virtualvoidf2（）{cout<<"f2..."<

virtualvoidf3（）{cout<<"f3..."<

voidf4（） {cout<<"f4..."<

};

classDerive:

publicBase

{ voidf1（） {cout<<"Derive:

f1（）..."<

voidf2（intx）{cout<<"Derive:

f2（）..."<

voidf4（） {cout<<"Derive:

f4（）..."<

};

voidmain（void）

{ Baseobj1,*ptr;

Deriveobj2;

ptr=&obj1;

ptr->f1（）;ptr->f2（）;

ptr->f3（）;ptr->f4（）;

ptr=&obj2

ptr->f1（）;ptr->f2（）;

ptr->f3（）;ptr->f4（）;

}

程序运行结果：

f1...

f2...

f3...

f4...

Derive:

f1（）...

f2...

f3...

f4...

7、程序如下：

#include

　　voidmain（）

　　{inta[3],i,j,k=2;

　　for（i=0;i<3;i++）a[i]=i;

　　for（i=0;ifor（j=0;ja[j]=a[i];

　　cout<

程序输出结果为：

8、程序如下：

　　#include

　　　Voidmain（）　

　　{

　　　intm=0144;

　　　intn=0X25;

　　intq=32;

　　cout<

　　return;

　　}

　程序输出的结果为：

　　100

9、程序如下

#include

intmain（）

{

intk;

chara[][10]={"ABCD","EFGH","IJKL","MNOP"};

for（k=1;k<3;k++）

cout<<&a[k][k]<

return0;

}

程序的运行结果：

FGH

10、程序如下

#include

usingnamespacestd;

classA

{

public:

A（）{cout<<"A";}

};

classB

{

public:

B（）{cout<<"B";}

};

classC:

publicA,publicB

{

private:

Aa1;

Bb1;

public:

C（）{cout<<"C";

}

};

intmain（）

{

Cc1;

return0;

}

程序的运行结果

ABABC

11、下面程序是关于引用返回值的程序。

#include

doublearr[5];

double&select（intnum）

{

intn;

n=（（int）fabs（num））%5;

returnarr[n];

}

voidmain（）

{

intnum;

for（inti=11;i<=15;i++）

{ select（i）=i*0.2; }

for（i=0;i<=4;i++）

{ cout<

}

程序运行结果：

2.2

2.4

2.6

2.8

12、下面是关于异常处理程序。

#include

usingnamespacestd;

enumpower{good_looking=1,intelligence,perseverance};

voidmyTermina

展开阅读全文