- 析构函数可以被重载，不能有任何参数，有返回值。
- 如果一个模板声明列出了多个参数，则每个参数之间必须使用逗号隔开，每个参数都须重复使用关键字（ ）。
- 类模板代表一个具体的类，可以直接用于定义对象。
- 对于文件的访问方式，C++提供 ( )读写方式。
- ( )的功能是在创建对象时，给数据成员赋初值，即对象的初始化。
- ( )是标准输出流。
- 以下程序的输出结果为( )#include #include using namespace std;void myread(const char* fname){ ifstream file_read(fname,ios::binary); char c; if(file_read) { while(file_read.get(c))//文件没有结束时读入 cout< }}void mywrite(const char* fname){ ofstream file_write(fname,ios::binary); char c='A'; if(file_write) { for(int i=0;i<6 fname[20]="word.file">
答案:ABCDEF
- 以下程序的输出结果为( )#include#includeclass Sample{public: int x,y; Sample(){x=y=0;} Sample(int a,int b){x=a;y=b;} void disp() { cout<<"x="< } ~Sample() { if(x==y) cout<<"x=y"< else x!=y xss=removed>
答案:x=2,y=3
- 以下程序的输出结果为( )#include 'iostream'using namespace std;templatevoid PrintArray(T *Array,int count){ for(int i=0;i
答案:1 2 3 4 5
- 以下程序的输出结果为( )#include int p(int x = 4, int y = 5, int z = 6){ return x + y + z;}void main(){ int a = 3, b = 4, c = 0; c = p(b, c); cout << c>
答案:10
- 一个类中有且仅有一个析构函数，且应为( )。
答案:public
- 以下程序的输出结果为( )#include class B{public: B(){a=b=0;} B(int i,int j) {a=i;b=j;} void printb() { cout
- 以下程序的输出结果为( )#includeusing namespace std;class base{public: virtual char* show()const=0;};class d1 : virtual public base{public: char* show() const{return 'd1';}};class d2: virtual public base{public: char* show() const{return 'd2';}};class m:public d1,public d2{public: char* show()const { return d2::show(); }};int main(){ m m1; cout<
- 模板分函数模板和（ ）。
- 以下程序的输出结果为( )#includeint &f(int &i){ i*=5; return i;}int main(){ int k=3; int &m=f(k); m=50; cout< return>
- 友元函数可以在类的私有部分进行声明，也可以在类的公有部分进行声明。
- 以下程序的输出结果为2234#includeclass Sample{int x;public:Sample(){x=0;}Sample(int a) {cout<<(x=a);}~Sample(){ cout<<++x;}void disp(){ cout<
- 一旦一个引用被初始化为指向一个对象，它也可以被改变为指向另一个对象的引用。
- 如有定义const int i=5; const int j=3; const int *p=&i; 则执行语句p=&j; 是合法的。
- 输出运算符<<不支持级联输入。
- 输出运算符<<不支持十六进制数据的输出。
- 给一组变量输入值时，用( )将输入的数值间隔开。
- 下列叙述中不正确的是( )
- 定义一个整形常量x并设其初值为5的格式为( )。
- 当引用被创建时，它必须被( )。
- 以下程序的输出结果为( )#includeclass Sample{private: int x;public: Sample(){ cout<<(x=0);} Sample(int i,int j) {cout<<(x=i+j);} ~Sample(){cout<};void main(){ Sample *p1=new Sample, *p2=new Sample(3,4); delete p1; delete p2;}
- 函数模板和类模板提供了( )的通用机制。
- 赋值运算符不能重载为( )函数。
- 以下程序的输出结果为( )#includeclass Sample{ int n; int m;public: Sample(int i=0,int j=5){n=i;m=j;} Sample &operator =(Sample); void disp(){ cout< }};Sample &Sample::operator=(Sample s){ n=s.n; m=s.m; return *this;}void main(){ Sample s1(20),s2; s2=s1; s2.disp();}
- 如果在try块内没有发生异常，则直接转到所有catch块后的( )语句执行下去。
- 为防止一个对象不被通过传值方式传递，需要声明一个( )拷贝构造函数。
- 定义命名空间的关键字为( )。
- 以下程序的输出结果为( )#include class X { //基类protected: int a;public: void make(int i) { a = i; }};class Y {protected: int a;public: void make(int i) { a = i; }};class Z:public X, public Y {public: int make(int i) { return X::a * Y::a ; }};void main() { Z zobj; zobj.X::make (10); zobj.Y::make (20); cout << zobj>
- 类和对象之间的关系是( )的关系。
- 以下程序的输出结果为( )#includeclass Sample{ int n;public: Sample(){} Sample(int i){n=i;} friend Sample operator-(Sample &,Sample &); friend Sample operator+(Sample &,Sample &); void disp(){cout<<"n="<};Sample operator-(Sample &s1,Sample &s2) { int m=s1.n-s2.n; return Sample(m);}Sample operator+(Sample &s1,Sample &s2) { int m=s1.n+s2.n; return Sample(m);}void main(){ Sample s1(10),s2(20),s3; s3=s2-s1; s3.disp(); s3=s2+s1; s3.disp();}
- C++把每个文件都看成是一个有序的( )。
- 以下程序的输出结果为( )#include class Sample{public: Sample(int a=0,int b=1); void disp(); ~Sample();private: int x,y;};Sample::Sample(int a,int b){x=a;y=b;}void Sample::disp (){ cout<}Sample::~Sample(){ if(x) cout< else>
- 以下程序的输出结果为( )#includeclass Sample{ int n;public: Sample(int i){n=i;} operator++(){n++;} // 前缀重载运算符 operator++(int){n+=2;} // 后缀重载运算符 void disp() { cout<<"n="< }};void main(){ Sample A(2),B(2); A++; // 调用后缀重载运算符 ++B; // 调用前缀重载运算符 A.disp(); B.disp();}
- 要向文件中输出数据，则必须定义( )类的对象。
- 如有定义 int const * p;表示指针不能被改变。
- 输入运算符>>不支持级联输入。
- 析构函数可以重载。
- 非成员函数作为类的友元函数有this指针。
- 重载不能改变运算符的原有( )。
- 面向对象程序设计方法的基本特征主要有抽象性、( )和多态性。
- 对于C++中的模板类型参数T，只能是系统预定义的数据类型。
- C++的流库预定义了4个流，它们是cin和( )。
- 构造函数可以声明为虚函数。
- 如有const int MAX=100;则定义 int iData[MAX];是非法的。
- 对于catch块来说，处理错误之后可以让程序继续运行，也可以终止程序。
- 函数重载是指两个或两个以上的函数具有相同的函数名，但要求( )。
- 派生类不能继承基类的构造函数和析构函数。
- 如有定义 int i=5, &j=i; 则j值的变化不会引起i值得变化。
- 通过对( )进行重载，可以实现定义对象时初始化赋值的多样性。
- 以下程序的输出结果为( )#include class ThreeD{private: int x,y,z;public: ThreeD operator ++( ); void Show( ) { cout << x xss=removed xss=removed xss=removed xss=removed>
- 以下程序的输出结果为( )#includeclass Sample{ int n;public: Sample(){} Sample (int m){n=m;} friend void square(Sample &s) { s.n=s.n*s.n; } void disp() { cout<<"n="< }};void main(){ Sample a(10); square(a); a.disp();}
- 当派生类也作为基类使用时，则各派生类只负责其（ ）基类的构造。
- 以下程序的输出结果为( )#includeclass Sample{ int n;public: Sample(int i){n=i;} friend int add(Sample &s1,Sample &s2);};int add(Sample &s1,Sample &s2) { return s1.n+s2.n;}void main(){ Sample s1(10),s2(20); cout<}
- 以下程序的输出结果为( )#include int p(int x = 4, int y = 5){ return x + y;}void main(){ int a = 3, b = 4, c = 0; c = p(b); cout << c>
- 以下程序的输出结果为( )#includeclass Sample{public: int x; int y; void disp() { cout< }};void main(){ int Sample::*pc; Sample s; pc=&Sample::x; s.*pc=10; pc=&Sample::y; s.*pc=20; s.disp();}
- ( )就是针对对象的行为特征，如鸟会飞、会跳等方面，可以抽象为方法。
- C++支持两种多态性，即编译时的多态性和运行时的多态性。运行时的多态性是通过 （ ）来实现的。
- 不同的对象，收到同一消息可以产生不同的结果，这种现象称为( )。
- 以下程序的输出结果为( )#includeclass sample{ int n;public: sample(){}; sample(int m){n=m;} sample add(sample s1,sample s2){ this->n=s1.n+s2.n; return(*this); } void disp() { cout<<'n='<
- 当函数被声明为一个类的( )后，它就可以通过对象名访问类的私有成员和保护成员。
- 双目运算符重载为类的友元函数时，其参数表有( )个参数。
- 类模板的模板参数( )
- ( )是一个函数，它与一般函数的区别是在使用时可以像宏一样展开，所以没有函数调用的开销。
- this指针是C++实现( )的一种机制。
- 以下程序的输出结果为( )#includeclass CSample{int i; public: CSample() { i=1; cout< } void disp() { cout<<++i; } ~CSample() { cout< }};void main(){ CSample s; s.disp();}
- 测试块作为普通作用域，由关键字( )引导。
- 如果找不到匹配类型的catch语句，系统函数( )被调用，终止程序。
- 以下程序的输出结果为( )#include "iostream"using namespace std;templateT result(T *a,int n=0) { T b=1; int i; for(i=0;i { b*=a[i]; } return b;}int main(){ int a[]={2,3,4,5}; cout< return>
- 定义对象时，编译系统会自动地调用( )。
- 以下程序的输出结果为( )#include #include int main(){ ofstream outf("data.dat"); char p[]="Good Morning"; outf< outf>>p; cout< return>
- 以下程序的输出结果为( )#includeclass B;class A{ int i; friend B; void disp(){cout<
- 以下程序的输出结果为( )#includeclass Base{ int i;public: Base(int I):i(I){} virtual int value() const { return i; } virtual int shift(int x)const{return i;}};class Der :public Base{public: Der(int I):Base(I){} int value() const { return Base::value()*2; } virtual int shift(int x) const { return Base::value()<
- 定义A是一个类，那么执行语句“A a, b(3),*p;”调用了( )次构造函数。
- 以下程序的输出结果为( )#include #include using namespace std;ostream &myoutput(ostream& stream){ stream< return i=123;>
- 当用传递值方式传递或返回一个对象时，编译器自动调用( )函数。
- 以下程序的输出结果为( )#includeclass Sample{ int n;public: Sample(){} Sample(int i){n=i;} Sample &operator =(Sample); void disp(){cout<<'n='<
- 下面程序输出的正确结果是( )#includeclass ThreeD {private:int x,y,z;public:ThreeD operator ++( );ThreeD operator ++(int i );void Show( ) { cout<
- 类类型转换函数只能定义为一个类的( )函数。
- 异常处理不仅提供了程序的容错性，还提供了各种( )的方法。
- 异常处理部分必须( )放在测试块之后。
- 如果发生异常，则根据throw抛出的异常对象类型来匹配一个( )语句。
- C++语言提供了异常接口声明语法，利用它可以清晰地告诉使用者异常抛出的( )。
- 如果找到类型匹配的catch语句，进行捕获，其参数被初始化为( )对象，执行相应catch内的语句模块。
- 给定void f( ) throw( ); 则该函数f能抛出( )异常。
- 如不想在异常抛出时退出函数，可在函数内创建一个( )，用于测试各种错误。
- 如果任意层的异常处理器都没有捕获到异常(没有指定相应的catch块)，称为( )。
- 在try之后，根据异常的不同情况，相应的处理方法由关键字( )引导。
- 如有异常抛出，可以使用( )类型变量作为参数。
- 下列关于getline( )函数的叙述中，错误的是( )。
- 以下程序的输出结果为( )#include
#include using namespace std;ostream &myoutput(ostream& stream){stream< - 打开文件的方式中，( )以追加方式打开文件。
- 以下程序的输出结果为( )#include
#include using namespace std;ostream &myoutput(ostream& stream){stream< - 控制格式输入输出的操作中，函数( )是用来设置填充字符。要求给出函数名和参数类型。
- 要从文件中输入数据，则必须定义( )类的对象。
- 要通过“<<”输出自定义的类类型，则必须重载该运算符为( )函数。
- 在C++ 的流对象中，( )表示标准输入的istream类对象。
- 根据数据的组织形式，文件分为( )。
- 以下程序的输出结果为( )#include
#include using namespace std;int main(){ofstream outf("data.dat");int i;for(i=0;i<10 xss=removed>>i;cout< - 模板函数与函数重载相同，可以互相取代。
- 把模板参数实例化后，由函数模板产生的函数称为( )，它是函数模板的具体实例。
- 类模板代表了一类( )，模板类表示某一具体的类。
- 类模板的成员函数都是模板函数。
- 使用函数模板的方法与使用普通函数类似，即使用( )代替模板参数并调用。
- 函数模板代表了一类函数，是对一类函数的抽象，它以( )类型为参数。
- 一个( )允许用户为类定义一种模式，使得类中的某些数据成员及某些成员函数的返回值能取任意类型。
- 如果一个模板声明列出了多个参数，则每个参数之间必须使用逗号隔开，每个参数都须重复使用关键字( )。
- 类模板的使用实际上是将类模板实例化成为一个具体的( )。
- 类模板本身在编译中会生成额外的代码。
- 在派生类中重新定义虚函数时，除了( )，其他方面都必须与基类中相应的虚函数保持一致。
- 抽象类用做提供( )类的接口，不能声明对象。
- 如果派生类没有给出全部纯虚函数的实现，这时的派生类仍然是一个( )类。
- 在派生类的声明中，如果只有一个基类名，则这种继承方式称为（ ）。
- 如果一个类带有纯虚函数，则此类称为( )类。
- （ ）函数和全局函数不能声明为虚函数。
- 抽象类只能用做其他类的( )类，不能建立抽象类对象。
- 关于虚函数和抽象类描述错误的是( )。
- 必须在派生类的( )函数中调用初始化虚基类的构造函数。
- 普通对象调用虚函数，系统仍然以( )方式调用函数。
- 前置单目运算符重载为类的成员函数时，其参数表有( )个参数。
- 将一个char型数据转换为String类型(用户自定义类型)的数据时，可以用( )函数完成类类型转换。
- 双目运算符重载为类的成员函数时，其参数表有( )个参数。
- 用构造函数完成类类型的转换，类内至少定义一个( )的构造函数。
- 下列运算符中，必须使用成员函数进行重载的是( )。
- 对赋值运算符进行重载时，应声明为( )函数。
- 下列关于运算符重载的描述中，错误的是( )。
- 如何只带一个参数(或其他参数都带有默认值)的( )函数都可以认为是一种转换构造函数。
- 大多数的运算符重载可以重载为类的( )。
- C++中只能重载C++语言中( )的运算符。
- 一旦一个引用被初始化为指向一个对象，它就( )被改变为对另一个对象的引用。
- 引用作为函数参数时，函数实参与形参之间的传递是( )传递。
- 在类里创建一个const数据成员时不能赋初值，只能在( )里对其赋初值。
- 如执行语句以下语句之后，x的值为（ ）。int a[5]={1,2,3},&x=a[2];int *y=&x; y++;
- 如执行语句以下语句之后，x的值为（ ）。int x=5,*y=&x;int* &z=y; z++;
- 引用是通过变量的别名( )访问变量。
- 常对象只能调( )函数。
- 定义q为一个指向int类型的变量i的常指针语句( )
- 已知：const int x = 23;定义指针q指向x，语句是（ ）
- 关于拷贝构造函数的描述正确的是（ ）。
- 函数重载是指两个或两个以上的函数具有( )的函数名，但参数类型不一致或参数个数不同。
- 函数重载是C++对C语言的扩展，包括( )重载。
- 成员函数重载的一个很重要的应用就是重载( )。
- 一个类的友元函数能够访问该类的( )
- 函数重载是指两个或两个以上的函数具有相同的函数名，但参数类型不一致或( )不同。
- ( )是指两个或两个以上的函数具有相同的函数名，但参数类型不一致或参数个数不同。
- 在类内给出函数体定义的成员函数被默认为( )。
- 在内联函数体中不能含有如下哪些语句( )。
- 内联函数的关键字是( )。
- 在函数调用时，若某个参数省略，则其后的参数皆应省略而采用( )。
- 以下程序的输出结果为( )#include
class Sample{int x;public:Sample(){cout<<(x=0);}Sample(int i){cout<<(x=i);}~Sample(){cout< - 如果不定义析构函数，系统会自动生成一个默认的( )。
- 请选择出下面程序的输出结果( )#include
float f(float x, float y){return x+y;}int f(int x, int y){return x+y;}void main(){float a, b, c;a = b = 50.5; c = f(a, b);cout << c> - 下面程序的输出结果为( )#include
int p(int x = 4, int y = 5, int z = 6){return x + y + z;}void main(){int a = 3, b = 4, c = 5; c = p(b, a);cout << c> - 析构函数和构造函数两者的调用次序( )。
- ( )的功能是释放一个对象，在对象删除之前，用它来做一些内存释放等清理工作，它的功能与构造函数的功能正好相反。
- 下面选项中是以下程序输出结果的是( )#include
int add(int x, int y = 8);void main(){int a = 6; cout << add> - 在堆中创建的数据对象称为( )。
- 在C++语言程序中，对象之间的相互通信通过调用( )函数实现。
- 下面4个选项中，专门用于读取单个字符的是( )。
- fstream从( )派生而来，把文件绑定到程序输入/输出。
- 大多数C++程序通常包含( )头文件，它包含了所有输入/输出操作所需要的信息。
- 运算符<<左边的操作数是( )类的一个对象，右边可以是C++的合法表达式。
- 命名空间成员的访问格式为( )。
- ifstream从( )派生而来，把文件绑定到程序输入。
- ( )表示标准错误输出（非缓冲方式）导出程序错误信息。
- ofstream从( )派生而来，把文件绑定到程序输出。
- ( )表示标准错误输出（缓冲方式），导出程序错误信息。
- ( )是标准输入流。
- 把面向对象思想应用于软件开发过程中，指导开发活动的系统方法，简称( )方法。
- 面向对象程序设计所涉及的术语有类、对象、方法、( )和重载。
- 子类继承了多个父类的数据结构和方法，则称为( )。
- ( )是一个类所描述的一个具体的对象。
- 编译时的多态性是通过( )来实现的。
- 面向对象设计中，对象就是( )，它是把数据结构和操作这些数据的方法紧密地结合在一起所构成的模块。
- ( )是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。
- ( )就是从众多的事物中抽取出共同的、本质性的特征，舍弃其非本质的特征。
- ( )是对一组具有共同属性特征和行为特征的对象的抽象。
- 运行时的多态性是通过( )来实现的。
- 以下程序的输出结果为( )#include int p(int x = 4, int y = 5, int z = 6){ return x + y + z;}void main(){ int a = 3, b = 4, c = 0; c = p(b, c); cout << c>
答案:错
答案:typename###class
答案:错
答案:顺序###随机
答案:构造函数
答案:cout
温馨提示支付 ￥5.00 元后可查看付费内容,请先翻页预览!
