c++复习

一、主要知识点：

函数的定义、原型、函数重载、带默认形参值的函数、内联函数

编译预处理（暂不要求）

字符串、字符串与数组、字符串与指针、指针、引用

动态存储分配

链表（暂不要求）

类和对象的概念、成员的访问

内联成员函数

成员函数的存储（暂不要求）

构造函数的概念和特点、其参数、重载、调用，

析构函数的概念和特点

构造和析构的调用顺序

静态成员

友元的概念和特点

继承和派生的概念、三种派生方式下的访问权限

派生类的构造和析构、多重派生时构造函数和析构函数的调用顺序

多重继承的二义性

联编、多态性、虚函数、纯虚函数、抽象类

（运算符重载、输入输出操作与文件流、模板、异常处理）的概念特点思想等。

二、考题类型

1、填空题（） 派生类的生成过程经历了三个步

骤： 、 、 。

多态分为： 和 。

面向对象的四个特点： 、 、 和 。 2、选择题（10分）

在一个函数中，要求通过函数来实现一种不太复杂的功能，并且要求加快执行速度，选用（ ）比较合适。

A 内联函数 B 重载函数 C 递归调用 D 嵌套调用

下面对构造函数的描述不正确的是（）

A 可以重载 B 其名字与类名相同 C 可以显式调用构造函数 D 构造函数是成员函数 E 构造函数不能是虚函数

3、判断题（正确的请写T，错误的请写F）（20分） 静态成员函数可以直接调用类中说明的非静态成员。（ ） this指针隐含于每一个成员函数中（ ）

windows应用程序采用基于消息的事件驱动运行机制。（ ）

4、找出程序中的错误并改正（10分）

class student（） {

private: public: display(){}

} }；

//----------------------------------------------- void g() student g() {

student s; return s; }

//------------------------------------------------ mian（） void main（） {

student s1;

s1->display(); s1.display(); }

5、读程序，在语句后的括号中填入相应的选项，并写出程序运行结果结果（8个小题）（共40分 结果30分 选择10分 ）

选项：A、复制构造函数 B、构造函数 C、内联成员函数 D、对象成员 E、对象作为函数的参数 F、调用复制构造函数 G、对象调用成员函数 1、

#include #include class Point {

public:

Point(int xx=0,int yy=0){X=xx;Y=yy;} //1、（ Point(const Point& p); //2、（ int GetX(){return X;}

int GetY(){return Y;} //3、（ private: int X,Y; };

Point::Point(const Point& p) {

X=p.X; Y=p.Y;

cout<<\}

class Distance {

public:

Distance(Point xp1,Point xp2); //4、（ double GetDis(){return dist;} private:

Point p1,p2; //5、（ double dist; };

Distance::Distance(Point xp1,Point xp2):p1(xp1),p2(xp2) //6{

cout<<\ double x=double(p1.GetX()-p2.GetX()); double y=double(p1.GetY()-p2.GetY()); dist=sqrt(x*x+y*y); }

void main() {

Point myp1(2,2),myp2(5,6); Distance myd(myp1,myp2);

） ） ） ） ） 、（ ） cout<<\

cout<

程序运行结果：

6、写程序（10分）

复习资料

（一） 填空题

在类体内使用关键字（ ）说明的成员称为静态成员。 2、重载的函数要求参数的（ ）和（ ）不同。 3、如果要表示某个变量的值不能修改，用修饰符（ ）限制。 4、对函数 int fun( int x，int y) 中的参数 x指定默认值10 正确的声明方式是（ ）。

5、C++语言规定，成员函数如果被定义在类体内，则为默认为（ ）。 6、在类层次结构中，创建子类对象时，（ ）构造函数最后被执行。 7、C++规定，动态联编通过（ ）和（ ）来实现。

8、派生类的生成过程经历了三个步骤： （ ）、（ ）和（ ）。

9、面向对象程序设计的4个基本特征是（ ）、（ ）、（ ）、( )。

10、Windows应用程序采用基于（ ）的事件驱动运行机制。 11、通常将用来派生新类的类称为（ ），又称为父类，而将派生出来的新类称为（ ），又称为子类。 12、含有（ ）函数的类称为抽象类。

13、引用与被引用的实体具有相同的（ ）。

14、类成员的访问权限有3种（ ）、（ ）、（ ）。

15、通过函数改变实参的数据，c++ 可以通过( )或者（ ）实现。

16、c++通过（ ）实现静态联编，其（ ）必须不同。 17、在类体内使用关键词（ ）说明的成员称为静态成员。 18、c++类的用途有两种，一种是生成类的对象，另一种是通过（ ）派生出新类。

19、在类Ctest的定义中，其拷贝构造函数的声明是（ ）。 20、抽象类必须有一个（ ）函数，并且不能产生自己的（ ）。 21、C++规定，动态联编通过多态性来实现，实现多态性的同名函数必须（ ）相同。

22、面向对象的模型中，最基本的概念是对象和( )。 23、软件设计模块化的目的是( )。

24、 派生类的成员一般分为两部分，一部分是( )，另一部分是自己定义的新成员。

25、 在函数参数传递中，解决大的对象传递效率，最好使用（ ）为参数 26、 如果要把返回值为void的函数A声明为类B的友元函数，则应在类B的定义中加入的语句是( )。

27、如果类B继承了类A，则称类A为类B的基类，类B称为类A的( ) 。

28、 将x+y中的+运算符用友元函数重载应写为( ) 29 在类层次结构中，创建子类对象时，（ ）构造函数最后被执行。 30、在多态性的实现中，在基类与派生类的虚函数除名字相同外，（ ）也必须相同。

31、用const定义的常量必须进行（ ）。 32、函数重载要求函数名相同，（ ）不同。 33、构造函数名必须与类名 （ ）

34、在面向对象的程序设计中，对象是指 ( ）和（ ）的封装体。

35、在函数参数传递中，解决大的对象传递效率，最好使用（ ）为函数参数

36、创建对象时系统自动调用（ ）函数。

37、用一个对象去构造同类的另一个新对象 需要调用( ）。 38、用new为对象动态分配内存，当程序完毕必须用（ ）释放。 39、类的每个普通成员函数都有一个隐含的this指针参数， this指针指向（ ）的对象。

40、设pt为T类的一个指针，pt=new T[10]操作 须调用（ ）次构造函数

（二）判断题（正确的请写T，错误的请写F）

1、引用作为函数参数在函数内可对被直接引用的变量进行操作。 2、函数的返回值类型不同可以重载。 3、同类对象间可以整体赋值。 4、类的构造函数可以重载。

5、C++中标识符内的大小写字母是没有区别的。 6、静态成员函数可以直接调用类中说明的非静态成员。 7、友元破坏了类的封装和隐蔽性。

8、在多继承时，在调用不同基类中的相同成员时可能出现二义性。 9、抽象类自身无法实例化。

10、析构函数由于没有参数，它不能被重载。

11、使用关键字class定义的类中缺省的访问权限是public。 12、光标、位图、对话框和菜单都是资源。

13、说明函数原型时不需要指明每个函数参数的名字，只需要说明每个参数的类型和返回值类型就可以了。

14、类的静态数据成员需要在定义每个类的对象时进行初始化。 15、字符串’hello,world”在内存中存放时，占用11个字节的空间。 16、构造函数的主要功能就是用来初始化对象。

17、用new运算符动态分配的存储空间若不用delete 释放，则程序运行结束后该空间会自动释放。

18、基类的私有成员函数根本就不会继承，更谈不上使用。 19、友元关系是单向的不可逆的。

20、this指针隐含于每一个成员函数中。

21基类的构造函数和析构函数是能被继承的。

22、如果一个类中，用户没有定义拷贝构造函数时，系统自动创建一个默认的拷贝构造函数。

23、析构函数由于没有参数，它不能被重载。 24、成员函数的参数不可以设置为默认值。

25、静态成员的特点是它不仅是属于某对象的，而是属于整个类的，即所有对象的。

26、友元关系是单向的不可逆的。 27、友元没有破坏类的封装和隐蔽性。

27、delete运算符的功能是用来释放使用new运算符申请的内存。

28、在私有继承方式下，基类中公有成员和保护成员在派生类中都为私有成员。 29、基类的私有成员函数可以被继承。

30、在多继承时，在调用不同基类中的相同成员时可能出现二义性。

31、联编是指计算机程序自身彼此关联的过程，也就是把一个标识符名和一个存储地址联系在一起的过程。

32、函数重载和运算符重载就是通过动态联编方式实现的编译时的多态的体现。 33、虚函数是动态联编的基础。 34、抽象类自身也可以实例化。

35、运算符重载之后运算符的优先级和结合性都会改变，并且要保持原运算符的语法结构。参数和返回值类型可以重新说明。

36、在程序能正确支持所设计的正常情况之后，再添加语句来处理异常情况，这种思想就是异常处理。

37、MFC是一个功能强大、结构复杂和庞大的类库。

38、C++支持多态性。 39、说明函数原型时不需要指明每个函数参数的名字，只需要说明每个参数的类型和返回值类型就可以了。

40、返回值类型、参数个数和类型都相同的函数也可以重载。 41、“引用”作为目标的别名而使用，对引用的改动实际就是对目标的改动。引

用不是值，不占存储空间，声明引用时，目标的存储状态不会改变。

42、使用关键字class定义的类中缺省的访问权限是私有（private）的。 43、一个抽象类至少具有一个纯虚函数。

44、类的静态数据成员需要在定义每个类的对象时进行初始化。

45、当将一个类S定义为另一个类A的友元类时，类S的所有成员函数都可以直接访问类A的所有成员。

46、当函数的返回值是数组类型的，传递的是数组第一个元素的地址。 47、构造函数可以声明为虚函数

（三）选择题

1、关于成员函数特征的下列描述中，（ ）是错误的。 A、成员函数一定是内联函数；B、成员函数可以重载；C、成员函数可以设置缺省参数值；D、成员函数可以是静态的。

2、void main(){char str[10]={'a','b','c'};cout<<*str;} 的输出为（ ）。 A、a； B、b； C、c； D、abc； E、以上都不是。 3、（ ）是析构函数的特征。

A、析构函数可以有一个或多个参数；B、析构函数名与类名不同；C、析构函数的定义只能在类体内。

4、C++语言中函数返回值的类型由（ ）决定。

A、return语句的表达式的类型；B、定义函数时所指明的返回值类型；C、实参类型； D、调用函数类型

5、int a=10; int *pa=&a; int &ia=a; *pa=20; ia=30;cout<

6、在一个函数中，要求通过函数来实现一种不太复杂的功能，并且要求加快执行速度，选用（ ）比较合适。

A、 内联函数； B、 重载函数； C、 递归调用； D、 嵌套调用。 7、void main(){char str[10]={'a','b','c'};cout<

A、静态数据成员不是属于某个对象，而是属于整个类的。

B、静态数据成员不随对象的创建而分配内存空间，它也不随对象被释放而撤销。只有在程序结束时才被系统释放。 C、静态数据成员只能在类体外被初始化 D、静态数据成员可以不初始化

9、void main(){char* str=\的输出为（ ）。

A、a； B、b； C、c； D、abc； E、以上都不是。 10、（ ）不是构造函数的特征。

A、构造函数的函数名与类名相同； B、构造函数可以重载； C、构造函数必须指定类型说明

11、下列关于C++语言类的描述中错误的是（ ）

A)类用于描述事物的属性和对事物的操作 B)类与类之间通过封装而具有明确的独立性

C)类与类之间必须是平等的关系，而不能组成层次结构

D)类与类之间可以通过一些方法进行通信和联络 12、 下面函数（ ）的表示方法说明它使用对象的引用作为参数。

A）test(pt *p) B）test(pt p) C） test(pt &p) D） test(const P)

13、以下叙述中正确的是（ ）

A)构成C++语言程序的基本单位是类 B)可以在一个函数中定义另一个函数

C) main()函数必须放在其他函数之前 D)所有被调用的函数一定要在调用之前进行定义 14、己知有定义：

const int D=5； int i=1；

double f=0.32； char c=15;

则下列选项错误的是 （ ） A) ++i; B) D--; C) C++; D)--f;

15、以下程序的输出结果是（ ） #include void reverse (int a[]，int n) { int i，t;

for(i=0;i

{t=a[i];a[i]=a[n-1-i];a[n-1-i]=t;} }

void main()

{ int b[10]={1,2,3,4,5,6,7,8,9,10};int i,s=0; reverse(b，8);

for(i=6;i<10;i++)s+=b[i]; cout<

A)22 B)10 C)34 D)30 16、（ ）不是构造函数的特征：

A）构造函数的函数名与类名相同； B）构造函数可以重载；

C）构造函数可以设置缺省参数； D）构造函数必须指定类型说明。

17、关于成员函数特征的下列描述中，（ ）是错误的。

A）成员函数一定是内联函数； B）成员函数可以重载；

C）成员函数可以设置缺省参数值； D）成员函数可以是静态的；

18、下列描述中，正确的是（ ）

A) 虚函数是一个static 类型的成员函数； B)虚函数是一个非成员函数； C) 抽象类是指具有纯虚函数的类；D)抽象类可以说明其对象； 19、友元的作用是（ ）。

A）提高程序的运用效率；B）加强类的封装性； C）实现数据的隐藏性； D）增加成员函数的种类；

20、下面程序的功能是把316表示为两个加数的和，使两个加数分别能被13和11整除，

在划线处应填入的选项是（ ） #include

void main()

{ int i=0，j，k;

do{i++;k=316-13*i;}while( ); j=k/11;

cout<<”316=13*”<

A)k/11 B)k% 11 C)k/11＝=0 D)k＝＝0

读程序写结果 1、

#include class Date {public:

Date(int y, int m, int d) {year=y;month=m;day=d; cout<<\ ~Date(){cout<<\ void Print() {cout<

int year, month, day;}; void main()

{ Date today(2011,1,20), *pd; pd=&today; today.Print();

today.SetDate(2008,4,10); (*pd).Print();

pd->SetDate(2012,1,23); 2、

#include class Point {

public:

Point(int x, int y)

{X=x; Y=y;cout<<\ Point(Point & p); ~Point()

{cout<<\ int Xcoord(){return X;} int Ycoord(){return Y;} private:

int X, Y;};

Point::Point(Point & p)

{X=p.X;Y=p.Y;

cout<<\} void main()

{ Point P1(5,7);

Point P2(P1);

cout<<\

3、#include class M {public:

M(int x,int y){ X=x; Y=y;} M(int x){ X=x; Y=x*x;} int Add(int x,int y=10); int Add();

int Xout() { return X;} int Yout() { return Y;} private: int X,Y; };

int M::Add(int x,int y){ X=x;Y=y;return X+Y;} int M::Add(){return X+Y;}

void main() {

M a(1,2),b(4);

today.Print();} cout<<\ cout<<\ int i=a.Add();

int j=a.Add(35,20); int k=b.Add(5);

cout<

4、

#include class Myclass {public:

Myclass(int a,int b,int c); void GetNumber(); void GetSum(); private:

int A,B,C;

static int Sum;};

int Myclass::Sum=0;

Myclass::Myclass(int a,int b,int c)

{A=a;B=b;C=c;Sum+=A+B+C;} void Myclass::GetNumber()

{cout<<\ void Myclass::GetSum()

{cout<<\void main()

{ Myclass M(4,9,11),N(11,8,12); M.GetNumber(); N.GetNumber(); M.GetSum();

Myclass P(5,5,8); P.GetSum();

N.GetSum();} 5、

#include #include class student

{char* classname;

public:

student(char* pclassname)

{classname=pclassname;cout<<\构造\~student(){cout<<\析构\};

class teacher {char* dpt; public:

teacher(char* pdpt)

{ dpt=pdpt;cout<<\构造\~teacher(){cout<<\析构\};

class GraduateStudent:public student,public teacher {char* major; public:

GraduateStudent(char* pclassname,char* pdpt,char* pmajor): student(pclassname),teacher(pdpt)

{ major =pmajor;cout<<\构造\};

void main()

{GraduateStudent g(\通信系\数学\ 6、

#include class Base1 {public: Base1(int i)

{b1=i;cout<<\ ~Base1(){cout<<\void print(){ cout<

int b1;}; class Base2 {public:

Base2(int i)

{b2=i;cout<<\~Base2(){cout<<\ void print(){ cout<

int b2;};

class A:public Base2,public Base1 {public:

A(int i,int j,int l):Base1(i),Base2(j)

{a=l;cout<<\ void print()

{ Base1::print(); Base2::print();cout<

{A aa(1,2,3);} 7、

#include class A {public:

A(const char *s){ cout<

class B:virtual public A {public:

B(const char *s1,const char *s2):A(s1) {cout<

class C:virtual public A {public:

C(const char *s1,const char *s2):A(s1) { cout<

class D:public B,public C {public:

D(const char *s1,const char *s2,const char *s3,const char *s4) :B(s1,s2),C(s1,s3),A(s1) { cout<

void main()

{ D *ptr=new D(\ delete ptr; }

8、

#include class Student

{public:

virtual void print()

{cout<<\};

class GStudent:public Student {public:

virtual void print()

{cout<<\};

void main() {

Student s1,s2,*ps;GStudent g; g.print(); ps=&s1; ps->print(); ps=&g;

ps->print(); Student &ig=g; ig.print (); s2=g; s2.print(); } 9、

#include class Date {

public:

Date(int y, int m, int d); ~Date(); void Print();

void SetDate(int py, int pm, int pd); private:

int year, month, day; };

Date::Date(int y, int m, int d) {

year=y; month=m;

day=d;

cout<<\}

Date::~Date()

{cout<<\void Date::Print()

{cout<

void main() {

Date today(1998,4,9), *pd; pd=&today;

cout<<\ today.Print();

today.SetDate(1998,4,10); cout<<\ (*pd).Print();

pd->SetDate(2009,10,1); cout<<\ today.Print(); } 10、

#include class A {public:

A(){a=0; cout<<\ A(int i){a=i; cout<<\ ~A(){ cout<<\ void Print() const { cout<

class B:public A {public:

B(){ b=0;cout<<\′s default constructor called.\ B(int i,int j,int k);

~B(){ cout<<\′s destructor called.\ void Print(); private:int b;};

B::B(int i,int j,int k):A(i)

{b=k;cout<<\′s constructor called.\void B::Print()

{A::Print();cout<

#include class Base1 {public: Base1(int i)

{b1=i;cout<<\ ~Base1(){cout<<\void print(){ cout<

int b1;}; class Base2 {public:

Base2(int i)

{b2=i;cout<<\~Base2(){cout<<\ void print(){ cout<

int b2;};

class A:public Base2,public Base1 {public:

A(int i,int j,int l):Base1(i),Base2(j)

{a=l;cout<<\ void print()

{ Base1::print(); Base2::print();cout<

#include class A {public:

A(const char *s){ cout<

class B:virtual public A //⑧ {public:

B(const char *s1,const char *s2):A(s1) {cout<

class C:virtual public A {public:

C(const char *s1,const char *s2):A(s1) { cout<

class D:public B,public C {public:

D(const char *s1,const char *s2,const char *s3,const char *s4) :B(s1,s2),C(s1,s3),A(s1) { cout<

void main()

{ D *ptr=new D(\ delete ptr; 13、

#include class point {public:

point(int i=0,int j=0){ x0=i;y0=j;}

void draw(){ cout<<\∷draw() called.\ virtual void set(){ cout<<\∷set() called.\ //⑨ protected: int x0,y0; };

class line: public point {public:

line(int i=0,int j=0,int m=0,int n=0):point(i,j) { x1=m;y1=n;}

void set(){ cout<<\∷set() called.\ void draw(){ cout<<\∷draw() called.\ protected: int x1,y1; };

void drawobj(point *p){p->draw();} // ⑩ void setobj(point *p){p->set();} void main()

{ point *poiobj=new point; line *lineobj=new line; drawobj(lineobj); setobj(lineobj); setobj(poiobj); poiobj->set(); (*lineobj).draw();

14、

#include class A{ protected: int x; public: A(){}

A(int x1) { x=x1; cout<<”x=”<

~A(){ cout<<”out class A! ”<

};

class B { protected: int y; public:

B(int y1) { y=y1; cout<<”y=”<

}; 15、

＃include

class Base{ protected: int x,y;

public: Base(int x1=0,int y1=0) {x=x1;y=y1;}

virtual void display()=0;

};

class Sub1:public Base { protected: float z;

public: sub1(int x2,int y2 ,float z1) :Base(x2,y2){ z=z1;}

virtual void display()

{ cout<<”x=”<

};

class Sub2:public Base { protected: char ch;

public: sub2(int x2,int y2 ,char ch1) :Base(x2,y2){ ch=ch1;}

virtual void display()

{ cout<<”x=”<

};

class Sub11:public Sub1 { protected: float w;

public: sub11(int x3,int y3 ,float z2,float w1) :Sub1(x3,y3,z2){ w=w1;}

virtual void display()

{ Sub1::display();cout<<”w=”<

};

void fn(Base &s) { s.display();}

main(){ Sub1 a(1,2,3.0),Sub2 b(1,2 ,‘c’),Sub11 c(1,2,3.0,4.0);

fn(a);fn(b);fn(c);}

据以下要求写程序。

1、 基类：Person，数据成员：姓名 name；成员函数：display（）。

由基类派生Student和Teacher类。

Student类，数据成员：班级，classname；成员函数：display（）。 Teacher类，数据成员：部门，dpt；成员函数：display（）。 由Student和Teacher类派生Graduatestudent。

Graduatestudent类，数据成员：主攻方向，major；成员函数：display（）。 实例化一个Graduatestudent对象，并能显示其信息。 （请注意对同名成员的处理）

2、

两个基类：演员类，器械类。一个派生类：杂技类。（这三个类均要求有构造函数）

演员类要求有演员的名字，器械类要求有器械的名字（如：钢丝、盘子等），杂技类要求有杂技节目名称（如空中走钢丝）。

程序能够输出杂技节目名称，演员名字及所用器械。

3、定义一个类，使得在该类的构造函数和析构函数中各输出一行文本，且构造函数能完成该类的部分数据成员的赋值。在主函数中调用该类的一个成员函数,来输出该类的一个数据成员。

4、计算图形面积，声明一个Shape（形状）基类，它有三个派生类——Circle（圆）和Square（正方形），三角形（Triangle）

已知 (1)圆的半径r,（2）矩形的长a、宽b ，(3) 三角形的三个边 a、b、c 要求利用多态性（纯虚函数、抽象类）计算上述三种任何一种图形的面积

5、复数类程序设计。

6、多继承、虚基类、多态(多看例题,课本+讲义)

本文来源：https://www.bwwdw.com/article/1lpd.html