c#面向对象试题及答案.docx
《c#面向对象试题及答案.docx》由会员分享，可在线阅读，更多相关《c#面向对象试题及答案.docx（28页珍藏版）》请在冰豆网上搜索。
c#面向对象试题及答案
一、选择题：
1、下列关于类的描述中，错误的是（A）。
A．类就是C语言中的结构类型
B．类是创建对象的模板
C．类是抽象数据类型的实现
D．类是具有共同行为的若干对象的统一描述体
2、下列常量中，不是字符常量的是（B）。
A．'\n'B．"y"
C．'x'D．'\7'
3、下列表达式中，其值为0的是（A）。
A．5/10B．！
0
C．2>4？
0：
1D．2&&2||0
4、下列关于数组维数的描述中，错误的是（C）。
A．定义数组时必须将每维的大小都明确指出
B．二维数组是指该数组的维数为2
C．数组的维数可以使用常量表达式
D．数组元素个数等于该数组的各维大小的乘积
5、下列关于字符数组的描述中，错误的是（D）。
A．字符数组中的每一个元素都是字符
B．字符数组可以使用初始值表进行初始化
C．字符数组可以存放字符串
D．字符数组就是字符串
6、已知：
inta[5]={1,2,3,4};下列数组元素值为2的数组元素是（B）。
A．a[0]B．a[1]
C．a[2]D．a[3]
7、下列while循环语句的循环次数是（A）。
while（inti（0））i--;
A．0B．1
C．2D．无限
8、已知：
inta[]={1,2,3,4,5}，*p=a；在下列数组元素地址的表示中，正确的是（C）。
A．&（a+1）B．&（p+1）
C．&p[2]D．*p++
9、已知：
inta=1，b=2，*p[2]；下列表达式中正确的是（C）。
A．p=&aB．p=&b
C．p[0]=&a，p[1]=&bD．p[]={&a，&b}；
10、当一个函数没有返回值时，该函数类型应说明为（A）。
A．voidB．int
C．无D．任意
11、下列关于类的定义格式的描述中，错误的是（C）。
A．类中成员有3种访问权限
B．类的定义可分说明部分和实现部分
C．类中成员函数都是公有的，数据成员都是私有的
D．定义类的关键字通常用class，也可用struct
12、下列关于成员函数的描述中，错误的是（A）。
A．成员函数的定义必须在类体外
B．成员函数可以是公有的，也可以是私有的
C．成员函数在类体外定义时，前加inline可为内联函数
D．成员函数可以设置参数的默认值
D．一个类所能创建对象的个数是有限制的
13、下列关于构造函数的描述中，错误的是（C）。
A．构造函数可以重载
B．构造函数名同类名
C．带参数的构造函数具有类型转换作用
D．构造函数是系统自动调用的
14、下列关于静态成员的描述中，错误的是（C）。
A．静态成员都是使用static来说明的
B．静态成员是属于类的，不是属于某个对象的
C．静态成员只可以用类名加作用域运算符来引用，不可用对象引用
D．静态数据成员的初始化是在类体外进行的
15、VoidSet（A&a）;是类A中一个成员函数的说明，其中A&a的含义是（A）。
A．类A的对象引用a作该函数的参数
B．类A的对象a的地址值作函数的参数
C．表达式变量A与变量a按位与作函数参数
16、下列关于运算符delete的描述中，错误的是（B）。
A．使用该运算符可以释放用new运算符创建的对象或对象数组
B．使用该运算符可以释放所有对象
C．使用delete运算符时会自动调用析构函数
D．用它释放对象数组时，它作用的指针名前要加下标运算符[]
17．下列关于基类和派生类的描述中，错误的是（C）。
A．一个基类可以生成多个派生类
B．基类中所有成员都是它的派生类的成员
C．基类中成员访问权限继承到派生类中不变
D．派生类中除了继承的基类成员还有自己的成员
18、派生类的对象可以直接访问的基类成员是（A）。
A．公有继承的公有成员B．保护继承的公有成员
C．私有继承的公有成员D．公有继承的保护成员
19、含有一个或多个纯虚函数的类称为（A）。
A．抽象类B．具体类
C．虚基类D．派生类
20、下列关于动态联编的描述中，错误的是（C）。
A．动态联编是函数联编的一种方式，它是在运行时来选择联编函数的
B．动态联编又可称为动态多态性，它是C++语言中多态性的一种重要形式
C．函数重载和运算符重载都属于动态联编
D．动态联编只是用来选择虚函数的
1、下列关于对象的描述中，错误的是（C）。
A．对象是类的一个实例
B．对象是属性和行为的封装体
C．对象就是C语言中的结构变量
D．对象是现实世界中客观存在的某种实体
2、在函数体内定义了下述变量a，a的存储类为（D）。
inta；
A．寄存器类B．外部类
C．静态类D．自动类
3、下列关于数组概念的描述中，错误的是（B）。
A．数组中所有元素类型是相同的
B．数组定义后，它的元素个数是可以改变的
C．数组在定义时可以被初始化，也可以不被初始化
D．数组元素的个数与定义时的每维大小有关
4、下列关于数组下标的描述中，错误的是（B）。
A．C++语言中数组元素的下标是从0开始的
B．数组元素下标是一个整常型表达式
C．数组元素可以用下标来表示
D．数组元素的某维下标值应小于该维的大小值
5、下列关于字符串的描述中，错误的是（C）。
A．一维字符数组可以存放一个字符串
B．二维字符数组可以存放多个字符串
C．可以使用一个字符串给二维字符数组赋值
D．可以用一个字符串给二维字符数组初始化
6、已知：
intb[5]={1,2,3,4};下列数组元素值为2的数组元素是（B）。
A．b[0]B．b[1]
C．b[2]D．b[3]
7、已知：
inti（3）；下列do-while循环语句的循环次数是（D）。
do{
cout<i--;
}while（i!
=0）;
A．0B．3
C．1D．无限
8、已知：
intb[]={1,2,3,4,5}，*p=b；在下列数组元素地址的表示中，正确的是（C）。
A．&（a+1）B．&（p+1）
C．&p[2]D．*p++
9、已知：
inta（5），&ra=a；下列描述中，错误的是（D）。
A．ra是变量a的引用，即为变量的别名B．ra的值为5
C．ra的地址值为&aD．改变ra的值为10，变量a值仍为5
10、下列关于被调用函数中return语句的描述中，错误的是（D）。
A．一个函数中可以有多条return语句
B．return语句具有返回程序控制权的作用
C．函数通过return语句返回值时仅有一个
D．一个函数中有且仅有一条return语句
11、下列关键字中，不属于定义类时使用的关键字是（D）。
A．classB．struct
C．publicD．default
12、下列关于对象的描述中，错误的是（D）。
A．定义对象时系统会自动进行初始化
B．对象成员的表示与C语言中结构变量的成员表示相同
C．属于同一个类的对象占有内存字节数相同
D．一个类所能创建对象的个数是有限制的
13、下列关于析构函数的描述中，错误的是（A）。
A．析构函数的函数体都为空
B．析构函数是用来释放对象的
C．析构函数是系统自动调用的
D．析构函数是不能重载的
14、下列关于友元函数的描述中，错误的是（B）。
A．友元函数不是成员函数
B．友元函数只可访问类的私有成员
C．友元函数的调用方法同一般函数
D．友元函数可以是另一类中的成员函数
15．下列关于运算符new的描述中，错误的是（D）。
A．它可以创建对象或变量
B．它可以创建对象数组或一般类型数组
C．用它创建对象或对象数组时要调用相应的构造函数
D．用它创建的对象可以不用delete运算符释放
16、下列关于this的描述中，错误的是（D）。
A．this是一个由系统自动生成的指针
B．this指针是指向对象的
C．this指针在用对象引用成员函数时系统创建的
D．this指针只能隐含使用，不能显式使用
17、下列关于派生类的描述中，错误的是（D）。
A．派生类至少有一个基类
B．一个派生类可以作另一个派生类的基类
C．派生类的构造函数中应包含直接基类的构造函数
D．派生类默认的继承方式是public
18、下列描述中，错误的是（D）。
A．基类的protected成员在public派生类中仍然是protected成员
B．基类的private成员在public派生类中是不可访问的
C．基类public成员在private派生类中是private成员
D．基类public成员在protected派生类中仍是public成员
19、下列关于虚函数的描述中，错误的是（C）。
A．虚函数是一个成员函数
B．虚函数具有继承性
C．静态成员函数可以说明为虚函数
D．在类的继承的层次结构中，虚函数是说明相同的函数
20、已知文本文件abc.txt，以读方式打开，下列的操作中错误的是（D）。
A．fstreaminfile（"abc.txt",ios:
:
in）;B．ifstreaminfile（"abc.txt"）;
C．ofstreaminfile（"abc.txt"）;Dfstreaminfile;infile.open（"abc.txt",ios:
:
in）;
二、填空题：
1、如果一个类中没有定义任何构造函数时，系统会自动提供一个默认构造函数；同样，类中没有定义析构函数时，系统会自动提供一个默认析构函数。
2、静态成员是属于类的，它除了可以通过对象名来引用外，还可以使用
类名限定来引用。
3、友元函数是被说明在类体内的非成员函数。
友元函数可访问该类中的___私有_____成员。
4、类体内成员有3个访问权限，说明它们的关键字分别是公有、私有和保护。
6、定义类A中有两个公有成员函数，其中一个是构造函数，另一个是静态成员函数f1（），还有两个私有的数据成员，一个是静态的整型数据成员a，另一个是整型的数据成员b。
为满足上述要求，请填写下列程序的空白处。
……
___class_______A
{
___static______inta；
___int____b；
public：
___A______（inti）
{
b=i；
}
____static______voidf1（）；
};
……
7、P类公有继承Q类，P和Q类中都仅有一个私有的数据成员，P类中两个成员函数，一个是构造函数，另一个友元函数fun（）。
下列一段程序实现上述要求，请将空白处填上适当的内容。
……
ClassP：
_public________Q_______
{
Public:
P（inti，intj）：
___Q（j）_____
{
p=i；
}
__friend____voidfun（）；
Private：
__intp______；
}；
……
三、判断题
√1、构造函数可以重载。
√2、类的数据成员不一定都是私有的。
√3、对象数组的元素应该是同类的对象。
×4、在私有继承中，基类中只有公有成员对派生类是可见的。
√5、抽象类是不能创建对象的。
√6、定义一个对象时，系统总会对该对象进行初始化的。
×7、静态对象的成员称为静态成员。
√8、this指针是指向对象的指针，是系统自动生成的。
√9、运算符new可以创建对象，也可创建对象数组。
√10、C++语言对标准文件的读写函数与对磁盘文件的读写函数是一致的。
×11、在私有继承中，基类中只有公有成员对派生类是可见的。
√12、引用可以作函数参数，不能作函数的返回值。
√13、抽象类是不能创建对象的。
√14、C++语言既支持单继承，又支持多继承。
×15、没有参数的构造函数称为默认构造函数，该构造函数一定是系统自动生成的。
√16、在用一个对象给同类的另一个对象赋值时，调用拷贝初始化构造函数。
√17、友元类中的所有成员函数都是友元函数。
√18、运算符new可以创建对象，也可创建对象数组。
×19、定义派生类时必须指出基类名和继承方式，二者都不可默认。
√200、C++语言对标准文件的读写函数与对磁盘文件的读写函数是一致的。
四、分析下列程序的输出结果
1、#include
usingnamespacestd;
classM
{
inta;
public:
M（）{a=0;}
M（inti）{a=i;cout<<"inM\n";}
intgeta（）{returna;}
};
voidmain（）
{
Mr1,r2（18）;
cout<cout<}
答案：
inM
0
18
2、#include
usingnamespacestd;
classB
{
public:
B（）
{cout<<++b<~B（）
{cout<staticintGetb（）
{returnb;}
private:
staticintb;
};
intB:
:
b=10;
voidmain（）
{
Bb1,b2,b3;
cout<:
Getb（）<}
答案：
11
12
13
13
13
12
11
3、#include
usingnamespacestd;
classC
{
public:
C（inti,intj）
{c1=i;c2=j;}
voidSum（Ca,Cb）
{
c1=a.c1+b.c1;
c2=a.c2+b.c2;
}
voidPrint（）
{cout<<"c1="<private:
intc1,c2;
};
voidmain（）
{
Ca（60,90）;
Cb（a）;
Cc（b）;
c.Sum（a,b）;
c.Print（）;
}
答案：
c1=120,c2=180
4、#include
usingnamespacestd;
classA
{
public:
A（）
{
a1=a2=0;
cout<<"Defaultconstructorcalled.\n";
}
A（inti,intj）;
~A（）
{cout<<"Destructorcalled.\n";}
voidPrint（）
{cout<<"a1="<private:
inta1,a2;
};
A:
:
A（inti,intj）
{
a1=i;
a2=j;
cout<<"Constructorcalled.\n";
}
voidmain（）
{
Aa,b（5,8）;
a.Print（）;
b.Print（）;
}
答案：
Defaultconstructorcalled.
Constructorcalled.
a1=0,a2=0
a1=5,a2=8
Destructorcalled.
Destructorcalled.
5、#include
usingnamespacestd;
classA
{
public:
A（）
{a1=a2=0;}
A（inti,intj）
{a1=i;a2=j;}
~A（）
{cout<<"A\n";}
A（A&a）
{
a1=a.a1+2;a2=a.a2+2;
cout<<"C\n";
}
voidprint（）
{cout<private:
inta1,a2;
};
voidfun（A&a）
{
Ab;
b=a;
b.print（）;
}
voidmain（）
{Ax（4,8）,y;
Ap（x）;
y=x;
fun（p）;
y.print（）;
}
答案：
C
16
A
12
A
A
A
6、#include
usingnamespacestd;
classA
{
public:
voidInitA（inti,intj）
{a1=i;a2=j;}
voidMove（intx,inty）
{a1+=x;a2+=y;}
intGeta1（）
{returna1;}
intGeta2（）
{returna2;}
private:
inta1,a2;
};
classB:
publicA
{
public:
voidInitB（inti,intj,intk,intl）
{
InitA（i,j）;
b1=k;
b2=l;
}
voidMove（intx,inty）
{b1+=x;b2+=y;}
intGetb1（）
{returnb1;}
intGetb2（）
{returnb2;}
private:
intb1,b2;
};
classC:
publicB
{
public:
voidfun（）
{Move（10,15）;}
};
voidmain（）
{
Cc;
c.InitB（11,12,13,14）;
c.fun（）;
cout<}
答案：
11，12，23，29
1.#include
voidmain（）
{
inta=40;
while（--a）
{
if（a==20）
break;
if（a%2==0||a%3==0||a%5）
continue;
cout<}
}
答案：
34
24
2、#include
usingnamespacestd;
classDate
{
public:
Date（inty,intm,intd）
{
year=y;
month=m;
day=d;
}
friendvoidPrint（Date&）;
private:
intyear,month,day;
};
voidPrint（Date&d）
{
cout<}
voidmain（）
{
Dated1（2005,10,1）,d2（2005,12,9）;
Print（d1）;
Print（d2）;
}
答案：
2005/10/1
2005/12/9
3、#include
usingnamespacestd;
classA
{
public:
A（）
{a=0;}
A（inti）
{a=i;}
intGeta（A&m）;
private:
inta;
};
intA:
:
Geta（A&m）
{returnm.a;}
voidmain（）
{
Ad（6）;
cout<}
答案：
6
4、#include
classD
{
public:
D（）
{
d1=d2=0;
cout<<"Defaultconstructorcallrd.\n";
}
D（inti,intj）
{
d1=i;d2=j;
cout<<"Constructorcalled."<<"d1="<}
~D（）
{cout<<"Destructorcalled."<<"d1="<voidSet（inti,intj）
{d1=i;d2=j;}
private:
intd1,d2;
};
voidmain（）
{
intn=10,m=20;
Dd[4]={D（5,7）,D（3,6）,D（7,9）,D（1,4）};
for（inti=0;i<4;i++）
d[i].Set（n++,m++）;
}
答案：
Constructorcalled.d1=5,d2=7
Constructorcalled.d1=3,d2=6
Constructorcalled.d1=7,d2=9
Constructorcalled.d1=1,d2=4
Destructorcalled.d1=13,d2=23
Destructorcalled.d1=12,d2=22
Destructorcalled.d1=11,d2=21
Destructorcalled.d1=10,d2=20
5、#include
usingnamespacestd;
classPQ
{
public:
PQ（inti=0）
{p=i;}
voidprint（）
{cout<~PQ（）
{cout<<"PQ"<private:
intp;
};
PQa（8）;
voidmain（）
{
PQ*p1,*p2;
p1=newPQ（7）;
p2=newPQ[2];
p2[0]=a;
p2[1]=*p1;
（*p1）.print（）;
p2[0].print（）;
p2[1].print（）;
delet
升级会员 