今天备考C++，看到了一些好的复习资料，整合一起给大家分享一下
一起来交流编程吧【CSDN app】：
http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=x9pL9ccIHGKNLE0CWviAqQ_q6HzxomLW&authKey=VslKe623ptw8VRepda%2Bh0Ttr8Ruz8v%2FBW5HpVzyTWU7ECwpHIZpULMj6qIHYZBVb&noverify=0&gro
A. 常数据成员必须被初始化，并且不能被修改
B. 常数据成员可以不初始化，并且不能被修改
C. 常数据成员可以不初始化，并且可以被修改
D. 常数据成员必须被初始化，并且可以被修改
A. ios B. ifstream C. ofstream D. istrstream
A. 只要是编程者认为是异常的都可当异常抛出
B. 硬件故障也可当异常抛出
C. 运行错属于异常
D. 编译错属于异常，可以抛出
A. 封装性 B. 消息性 C. 继承性 D. 多态性
A. 一个类是一个独立的域
B. 派生类域被自动嵌套在基类类域中
C. 域操作符::可以被重载
D. 不同域中可以定义同名变量和函数
A. inta; int &p = a;
B. chara; char *p = &a;
C. inta; int &p; p = a;
D. floata; float p=a;
A. 基类的对象可以赋值派生类的对象
B. 派生类指针可以指向基类对象
C. 派生类的对象可以初始化基类的对象
D. 派生类的对象的地址可以赋值给指向基类的指针
A.构造函数的函数名与类名相同
B.构造函数可以重载
C.构造函数可以设置默认参数
D.构造函数必须指定返回类型
A. 虚函数是一个static类型的成员函数
B. 虚函数是一个友元函数
C. 基类中说明了虚函数后，派生类中与其对应的函数必须再次说明为虚函数
D. 派生类的虚函数与基类的虚函数具有相同的参数个数和类型
A. 类中定义的公用静态数据成员，可以通过类的对象来访问
B. 类中定义的所有静态数据成员，都必须在类外初始化
C. 静态数据成员不是所有对象所共用的
D. 普通的成员函数可以直接访问类中的静态数据成员
A. 运算符重载可以改变操作数的个数
B. 运算符重载可以改变优先级
C. 运算符重载可以改变结合性
D. 运算符重载不可以改变语法结构
A. 内联函数可以提高程序效率
B. 内联函数的调用过程与普通函数一样
C. 只要用 inline 关键字声明的函数都是内联函数
D. 全局函数不能声明为内联函数
A. ->
B. *
C. %
D. ?:
A. int fun (char*, int)
B. void fun (char*)
C. int fun (int)
D. void fun (char*, int)
A. ①②③ B. ②①③ C. ③②① D. ②③①
A. ①③③②②② B. ①③②②
C. ①②③② D. ①②③③②②
A. 私有成员 B. 公有成员
C. 保护成员 D. 保护成员或私有成员
A. 函数体 B. 对象 C. 类 D. 数据块
A. 可以通过运算符重载来创建C++中原来没有的运算符
B. 在类型转换函数的定义中不需要声明返回类型
C. 运算符函数的返回类型不能声明为基本数据类型
D. C++已有的任何运算符都可以重载
A. 说明静态数据成员时前边要加修饰符static
B. 静态数据成员要在类体外进行初始化
C. 静态数据成员不是所有对象所共有的
D. 初始化静态数据成员时，要在其名称前加类名和作用域运算符
A.public B.protected C.private D.static
A. 在类中，不作特别说明的数据成员均为私有类型
B. 在类中，不作特别说明的数据成员均为公有类型
C. 类成员的定义必须是成员变量定义在前，成员函数定义在后
D. 类的成员定义必须放在类定义体内部
A. 函数的返回值是类的对象，函数执行返回调用时
B. 函数的形参是类的对象，调用函数进行形参和实参相结合
C. 将类的一个对象赋值给该类的另一个对象时
D. 用一个对象去初始化同一类的另一个新对象时
A. 抽象类不能定义对象
B. 其派生类没有定义纯虚函数，则仍是抽象类。”
C. 其派生类定义所有纯虚函数，则是具体类
D. 不能定义指向抽象类的指针变量
A. 通过常对象只能调用其常成员函数
B. 常成员函数只能由常对象调用
C.通 过常成员函数可以修改常成员数据的值
D. 常成员函数可以通过类名来调用
A. 成员函数一定是内联函数
B. 成员函数可以重载
C. 成员函数可以设置缺省参数值
D. 成员函数可以是静态的
A. 如果在类A中把类B的某个函数声明为自己的友元函数，那么在类A的定义之前一定要有类B的完整定义
B. 如果在类A中把类B声明为自己的友元类，那么在类A的定义之前可以仅有类B的前向声明，而不必有类B的完整定义
C. 如果将类B声明为类A的友元，那么类A也就成为类B的友元
D. 如果将类B声明为类A的友元，那么类B中的函数可以访问类A的全部成员
A.用于输出操作的成员函数
B.用于输入操作的成员函数
C.用于输入操作的非成员函数
D.用于输出操作的非成员函数
A. ‘\105’ B. ‘*’ C. “” D. ‘\n’
A. 静态数据成员是类的所有对象共享的数据
B. 类的每个对象都有自己的静态数据成员
C. 类的不同对象有不同的静态数据成员
D. 静态数据成员不能通过类的对象调用
A. 类A有不带参数的构造函数，且构造函数被调用10次
B. 类A有拷贝构造函数，且拷贝构造函数被调用10次
C. 类A有这样的构造函数，其每个参数都有默认的形参值，且该构造函数被调用10次
D. A和C皆有可能。
A. 将基类的构造函数声明为虚函数
B. 将基类的析构函数声明为虚函数
C. 将派生类的构造函数声明为虚函数
D. 将派生类的析构函数声明为纯虚函数
A. static object a;
B. object a;
C. static object *pa;
D. object* pa;
A. operator > (obj1,obj2)
B. > (obj1,obj2)
C. obj2.operator > (obj1)
D. obj1.operator > (obj2)
A. 如果类A是类B的友元，则类B也是类A的友元
B. 如果函数fun()被说明为类A的友元，那么在fun()中可以访问类A的私有成员
C. 友元关系不能被继承
D. 如果类A是类B的友元，那么类A的所有成员函数都是类B的友元
A. 封装性
B. 消息性
C. 维护性
D. 动态性
A. public
B. protected
C. private
D. virtual
A.虚函数可以是一个static类型的成员函数
B.虚函数可以是非成员函数
C.基类中说明了虚函数后，派生类中其对应的函数可以不必说明为虚函数
D.派生类的虚函数与基类的虚函数具有不同的参数个数和类型
A. 保证基类共有成员在子类中可以被访问
B. 保证基类保护成员在子类中可以被访问
C. 保证每个对象拥有自己的数据成员，但共享处理这些数据成员的代码
D. 保证基类私有成员在子类中可以被访问
A.virtual int vf (int);
B.void vf (int) = 0;
C.virtual void vf () = 0;
D.virtual void vf (int) {}
A. 类模板
B. 函数模板
C. 函数重载
D. 虚函数
A. cplus
B. news
C. std
D. namespace
下列关于这个函数的叙述中，错误的是【 B 】
A. 这是运算符-的重载运算符函数
B. 这个函数所重载的运算符是一个一元运算符
C. 这是一个成员函数
D. 这个函数不改变类的任何数据成员的值
A. void AA(int); B. int AA();
C. AA(int)const; D. AA(int);
A. virtual B. public
C. include D. using namespace
A. 重载函数 B. 构造函数
C. 析构函数 D.虚函数
A. 对象指针 B. 成员名限定
C. 对象名 D. 派生类名
A. virtual int vf(int); B. void vf(int)=0;\n\n C. virtual void vf()=0; D. virtual void vf(int)
A. 2、2 B. 2、1 C. 1、2 D. 1、1
A. 私有成员 B. 保护成员
C. 所有成员 D. 公有成员
A. C兼容C++
B. C++兼容C
C. C++不兼容C
D.C++部分兼容C
A. 基类的公有成员和保护成员被继承后作为派生类的公有成员和保护成员
B. 派生类的其他成员可以直接访问基类的公有成员和保护成员
C. 派生类成员和对象都无法访问基类的私有成员
D. 派生类的对象可以访问基类的私有成员
A.它可以用来动态创建对象和对象数组
B.使用它创建的对象或对象数组可以使用运算符delete删除
C.使用它创建对象时要调用构造函数
D.使用它创建数组时必须指定初始值
A. 对数据的操作 B. 信息
C. 数据隐藏 D. 数据抽象
A. public B. extern C. cpu D. register
A. 类用于描述事物的属性和对事物的操作
B. 类与类之间通过封装而具有明确的独立性
C. 类与类之间必须是平等的关系，而不能组成层次结构
D. 类与类之间必须是平等的关系，而不能组成层次结
A. 类是抽象数据类型的实现
B. 类是具有共同行为的若干对象的统一描述体
C.类是创建对象的模板
D. 类就是C语言中的结构体类型
A. 标识作用域的级别
B. 指出其大小
C. 标识某个成员是属于哪一个类
D. 给出的范围
A. 在一定条件下函数模板的实参可以省略
B. 类模板不能有数据成员
C. 在模板声明中用< >括起来的部分是模板的形参表
D. 模板声明中的第一个符号总是关键字template
A. 每个函数都必须有参数
B. 每个函数都必须返回一个值
C. 函数在被调用之前可以不先声明
D. 函数可以自己调用自己
A. int Fun(int x, int y=2, int z=3);
B. int Fun(int x=1, int y, int z);
C. int Fun(int x=1, int y, int z=3);
D. int Fun(int x, int y=2, int z);
A. a1.f B. a1.f() C. a1->f() D.（a1）.f ()
A. 通过运算符重载，可以定义新的运算符
B.有的运算符只能作为成员函数重载
C. 若重载运算符+，则相应的运算符函数名是+
D. 重载二元运算符时，必须声明两个形参\n\n
A. x.a B.x.a() C.x->a D. x->a()
A. 构造函数是一种成员函数，它具有一般成员函数的特点
B. 构造函数必须指明其类型
C. 构造函数的名称与其类名相同
D. 一个类中可以定义一个或多个构造函数
A. X,Y；Y,X B. X,Y；X,Y
C. Y,X；X,Y D. Y,X；Y,X
A. free B. release C. delete D. malloc
A. catch（…）语句可捕获所有类型的异常
B．一个try语句可以有多个catch语句
C．catch（…）语句可以放在catch语句组的中间
D．程序中try语句与catch语句是一个整体，缺一不可
A. 类 B. 函数 C. 对象 D. 数据块
A. 结构体一般只有数据成员，通常不会加入函数方法
B. 类一般只有函数方法，通常不会包含数据成员
C. 类的成员默认都是私有的
D. 结构体的成员默认都是公开的
A.成员函数时 B.数据成员时
C.对象时 D.友元函数时
A. 保证每个对象拥有自己的数据成员，但共享处理这些数据的代码
B. 保证基类私有成员在子类中可以被访问。
C. 保证基类保护成员在子类中可以被访问。
D. 保证基类公有成员在子类中可以被访问。
A. 静态数据成员可以在类体内进行初始化
B. 静态数据成员不可以被类的对象调用
C. 静态数据成员可以直接用类名调用
D. 静态数据成员不能受private控制符的作用
A. 友元函数的实现必须在类的内部定义
B. 友元函数是类的成员函数
C. 在类中必须用friend声明友元函数
D.友元函数不能访问类的私有成员
A. 类B也一定是类A的友元
B. 类B的成员即类A的成员
C. 类A的成员即类B的成员
D. 类A的成员函数可以访问类B的成员
A. C++语言的多态性分为编译时的多态性和运行时的多态性
B. 编译时的多态性可通过函数重载实现
C. 运行时的多态性可通过模板和虚函数实现
D. 实现运行时多态性的机制称为动态多态性
A. 派生类是基类的具体化
B. 基类继承了派生类的属性
C. 派生类是基类定义的延续
D. 派生类是基类的特殊化
A. 不同的对象调用不同名称的函数
B. 不同的对象调用相同名称的函数
C. 一个对象调用相同名称的函数
D. 一个对象调用不同名称的对象
A. cout.open(“C:\vc\abc.txt”,ios::binary);
B. ifstream ifile (“C:\vc\abc.txt”);
C. fstream iofile;iofile.open(“abc.txt”,ios::ate);
D. ofstream ofile; ofile.open(“C:\vc\abc.txt”,ios::binary);
A. 析构函数和构造函数一样可以有形参
B. 析构函数名前必须冠有符号“~”
C. 析构函数不允许用返回值
D. 在一个类只能定义一个析构函数
A. 构造函数不能重载，析构函数可以重载
B. 构造函数可以重载，析构函数不能重载
C. 构造函数可以重载，析构函数也可以重载
D. 构造函数不能重载，析构函数也不能重载
A. virtual void draw();
B. virtual void draw() = 0;
C. virtual void draw(){}
D. void draw() = 0;
A. 每个函数至少要具有一个参数
B. 每个函数都必须返回一个值
C. 函数在被调用之前必须先声明
D.函数不能自己调用自己
A. 一个类只能有一个对象
B. 对象是类的具体实例
C. 类是对某一类对象的抽象
D. 类和对象的关系是一种数据类型与变量的关系
A. 有参构造函数 B. 无参构造函数
C.拷贝构造函数 D. 赋值构造函数
A. 本类对象名 B. 本类对象的指针名
C. 本类对象的成员名 D. 本类对象的引用名
A. 构造函数 B. 友元函数
C. 析构函数 D. 拷贝构造函数
A. 公用继承时基类中的private成员在派生类中仍是private的
B. 公用继承时基类中的public成员在派生类中仍是public的
C. 公用继承时基类中的protected成员在派生类中仍是protected的
D. 私有继承时基类中的public成员在派生类中是private的
A. fun(1); B. fun(1,2);
C. fun( ); D. fun(1,2,‘a’);
A. 类 B. 对象 C. 包含文件 D. 常量
A.虚基类 B.虚函数 C.函数重载 D.名称空间
A. 一个命名空间对应多个命名作用域
B. 一个命名空间中的标识符命名作用域相同
C. 一个命名空间中可以集合很多不同的标识符
D. 命名空间的引入让程序员可以在不同的模块中使用相同名字表示不同事物
A. static B. public C. const D.inline
A. 重载函数必须具有不同的返回值类型
B. 重载函数形参个数必须不同
C. 重载函数必须有不同的形参列表
D. 重载函数名可以不同
A.派生类是基类的具体化
B.基类继承了派生类的属性
C.派生类是基类定义的延续
D.派生类是基类的特殊化
A. 一个派生类的两个基类中都有某个同名成员，派生类中这个成员的访问可能出现二义性。
B. 基类和派生类中同时出现的同名函数，也存在二义性问题。
C. 解决二义性的最常用的方法是对成员名的限定法
D. 一个派生类是从两个基类派生出来的，而这两个基类又有一个共同的基类，对该基类成员进行访问时，可能出现二义性。
A. 类是一种用户自定义的数据类型
B. 只有类中的成员函数或类的友元函数才能存取类中的私有成员
C. 在类中，如果不做特别说明，所有成员的访问权限均为私有的
D. 在类中，如果不做特别说明，所有成员的访问权限均为公用的
A. public B. protected C. private D. static
A. 说明为公有的成员可以被程序中的任何代码访问
B. 说明为私有的成员只能被类的成员和说明为友元类的成员函数访问
C. 说明为保护的成员,除了能被本身的成员函数和说明为友元类的成员函数访问外,该类的派生类的成员也可以访问
D. 类的所有成员都可以被程序中的任何代码访问
构造函数、析构函数能被继承或取地址（×）
构造函数可以重载，但析构函数只有一个（√）
返回值类型为引用类型的函数可以返回局部变量（×）
静态成员函数没有this指针（√）
静态成员函数可以直接访问非静态成员变量（×）
//由于静态成员函数没有this指针，所以不能直接访问非静态成员变量，必须通过向函数传递当前对象作为参数才可以访问当前对象的成员变量
const类型的变量声明时可以不用初始化（×）
const类型的对象只能访问const类型的成员函数，构造函数、析构函数除外（√）
const类型的对象如果作为实参，只能传递给const类型的形参（√）
volatile类型的对象只能访问volatile类型的成员函数，构造函数、析构函数除外（√）
复合类调用构造函数时，成员对象的构造函数调用顺序取决于复合类的构造函数初始化列表（×）
//成员对象的构造函数调用顺序取决于其在复合类的声明顺序
作为友元的类或类的函数，必须先声明后使用（√）
友元关系可以继承（×）
//友元关系不继承、不传递、不对称
//重载函数可以在参数个数、参数类型、是否为const类型上有不同，但如果只有返回值类型不同，则调用函数时有歧义
可以重载C++中不存在的运算符（×）
运算符重载可以改变优先级（×）
运算符重载不改变操作数个数（√）
不能重载的运算符有 ？: :: . # ## .* ->* *
返回值为临时对象的重载运算符有 后缀++ 后缀-- + - * / %
返回值为引用类型的重载运算符有 前缀++ 前缀-- = [] () << >>
必须以友元方式重载的运算符有 << >>
必须以成员函数方式重载的运算符有 = [] () ->
派生类对象可用在基类对象使用的任何场合，如派生类对象可以赋值给基类对象、基类指针或基类引用，但此时这一基类的对象、指针或引用只能访问基类成员
复合类或派生类的定义前需要包含成员对象所在类或基类的定义
派生类构造函数的执行顺序：基类的构造函数（都为或都不为虚基类时按继承时声明的顺序）-> 内嵌成员对象的构造函数（按成员对象在类中声明的顺序）-> 自身类的构造函数
派生类对象在调用其基类的构造函数时，若其有多个在同一层次上的基类，则虚基类的构造先于非虚基类的构造
派生类和基类的虚函数原型可以不一致（×）
//如果仅是同名，则只是普通重载；如果仅是返回值类型不同，则程序会出错
//静态函数、内联函数、构造函数不可以是虚函数
在普通函数调用虚函数时，实际调用的是this指针指向的对象所在类的虚函数（√）
在基类的构造函数或析构函数中调用虚函数，调用的是基类的虚函数（√）
虚特性不可以继承（×）
实现多态的两种方式：重载、虚函数
纯虚函数是空函数（×）
函数调用的匹配原则：
① 寻找完全匹配的函数
② 函数模板实例化后匹配
③ 重载函数参数隐式类型转化后匹配
④ 在上述某一步找到两个及以上匹配的函数或三步都找不到匹配的函数时，则程序出错
//主动调用析构函数后，程序最终还会再次调用析构函数
//友元函数的定义可以在类内或类外
静态成员函数的定义在类外时，需要加上static关键字（×）
在类中定义的函数是内联函数（√）
//类中的内联函数实现有两种方式，一种是在类中进行定义；另一种是在类外进行定义，函数定义前加上incline关键字。注意第二种方式的函数定义需要放在头文件
定义引用类型的变量时必须初始化（√）
在调用派生类的拷贝构造函数时，其基类的构造函数不会被调用（×）
40.在异常处理机制中，throw的变量一定会被catch（×）
下面程序的运行结果是____
#include
using namespace std;
class Base
{public:
Base(){ cout << “0”; }
};
Class Base1: virtual Base
{public:
Base1(){ cout << “1”; }
};
Class Base2: virtual Base
{public:
Base2(){ cout << “2”; }
};
class Derived: public Base1, public Base2
{public:
Derived(){ cout << “3”; }
};
void main()
{ Derived obj;
}
A. 0123 B. 3120 C. 0312 D. 3012
答案：A
#include
using namespace std;
int i = 0;
void fun()
{
{
static int i = 1;
std::cout << i++ << ',';
}
std::cout << i << ',';
}
int main()
{
fun(); fun();
return 0;
}
答案：1,0,2,0,
下列程序中画线处应填如的语句是____
class Base
{public:
void fun(){ cout << “Base of fun” << endl; }
};
class Derived: public Base
{public:
void fun()
{
______ //调用基类的成员函数fun()
cout << "Derived of fun" << endl;
}
};
A. fun(); B. Base.fun();
C. Base::fun(); D. Base->fun() ;
答案：C
#include
using namespace std;
class Base
{public:
int x;
void Print(){ cout << "Base::x is " << x << endl; }
};
class Derived1: public Base
{public:
void Print()
{ cout << "Derived1::x is " << x << endl;
}
};
class Derived2: private Base
{public:
Derived2(){ Base::x = 4; }
int x;
void Print()
{ cout << "Derived2’s Base::x is " << Base::x << endl;
cout << "Derived2::x is " << x << endl;
}
};
void main()
{ Base objB;
Derived1 objD1;
Derived2 objD2;
objD2.x = 1 + (objD1.x = 1 + (objB.x = 1));
objB.Print();
objD1.Print();
objD2.Print();
}
答案：Base::x is 1
Derived1::x is 2
Derived2’s Base::x is 4
Derived2::x is 3
写出程序运行结果
#include
using namespace std;
class A
{public:
A(){ cout << "constructor of A" << endl; }
~A(){ cout << "destructor of A" << endl; }
};
class B
{public:
B(){ cout << "constructor of B" << endl; }
~B(){ cout << "destructor of B" << endl; }
};
int main()
{ B b;
static A a;
}
答案：constructor of B
constructor of A
constructor of B
constructor of A
写出程序运行结果
#include
using namespace std;
class Coord
{public:
Coord(int i = 0, int j = 0){ x = i; y = j; }
void Print(){ cout << “x=” << x << “, y=” << y << endl; }
friend Coord operator++(Coord op);
private:
int x, y;
};
Coord operator ++(Coord op)
{ ++op.x;
++op.y;
return op;
}
void main()
{ Coord obj(1, 2);
obj.Print();
++obj;
obj.Print();
}
答案：x = 1, y = 2
x = 1, y = 2
#include
using namespace std;
class Expt{};
class Expt1: public Expt{
public: Expt1() { cout<<“Expt1 的构造函数被调用。”<<endl; }
Expt1(Expt1 & e) {cout<<“Expt1 的拷贝构造函数被调用。”<<endl; }
~Expt1() { cout<<“Expt1 的析构函数被调用。”<<endl; }
};
class Expt2: public Expt1 {
public: Expt2() { cout<<“Expt2 的构造函数被调用。”<<endl; }
Expt2(Expt2 & e) { cout<<“Expt2 的拷贝构造函数被调用。”<<endl; }
~Expt2() { cout<<“Expt2 的析构函数被调用。”<<endl; }
};
void MyFunc() { Expt1 e; throw e; }
void main() {
try {
cout << "在try块中，调用MyFunc()。" << endl;
MyFunc();
cout << "在try块中，MyFunc()执行结束。" << endl;
}
catch( Expt E ) { cout << "捕获到Expt类型异常。"<<endl; }
catch( Expt2 E ) { cout << “捕获到Expt2类型异常。”<<endl; }
cout << "回到main函数。" << endl;
}
答案：在try块中，调用MyFunc()。
Expt1 的构造函数被调用。
Expt1 的拷贝构造函数被调用。
Expt1 的析构函数被调用。
捕获到Expt类型异常。
Expt1 的析构函数被调用。
回到main函数。
下面的程序有什么错误？
class MyClass
{
public:
void MyClass(int a){ x = a; }
int f(int a, int b){ x = a; y = b; }
int f(int a, int b, int c = 0){ x = a; y = b; z = c; }
static void g(){ x = 10; };
private:
int x, y, z;
};
答案：构造函数不能有返回值和返回值类型；静态函数g不能直接访问非静态数据成员x。
#include
using namespace std;
class Shape{
public:
Shape() { cout<<“Shape 的构造函数被调用。”<<endl; }
void Display() { cout<<“Shape 的显示函数被调用。”<<endl; }
virtual ~Shape() { cout<<“Shape 的析构函数被调用。”<<endl; }
};
class Rectangle: public Shape {
public: Rectangle () {
Side=Hight=0;
cout<<“Rectangle 的默认构造函数被调用。”<<endl;
}
Rectangle(int xx,int yy) {
Side=xx; Hight=yy;
cout<< “Rectangle 的构造函数被调用。”<<endl;
}
void Display() {
cout<<" Rectangle 的边长和高为：“<<Side<<”,"<<Hight<<endl;
}
~Rectangle() { cout<<"Rectangle 的析构函数被调用。"<<endl; }
int GetSide() {return Side;}
int GetHight() {return Hight;}
private:
int Side, Hight;
};
void main()
{
Shape *ptr1 = new Rectangle[2];
(*(ptr1+1)).Display();
delete [] ptr1;
}
答案：Shape的构造函数被调用。
Rectangle的默认构造函数被调用。
Shape的构造函数被调用。
Rectangle的默认构造函数被调用。
Shape的显示函数被调用。
Rectangle的析构函数被调用。
Shape的析构函数被调用。
Rectangle的析构函数被调用。
Shape的析构函数被调用。
#include
using namespace std;
template
class Sample
{private:
T n;
public:
Sample(T i){ n = i; }
void operator++();
void disp(){ cout << "n = " << n << endl; }
};
template
void Sample::operator++()
{ n += 1;
}
void main()
{ Sample s(‘a’);
s++;
s.disp();
}
答案：n = b
#include
using namespace std;
char* increase(char* ch) {return ++ch;}
char& increase(char& ch) {return ++ch;}
int main(){
char buf[16] = “IloveC++!”;
char* p = buf;
for (int i = 0; i < 4; i++) {
p = increase§;
increase(*p);
}
cout << buf << endl;
return 0;
}
答案：ImpwfC++!
#include
using namespace std;
class Sample
{
public:
int x, y;
Sample(int a = 0, int b = 0){ x = a; y = b; }
friend void square_x(Sample &s){ s.x = s.x * s.x; }
void disp(){ cout << "x = " << x << ", y = " << y << endl; }
};
void main()
{
Sample s(2, 3);
square_x(s);
s.disp();
}
答案：x = 4, y = 3
#include
using namespace std;
class A
{
int num;
public:
A(int i){ num = i; }
A(A &a){ num = a.num++; }
void print(){ cout << num; }
};
void main()
{
A a(1), b(a);
a.print();
b.print();
}
答案：21
#include
using namespace std;
class Base
{public:
int n;
Base(int x){ n = x; }
virtual void set(int m){ n = m; cout << n << ' '; }
};
class DerivedA: public Base
{public:
DerivedA(int x): Base(x){ }
void set(int m){ n += m; cout << n << ’ '; }
};
class DerivedB: public Base
{public:
DerivedB(int x): Base(x){ }
void set(int m){ n += m; cout << n << ’ '; }
};
int main()
{ DerivedA da(1);
DerivedB db(3);
Base * pBase;
pBase = &da;
pBase->set(1);
pBase = &db;
pBase->set(2);
}
答案：2 5
#include
using namespace std ;
class Base
{public:
virtual void fun(int a) { cout << "Base: " << a << endl; }
void fun(char *p) { cout << "Base: " << p << endl; }
void fun() { cout << “Base: no parameter!” << endl; }
};
class Derived: public Base
{public:
void fun(int a) { cout << “Derived:” << a << endl; }
void fun(char *p) { cout << “Derived:” << p << endl; }
};
void main()
{ Derived* pd = new Derived;
Base *pb = pd;
pb->fun(); pb->fun(0); pb->fun(“c++”);
pd->fun(1); pd->fun(“object”);
}
答案：Base: no parameter!
Derived:0
Base: c++
Derived:1
Derived:object
#include
using namespace std;
class Sample
{
public:
int x, y;
Sample(int a = 0, int b = 0){ x = a; y = b; }
~Sample(){ cout << "x = " << x << ", y = " << y << endl; }
};
void main()
{
Sample s;
s.~Sample();
}
答案：x = 0, y = 0
x = 0, y = 0
#include
Using namespace std;
class First
{protected:
int first;
public:
First(int f = 0){ first = f; }
void show(){ cout << first << endl; }
};
class Second: public First
{private:
int second;
public:
Second(int f, int s): First(f), second(s) { }
void show(){ cout << first << " " << second << endl; }
};
int main()
{
Second s(5, 3);
s.show();
}
A. 5 3 B. 3 C. 5 D. 3 5
答案：A
#include
using namespace std;
class Base
{int n;
public:
Base(int a)
{ cout << "constructing base class" << endl;
n = a;
cout << "n = " << n << endl;
}
~Base(){ cout << "destructing base class" << endl; }
};
class Derived: public Base
{ Base base;
int m;
public:
Derived(int a, int b, int c) : Base(a), base(c)
{ cout << "constructing derived class" << endl;
m = b;
cout << "m = " << m << endl;
}
~Derived(){ cout << "destructing derived class" << endl; }
};
void main(){ Derived d(1, 2, 3); }
答案：constructing base class
n = 1
constructing base class
n = 3
constructing derived class
m = 2
destructing derived class
destructing base class
destructing base class
#include
using namespace std;
class B1 {
public: B1(int i) {cout<<“B1 的构造函数被调用:”<<i<<endl;}
~B1() {cout<<“B1 的析构函数被调用。”<<endl;}
};
class B2 {
public: B2(int j) {cout<<“B2 的构造函数被调用:”<<j<<endl;}
~B2() {cout<<“B2 的析构函数被调用。”<<endl;}
};
class C: public B2, public B1 {
public:
C(int a, int b, int c, int d):B1(a),memberB2(d),memberB1?,B2(b) {
cout<<“C 的构造函数被调用。”<<endl;
}
~C() { cout<<“C 的析构函数被调用。”<<endl;}
private:
B1 memberB1; B2 memberB2;
};
void main(){
C obj(1,2,3,4);
}
答案：B2的构造函数被调用：2
B1的构造函数被调用：1
B1的构造函数被调用：3
B2的构造函数被调用：4
C的构造函数被调用。
C的析构函数被调用。
B2的析构函数被调用。
B1的析构函数被调用。
B1的析构函数被调用。
B2的析构函数被调用。
#include
using namespace std;
void func(int a)
{
static int m = 0;
m += a;
cout << m << " ";
}
void main()
{
int k = 6;
func(k);
func(k);
cout << endl;
}
答案：6 12
#include
using namespace std;
class Sample
{
public:
int x, y;
Sample(int a = 0, int b = 0){ x = a; y = b; }
~Sample(){ cout << "x = " << x << ", y = " << y << endl; }
};
void main()
{
Sample s;
exit(0);
}
答案：（不输出）
#include
using namespace std;
class point {
protected:
int x, y;
public:
point(int xx, int yy) {
x = xx, y = yy;
cout << "construct point: " << x << “,” << y << endl;
}
~point() { cout << “destroy point” << endl;}
};
class circle {
protected:
point center;
int radius;
public:
circle(int x, int y, int r):center(x, y),radius? {
cout << "construct circle: " << radius << endl;
}
~circle(){ cout << "destroy circle " << endl;}
};
int main() {
circle c(1,2,3);
return 0;
}
答案：construct point:1,2
construct circle:3
destroy circle
destroy point
#include
using namespace std;
class Sample
{ int x;
public:
Sample(int a)
{ x = a;
cout << "constructing object: x = " << x << endl;
}
};
void fun(int n)
{ static Sample obj(n);
}
void main()
{ fun(1); fun(10);
}
答案：constructing object: x = 1
#include
using namespace std;
class Sample
{
public:
int x, y;
void disp(){ cout << "x = " << x << ", y = " << y << endl; }
};
void main()
{
int Sample::*pc;
Sample s;
pc = &Sample::x;
s.*pc = 10;
pc = &Sample::y;
s.*pc = 20;
s.disp();
}
答案：x = 10, y = 20
#include
using namespace std;
class MyClass
{
public:
MyClass(int n){ number = n; }
MyClass(MyClass & other){ number = other.number; }
~MyClass(){}
private:
int number;
};
MyClass fun(MyClass p)
{
MyClass temp(p);
return temp;
}
int main()
{
MyClass obj1(10), obj2(0);
MyClass obj3(obj1);
obj2 = fun(obj3);
return 0;
}
程序执行时，MyClass的拷贝构造函数被调用了几次？
答案：4次
class Point
{
public:
Point(int x = 0, int y = 0){ _x = x; _y = y; }
void Move(int xOff, int yOff)
{ _x += xOff; _y += yOff; }
void Print() const
{ cout << '(' << _x << ',' << _y << ')' << endl; }
private:
int _x, _y;
};
下列语句中会发生编译错误的是____
A. Point pt; pt.Print();
B. const Point pt; pt.Print();
C. Point pt; pt.Move(1, 2);
D. const Point pt; pt.Move(1, 2);
答案：D
#include
using namespace std;
char *x[] = {“first”, “second”, “third”};
void fun(char *z[])
{
cout << *++z << endl;
}
int main()
{
char **y;
y = x;
fun(y);
return 0;
}
答案：second
#include
using namespace std;
class counter {
protected:
static int count;
int id;
public:
counter() {
id = ++ count;
cout << "id = " << id << ", count = " << count << endl;
}
};
int counter::count = 0;
static counter c[3];
int main() {
cout << “initialize program” << endl;
return 0;
}
答案：id=1,count=1
id=2,count=2
id=3,count=3
initialize program
#include
using namespace std;
class Expt{};
class Expt1: public Expt{
public: Expt1() { cout<<“Expt1 的构造函数被调用。”<<endl; }
Expt1(Expt1 & e) {cout<<“Expt1 的拷贝构造函数被调用。”<<endl; }
~Expt1() { cout<<“Expt1 的析构函数被调用。”<<endl; }
};
class Expt2: public Expt1 {
public: Expt2() { cout<<“Expt2 的构造函数被调用。”<<endl; }
Expt2(Expt2 & e) { cout<<“Expt2 的拷贝构造函数被调用。”<<endl; }
~Expt2() { cout<<“Expt2 的析构函数被调用。”<<endl; }
};
void MyFunc() { Expt1 e; throw e; }
void main() {
try {
cout << "在try块中，调用MyFunc()。" << endl;
MyFunc();
cout << "在try块中，MyFunc()执行结束。" << endl;
}
catch( Expt E ) { cout << "捕获到Expt类型异常。"<<endl; }
catch( Expt2 E ) { cout << “捕获到Expt2类型异常。”<<endl; }
cout << "回到main函数。" << endl;
}
答案：在try块中，调用MyFunc()。
Expt1 的构造函数被调用。
Expt1 的拷贝构造函数被调用。
Expt1 的析构函数被调用。
捕获到Expt类型异常。
Expt1 的析构函数被调用。
回到main函数。
(1)
class Array
{protected:
int size; //动态数组的长度
(2) elements; //动态数组的首地址
public：
Array(int i);
(3) ~Array(); //析构函数
Array( (4) a); //拷贝构造函数
(5) operator[](int index); //重载下标运算符
(6) ostream & operator <<(ostream &o, Array & a);
};
(1) 空格(1)处应该填写 【 】
A. virtual B. template C. void D. class
(2) 空格(2)处应该填写 【 】
A. T * B. T C. int * D. int
(3) 空格(3)处应该填写 【 】
A. void B. int C. virtual D. template
(4) 空格(4)处应该填写 【 】
A. Array B. Array * C. Array & D. const Array &
(5) 空格(5)处应该填写 【 】
A. T B. T * C. T & D. void
(6) 空格(6)处应该填写 【 】
A. friend B. const C. virtual D. void
答案：B A C D C A