出自:河南财经大学数据库基础与应用

设有函数T Sum(T x,T y){return x+y;},其中T为模板类型,则下列语句中对该函数错误的使用是( )
A.Sum(1,2);
B.Sum(3.0,2.2);
C.Sum(‘A’,‘C’);
D.Sum(
编写C++程序一般需经过的几个步骤依次是( )
A.编译、编辑、连接、调试
B.编辑、编译、连接、调试
C.编译、调试、编辑、连接
D.编辑、调试、编译、连接
设存在函数int max(int,int)返回两参数中较大值,若求22,59,70三者中最大值,下列表达式不正确的是( )
A.int m = max(22,max(59,70));
B.int m = max(max(22,59),70);
C.int m = max(22,59,70);
D.int m = max(59,max(22,70));
假定AB为一个类,px为指向该类的一个含有n个对象的动态数组的指针,则执行“delete []px;”语句时共调用该类析构函数的次数为( )
A. 0
B.1
C. n
D.n+1
继承机制的作用是( )
A.信息隐藏
B. 数据封装
C.定义新类
D.数据抽象
语句ofstream f(″SALARY.DAT″,ios::app|ios::binary);的功能是建立流对象f,试图打开文件SALARY.DAT并与之连接,并且( )
A.若文件存在,将文件写指针定位于文件尾;若文件不存在,建立一个新文件
B.若文件存在,将其置为空文件;若文件不存在,打开失败
C.若文件存在,将文件写指针定位于文件首;若文件不存在,建立一个新文件
D.若文件存在,打开失败;若文件不存在,建立一个新文件
对于类定义 class A{ public: virtual void func1( ){ } void func2( ){ } }; class B:public A{ public: void func1( ){cout<″class b="" func="">
A.A::func2( )和B::func1( )都是虚函数
B. A::func2( )和B::func1( )都不是虚函数
C.B::func1( )是虚函数,而A::func2( )不是虚函数
D.B::func1( )不是虚函数,而A::func2( )是虚函数
下列有关模板和继承的叙述正确的是 ( )
A.模板和继承都可以派生出一个类系
B.从类系的成员看,模板类系的成员比继承类系的成员较为稳定
C.从动态性能看, 继承类系比模板类系具有更多的动态特性
D.相同类模板的不同实例一般没有联系,而派生类各种类之间有兄弟父子等关系
以下叙述正确的是( )
A.构造函数调用虚函数采用动态联编
B.构造函数可以说明为虚函数
C.当基类的析构函数是虚函数时,它的派生类的析构函数也是虚函数
D.析构函数调用虚函数采用动态联编
下列说法中正确的是( )
A.类定义中只能说明函数成员的函数头,不能定义函数体
B.类中的函数成员可以在类体中定义,也可以在类体之外定义
C.类中的函数成员在类体之外定义时必须要与类声明在同一文件中
D.在类体之外定义的函数成员不能操作该类的私有数据成员
在下列成对的表达式中,运算结果类型相同的一对是( )
A.7/2和7.0/2.0
B.7/2.0和7/2
C.7.0/2和7/2
D.7.0/2.0和7.0/2
设有函数模板 template Q Sum(Qx,Qy){ return(x)+(y); } 则下列语句中对该函数模板错误的使用是( )
A.Sum(10,2);
B.Sum(5.0,6.7);
C.Sum(15.2f,16.0f);
D.Sum(″AB″,″CD″);
若Sample类中的一个成员函数说明如下:voidset(Sample&a),则Sample&a的含义是( )
A.指向类Sample的名为a的指针
B.a是类Sample的对象引用,用来作函数Set()的形参
C.将a的地址赋给变量Set
D.变量Sample与a按位与的结果作为函数Set的参数
包含自定义头文件file.h的预处理指令是( )
A.#define
B.#include file.h
C.#define file.h
D.#include
设函数void swap(int&,int&)将交换两形参的值,如两整型变量int a=10;int b=15; 则执行swap(a,b)后,a、b值分别为( )
A.10,10
B.10,15
C.15,10
D.15,15
对类中声明的变量,下列描述中正确的是( )
A.属于全局变量
B.只属于该类
C.属于该类,某些情况下也可被该类不同实例所共享
D.任何情况下都可被该类所有实例共享
如没有使用private关键字定义类的数据成员,则默认为( )
A.private
B.public
C.protected
D.friend
类的私有成员可在何处访问( )
A.通过子类的对象访问
B.本类及子类的成员函数中
C.通过该类对象访问
D.本类的成员函数中
下列描述错误的是( )
A.在创建对象前,静态成员不存在
B.静态成员是类的成员
C.静态成员不能是虚函数
D.静态成员函数不能直接访问非静态成员
通常情况下,函数模板中的类型参数个数不能是( )
A.0
B.2
C.4
D.3
下列关于析构函数描述正确的是( )
A.可以重载
B.函数体中必须有delete语句
C.返回类型必须是void类型
D.不能指定返回类型
下面叙述不正确的是( )
A.派生类一般都用公有派生
B.对基类成员的访问必须是无二义性的
C.赋值兼容规则也适用于多重继承的组合
D.基类的公有成员在派生类中仍然是公有的
当一个类的某个函数被说明为virtual时,该函数在该类的所有派生类中( )
A.都是虚函数
B.只有被重新说明时才是虚函数
C.只有被重新说明为virtual时才是虚函数
D.都不是虚函数
在C++中实现封装是借助于( )
A.枚举
B.类
C.数组
D.函数
所有在函数中定义的变量,都是( )
A.全局变量
B.局部变量
C.静态变量
D.寄存器变量
在下列成对的表达式中,运算符“+”的意义不相同的一对是( )
A.5.0+2.0和5.0+2
B.5.0+2.0和5+2.0
C.5.0+2.0和5+2
D.5+2.0和5.0+2
要禁止修改指针p本身,又要禁止修改p所指向的数据,这样的指针应定义为( )
A.const char *p=“ABCD”;
B.char const *p=“ABCD”;
C.char *const p=“ABCD”;
D.const char * const p=“ABCD”;
给出下面程序的输出结果

#include<iostream>

using namespace std;

class Simple

{

int x,y;

public:

Simple(){x=y=0;}

Simple(int i,int j){x=i;y=j;}

void copy(Simple&s);

void setxy(int i,int j){x=i;y=j;}

void print(){cout<<"x="<<x<<",y="<<y<<endl;}

};

void Simple::copy(Simple&s)

{

x=s.x;y=s.y;

}

void func(Simple s1,Simple&s2)

{

s1.setxy(30,40);

s2.setxy(70,80);

}

void main()

{

Simple obj1(1,2),obj2;

obj2.copy(obj1);

func(obj1,obj2);

obj1.print();

obj2.print();

}
下面程序的运行结果如下:

B::display()

C::display()

在下划线处填上缺少的部分。源程序如下:

#include<iostream>

using namespace std;

class B

{

public:

_______display( ) {cout << "B::display( ) "<<endl;}

};

class C:public B

{

public:

void display(){cout<<"C::display()"<<endl;}

};

void fun(B*p)

{

p->display();

}

void main()

{

B b,*pb;

C c;

pb=&b;

fun(pb);

pb=&c;

fun(pb);

}
下面程序的运行结果如下:
This is line1

This is line2

This is line3

在下划线处填上缺少的部分。源程序如下:

#include

#include

using namespace std;

void main()

{

fstream fin, fout;

fout.open("my.txt",ios::out);

if(!fout.is_open())

return;

for(int i=0;i<3;i=i+1)

fout<<"This is line"<<><>< strong="">


fout.close();

fin.open("my.txt",ios::in);

if(! fin.is_open())

return;

char str[100];

while(!fin.eof())

{

fin.getline(str,100);

cout<<><>< strong="">


}

fin.close();

}
下面有一处错误,请给出修改意见。

#include

class point{

private:float x,y;

public:f1(float a,float b){x=a;y=b;}

point(){x=0;y=0;}

void getx(){cout<<><>< strong="">


void gety(){cout<<><>< strong="">


};

void print(point a){cout<<><>< strong="">


main(){

point a;

a.f1(3.0,5.0);

print(a);

}
下面有一处错误,请给出修改意见。

#include

class f{

private:int x,y;

public:fl(int a,int b){x=a;y=b;}

void print(){cout<<><><>< strong="">


} ;

main(){

f a;

a.f1(1.5,1.8);

a.print();

}

下面有一处错误,请给出修改意见。

#include

main(){

int x=6;

const int*p=x;

cout<<*p<<>< strong="">


}
下面有一处错误,请给出修改意见。

#include

class f{

private:float x,y;

public:f(float a,float b){x=a;y=b;}

float max(){return(x<>< strong="">


} ;

main( ){

f a(1.5,3.8);

cout<<><>


}
若使用标准输出流把整型变量a的值输出到屏幕上,实现此操作的C++语句是______。
C++将数据从一个对象流向另一个对象的流动抽象为“流”,从流中获取数据的操作称为______。
写出声明一个复数对象的语句,并使该对象被初始化为2.2+1.3i,此声明语句是______。
类和其它数据类型不同的是,组成这种类型的不仅可以有数据,还可以有对数据进行操作的_______。
有下列代码int a=0;double b=0;cin>>a>>b;当用键盘输入1.25时,b=______。
对于类Point而言,其析构函数的定义原型为
给出下面程序的输出结果。

#include

template

class Sample

{

T n;

public:

Sample(T i){n=i;}

int operator==(Sample &);

};

template

int Sample::operator==(Sample&s)

{

if(n==s.n)

return 1;

else

return 0;

}

void main( )

{

Samplesl(2),s2(3); .

cout<<″s1与s2的数据成员″<<(sl==s2 ?″相等″:″不相等″)<<>< p="">

Samples3(2.5),s4(2.5);

cout<<″s3与s4的数据成员″<<(s3==s4 ? ″相等″:″不相等″)<<>< p=""> }
下面是一个输入半径,输出其面积和周长的C++程序,在下划线处填上正确的语句。

#include

using namespace std;

const double pi=3.14159;

void main( )

{

double r;

cout<<″r=″;

_______;

double l=2.0*pi*r;

double s=pi*r*r;

cout<<″\n The long is:″<<><>< p="">

cout<<″The area is:″<<><>< p="">

}
程序的输出结果如下:
1,9

50,30

请根据输出数据在下面程序中的下划线处填写正确的语句。

源程序如下:

#include

using namespace std;

class base

{

private:

int m;

public:

base( ){ };

base(int a):m(a){}

int get( ){return m;}

void set(int a){m=a;}

};

void main()

{

base*ptr=new base[2];

ptr- >set(30);

ptr= _______ ;

ptr- >set(50);

base a[2]={1,9};

cout<<>< p=""><>

cout<get( )<<″,″;

ptr=ptr-1;

cout<get()<<>< p="">

delete[ ]ptr;

}
在下面横线处填上求两个浮点数之差的cha函数的原型声明、调用方法。
#include

using namespace std;

void main( )

{

float a,b;

float cha(float,float);//函数cha的原型声明

a=12.5;

b=6.5;

float c= ; //调用函数cha

cout<<><>< p="">

}

float cha(float x,float y)

{

float w;

w=x-y;

return w;

}
#include

void main( ) {

int x=5,y=6;

const int * p=&x;

*p=y;

cout<<*p<<>< p="">}
#include
class f{

private:int x,y;

public:f1( ){x=0;y=0;}

print( ){cout<<><><><>< p="">

};

void main( ){

f a;

a.f1(1,1);

a.print( );

}
#include
class f{

private:int x=0,y=0;

public:void f1(int a,int b){x=a;y=b;}

void get( ){cout<<><><><>< p="">

};

void main( ){

f a;

a.f1(1,3);

a.get ( );

}
#include
class point{private:float x;

public:void f(float a){x=a;}

void f( ){x=0;}

friend float max(point& a,point& b);

};

float max(point& a,point& b)

{return(a.x>b.x)? a.x:b.x;}

void main( ){

point a,b;

a.f(2.2);b.f(3.3);

cout<<>< p=""> }
#include
template

class f{

private:T x,y;

public:void f1(T a,T b){x=a;y=b;}

T max( ){retum(x>y)?x:y;}

};

void main( ){

f a;

a.f1(1.5,3.8); ’

cout<<><><>< p="">}
设要把一个文件输出流对象myFile与文件“f:\myText.txt相关联,所用的C++语句是:()。