C/C++測試題
面向對象
選擇題：
C++概述
1、以下C++新增的關鍵字為 D 。
A break
B continue
C stuct
D inline
2、面向對象程序設計將數據與__A___放在一起，作為相互依存、不可分割的整體來處理。
A對數據的操作 B信息 C數據隱藏 D數據抽象
3、面向對象程序設計優于傳統的結構化程序設計，其優越性主要表現在，它有希望解決軟件工程的兩個主要問題：軟件復雜性和__A____。
A 軟件生產率的提高 B 精化已有的代碼 C 共享代碼 D 編寫可重用代碼
4、面向對象系統的____B__是一種信息隱藏技術，目的在于將對象的使用者與設計者分開，使用者不必知道對象行為實現的細節，只需用設計者提供的協議命令對象去做即可。
A多態性 B封裝性 C繼承性 D復用性
5、___A___不是面向對象系統所包含的要素
A重載 B對象 C類 D繼承
6、關于C++與C語言的關系的描述中，____D__是錯誤的。
A C語言是C++的一個子集 B C++與C語言是兼容的
C C++對C語言進行了一些改進 D C++與C語言都是面向對象的
7、下面關于對象概念的表述中，___A___是錯誤的。
A 對象就是C語言中的結構變量
B 對象代表著正在創建的系統中的一個實體
C 對象是一個狀態和操作（或方法）的封裝體
D 對象之間的信息傳遞是通過信息進行的
8、下面關于類概念的表述中，_____D_是錯誤的。
A 類是抽象數據類型的實現 B 類是具有共同行為的若干對象的統一描述體
C 類是創建對象的樣板 D 類就是C語言中的結構類型
9、下列關于C++類的描述中錯誤的是___C___。
A 類與類之間可以通過一些手段進行通信和聯絡
B 類用于描述事物的屬性和對事物的操作
C 類與類之間必須是平等關系，而不能組成層次關系
D 類與類之間可以通過封裝而具有明確的獨立性
10、下列關鍵字中,____B__既在C語言中使用，又在C++語言中使用
A inline B break C private D public
11、C++對C語言做了很多改進。下列描述中___D___使得C語言發生了質變，即從面向過程變成了面向對象
A增加了一些新的運算符 B允許函數重載，并允許設置默認參數
C規定函數說明必須用原型 D引進了類和對象的概念
12、下列C++標點符號中表示行注釋開始的是___C___。
A # B ； C // D }
13、下列關于C++與C語言關系的描述中錯誤的是__C____。
A C++是C語言的超集 B C++對C語言進行了擴充
C C++|與C語言都是面向對象的程序設計語言 D C++包含C語言的全部語法
14、下列正確的選項是________A______。
A 繼承是創建一個具有另一個類的屬性和行為的新類的能力
B C語言支持面向對象的程序設計
C 空白符是一種可以被編譯的符號
D 標識符不宜太長，一般設定為16個字符
15、下列關于多態說法錯誤的是__B_______。
A 不同的對象調用相同名稱的函數，并可導致完全不同的行為的現象稱為多態性
B C++語言中多態性通過使用封裝技術來支持
C 多態是面向對象程序設計的一個重要機制
D 多態是人類思維方式的一種模擬
類和對象
16、以下類的說明，請指出錯誤的地方_____A___。
Class CSample
{
int a = 2; (A)
CSample(); (B)
Public:
CSample(int val); (C)
~CSample(); (D)
}
17、有關類的說法不正確的是____D____。
A 類是一種用戶自定義的數據類型
B 只有類中的成員函數才能存取類中的私有數據
C 在類中，如果不做特別說明，所有的數據類型均為私有類型
D 在類中，如果不做特別說明，所有的成員函數均為公有類型
18、有關類和對象的說法下列不正確的有____C____。
A 對象是類的一個實例 B 任何一個對象只能屬于一個具體的類
C 一個類只能有一個對象 D 類與對象的關系和數據類型和變量的關系
19、關于類和對象，以下敘述正確的是__B____
A 一個類的成員函數可以任意調用
B 通常，只有通過具體的對象，才能訪問類的成員函數
C 對象是模板，類是實例
D 類和對象間沒有任何關系
20、有關構造函數的說法不正確的是____D____。
A 構造函數名字和類的名字一樣 B 構造函數在說明類變量時自動執行
C 構造函數無任何函數類型 D 構造函數有且只有一個
21、有關析構函數的說法不正確的是___C_____。
A 析構函數有且只有一個
B 析構函數無任何函數類型
C 析構函數和構造函數一樣可以有形參
D 析構函數的作用是在對象被撤銷時收回先前分配的內存空間
22、在類的定義體外定義成員函數時，需要在函數名前加上__B______。
A 類標記 B 類域標記 C 類對象 D 域運算符
23、在類的定義形式中，數據成員、成員函數和___A____組成了類定義體。
A 成員的訪問控制消息 B 公有消息 C 私有消息 D 保護消息
24、____C____的功能使對對象進行初始化。
A 析構函數 B 數據成員 C 構造函數 D 靜態成員函數
25、若Q是類，a是它的一個對象，p1是類對象a的一個指針，那么類對象a可以通過①___B____來訪問類的成員，類對象a的指針p1可以通過②_____D__來訪問類的成員。
A ：： B . C ； D ->
26、下列的各類函數中，___C______不是類的成員函數
A 構造函數B 析構函數 C 友元函數 D 拷貝初始化構造函數
27、通常拷貝初始化構造函數的參數是______C____。
A 某個對象名 B 某個對象的成員名 C 某個對象的引用名 D 某個對象的指針名
28、類模板的使用實際上是將類模板實例化成一個具體的____A___。
A 類 B 對象 C 函數 D 模板類
29、模板是實現類屬機制的一種工具，其功能非常強大，它既允許用戶構造類屬函數，既① ____B___；也允許用戶構造類屬類，即② ______D__。
A 函數模板 B模板函數 C 類模板 D 模板類
30、關于對象的this指針，以下敘述正確的是__B____
A 必須顯式地在類定義中聲明this數據成員，才能使用this指針
B 一旦生成一個對象，該對象的this指針就指向該對象本身
C 一個類的所有對象的this指針的值都是相同的
D 不能通過對象的this指針訪問對象的數據成員和成員函數
31、關于new運算符的下列描述中， D 是錯誤的。
A 它可以用來動態創建對象和對象數組
B 使用它創建的對象或對象數組，可以使用運算符delete刪除
C 使用它創建對象時要調用構造函數
D 使用它創建對象數組時必須指定初始值
32、關于delete運算符的下列描述中， C 是錯誤的。
A 它必須用于new返回的指針
B 它也適用于空指針
C 對一個指針可以使用多次該運算符
D 指針名前只用一對方括號，不管所刪除數組的維數
繼承和派生
33、C++中的類有兩種用法：一種是類的實例化，即生成類的對象，并參與系統的運行；另一種是通過________，派生出新的類。
A 復用 B 繼承 C 單繼承 D 多繼承
//答案：B
34、繼承具有_______,即當基類本身也是某一個類的派生類時，底層的派生類也會自動繼承間接基類的成員。
A 規律性 B 傳遞性 C 重復性 D 多樣性
//答案：B
35、派生可以分為①________和②_________。由②________得到的派生類，其基類的所有公有成員都只能成為它的私有成員，這些私有成員只能被派生類的成員函數訪問，而③________無權訪問；①________的意義是基類中所有公有成員在派生類中也都是公有的。
A 公有派生 B 派生類的使用者 C 私有派生 D 派生類的構造函數
//答案：①A②C③B
36、基類的①________不能為派生類的成員訪問，基類的②_______在派生類中的性質和繼承的性質一樣，而基類的③_______在私有繼承時在派生類中成為私有成員函數，在公有和保護繼承時在派生類中仍為保護成員函數
A 公有成員 B 私有成員 C 私有成員函數 D 公有成員函數
//答案：① B②A③D
37、子類的數據成員和成員函數除了有從父類繼承而來的外，還有：
A 子類不能擁有自己的數據成員和成員函數
B 子類可以新添自己的數據成員，但成員函數只能從父類繼承
C 子類可以新添自己的成員函數，但數據成員只能從父類繼承
D 子類可以擁有自己獨特的數據成員和成員函數
//答案：D
38、在構造一個類的對象時，如果該類是從另一個類繼承的，則構造函數的調用順序是
A 同類的繼承關系無關
B 先調用父類的構造函數，然后調用本類的構造函數
C 先調用本類的構造函數，然后調用父類的構造函數
D 不用調用構造函數
//答案：B
39、在析構一個類的對象時，如果該類是從另一個類繼承的，則析構函數的調用順序是
A 同類的繼承關系無關
B 先調用父類的析構函數，然后調用本類的析構函數
C 先調用本類的析構函數，然后調用父類的析構函數
D 不用調用析構函數
//答案：C
重載、多態和虛函數
40、下列運算符中，________運算符在C++中不能重載。
A ?: B + C – D <=
//答案：A
41、下列運算符中，________運算符在C++中不能重載。
A && B [ ] C ：： D new
//答案：C
42、如果一個類至少有一個純虛函數，那么就稱該類為________。
A 抽象類 B 虛基類 C 派生類 D 以上都不是
//答案：A
43、下列描述中，________是抽象類的特性。
A 可以說明虛函數
B 可以進行構造函數重載
C 可以定義友元函數
D 不能說明其對象
//答案：D
44、關于動態聯編的下列描述中，________是錯誤的。
A 動態聯編是以虛函數為基礎的
B 動態聯編是在運行時確定所調用的函數代碼的
C 動態聯編調用函數操作是指向對象的指針或對象引用
D 動態聯編是在編譯時確定操作函數的
//答案：D
45、關于虛擬成員函數，以下敘述正確的是________
A 析構函數同構造函數一樣，不能是虛擬的
B 在一個類中被定義為虛擬的成員函數，其所有的派生類中相同的成員函數都是虛擬的
C 帶有虛擬函數的類不能直接生成對象，只有其子類才能生成對象
D 虛擬成員函數同普通成員函數不同，不能調用父類的虛擬成員函數
//答案：B
46、關于虛函數的描述中， 是正確的
A 虛函數是一個static類型的成員函數
B 虛函數是一個非成員函數
C 基類中說明了虛函數后，派生類中與其對應的函數可不必說明為虛函數
D 派生類的虛函數與基類的虛函數具有不同的參數個數和類型
//答案：C
填空題：
C++概述
47、寫出除class ，private， protected，public之外的任意五個C++新增的關鍵字 、 、 、 、 。
參考//答案：catch, ,const,delete,friend,new,operator, template,this,throw,try,virtual
48、_____________是指一種事物保留了另一種事物的全部特征，并且有自身的獨有特征。
//答案：繼承
49、C++語言中使用函數重載、模板、__________等概念來支持多態性。
//答案：虛函數
50、在C++中有兩種類型的注釋，一種是C語言中使用的注釋符（/*···*/），另一種是______。
//答案：//
51、在C++類中可以包含_______、_____和______三種具有不同訪問控制權的成員。
//答案：public、protected、private
類和對象
52、類中的數據和成員函數默認類型為_________。
//答案：私有
53、任何類中允許有三種權限的數據成員 、 、 。
//答案： public private protected
54、靜態數據成員在定義或說明時前面要加上關鍵字 。
//答案：static
55、以下程序運行的結果_________。
#include “iostream.h”
class CSample
{
private:
int i;
public:
CSample();
CSample(int val);
void Display();
~CSample();
};
CSample::CSample()
{
cout << “Constructor1” << endl;
i=0;
}
CSample:: CSample(int val)
{
cout << “Constructor2” << endl;
i=val;
}
void CSample::Display()
{
cout << ”i=” << i << endl;
}
CSample::~CSample()
{
cout << “Destructor” << endl;
}
void main()
{
CSample a, b(10);
a.Display();
b.Display();
}
//答案：
Constructor1
Constructor2
i=0
i=10
Destructor
Destructor
56、以下程序執行的結果是_____________________。
#include <iostream.h>
class B
{
int x,y;
public:
B() {x = y = 0; cout << “Constructor1” << endl;}
B(int i) {x = i; y = 0; cout << “Constructor2” << endl;}
B(int i ,int j) {x = i; y = j; cout << “Constructor3” << endl;}
~B() {cout << “Destructor” << endl;}
void print() {cout << “x=” << x << “,y=” << y << endl;}
};
void main()
{
B *ptr;
ptr = new B[3];
ptr[0] = B();
ptr[1] = B(5);
ptr[2] = B(2,3);
for (int i=0;i<3;i++)
ptr[i].print();
delete[] ptr;
}
//答案：
Constructor1
Constructor1
Constructor1
Constructor1
Destructor
Constructor2
Destructor
Constructor3
Destructor
x=0,y=0
x=5,y=0
x=2,y=3
Destructor
Destructor
Destructor
57、以下程序執行的結果是_____________________。
class B{
int x,y;
public:
B() {x = y = 0; cout << "Constructor1" << endl;}
B(int i) {x = i; y = 0; cout << "Constructor2" << endl;}
B(int i ,int j) {x = i; y = j; cout << "Constructor3" << endl;}
~B() {cout << "Destructor" << endl;}
void print() {cout << "x=" << x << ",y=" << y << endl;}
};
void main(){
B *ptr;
ptr = new B[2]; ptr[0] = B();
ptr[1] = B(5); delete[] ptr;
}
//答案：Constructor1
Constructor1
Constructor1
Destructor
Constructor2
Destructor
Destructor
Destructor
58、以下程序執行結果是_____________。
#include <iostream.h>
class A
{
public:
A(int i=0) {m = i; cout << "Constructor" << m << endl; }
void set(int i) {m = i;}
void print() const {cout << m << endl;}
~A() {cout << "Destructor" << m << endl;}
private:
int m;
};
void fun(const A &c)
{
c.print();
}
void main()
{
fun(5);
}
//答案：
Constructor5
5
Destructor5
繼承和派生
59、以下程序執行結果是________________。
#include <iostream.h>
class A
{
public:
A(int i, int j) {a = i; b = j;}
void move (int x, int y) {a += x; b += y;}
void show() { cout << “(“ << a << “,” << b << “)” << endl;}
private:
int a, b;
};
class B:private A
{
public:
B(int i, int j, int k, int l):A(i, j)
{
x =k; y = l;
}
void show()
{ cout << x << “,” << y << endl;}
void fun() {move (3,5);}
void f1() { A::show();}
private:
int x, y;
};
void main()
{
A e(1,2);
e.show();
B d(3,4,5,6);
d.fun();
d.show();
d.f1();
}
//答案：(1,2)
5,6
(6,9)
void main()
{
A e(1,2);
e.show();
B d(3,4,5,6);
d.fun();
d.A::show();
d.B::show();
d.f1();
}
//答案： (1,2)
(6,9)
5,6
(6,9)
60、以下程序執行結果是________________
# include <iostream.h>
class A {
int a;
public:
A(int aa=0) { a=aa; }
~A() { cout <<"Destructor A!"<<a<<endl; }
};
class B:public A {
int b;
public:
B(int aa=0,int bb=0):A(aa) { b=bb; }
~B() { cout <<"Destructor B!"<<b<<endl; }
};
void main() {
B x(5),y(6,7); // 后定義的變量將先被釋放
}
//答案：
Destructor B! 7
Destructor A! 6
Destructor B! 0
Destructor A! 5
重載多態和虛函數
61、以下程序執行結果是________________。
#include <iostream.h>
class base
{
public:
base()
{
cout << “構造base子對象” << endl;
f();
}
virtual void f()
{
cout << “調用base::f()” << endl;
}
};
class derived : public base
{
public:
derived()
{
cout << “構造derived對象” << endl;
f();
}
void f()
{
cout << “調用derived :: f()” << endl;
}
};
void main()
{
derived d;
}
//答案：
構造base子對象
調用base::f()
構造derived對象
調用derived :: f()
62、以下程序執行結果是________________。
#include <iostream.h>
class base
{
public:
base() {
cout << “Constructor base subobject” << endl;
f(); }
virtual void f() {
cout << “Call base::f()” << endl; }
};
class derived : public base
{
public:
derived() {
cout << “Constructor derived object” << endl;
f(); }
void f() {
cout << “Call derived :: f()” << endl; }
};
void main(){
derived d;
}
//答案：
Constructor base subobject
Call base::f()
Constructor derived object
Call derived :: f()
63、以下程序執行結果是________________。
#include <iostream.h>
class Sample
{
private:
int x;
public:
Sample() {x = 0;}
void disp()
{
cout << “x=” << x << endl;
}
void operator ++() {x += 10;}
};
void main()
{
Sample obj;
obj.disp();
obj ++;
cout << “執行obj++之后” << endl;
obj.disp();
}
//答案：
x=0
執行obj++之后
x=10
64、以下程序執行結果
#include <iostream.h>
class base
{
public:
virtual void f1()
{ cout<<"f1 fuc of base"<<endl;}
virtual void f2()
{ cout<<"f2 fuc of base"<<endl;}
virtual void f3()
{ cout<<"f3 fuc of base"<<endl;}
void f4()
{ cout<<"f4 fuc of base"<<endl;}
};
class derive : public base
{
void f1()
{ cout<<"f1 fuc of derive"<<endl;}
void f2(int x)
{ cout<<"f2 fuc of derive"<<endl;}
void f4()
{ cout<<"f4 fuc of derive"<<endl;}
};
void main()
{
base obj1, *p;
derive obj2;
p = &obj1;
p->f1();
p->f2();
p->f3();
p = &obj2;
p->f1();
p->f2();
p->f4();
}
//答案：
f1 fuc of base
f2 fuc of base
f3 fuc of base
f1 fuc of derive
f2 fuc of base
f4 fuc of base
解析題：
*65、指出程序中的錯誤，并予以改正（全部重寫）
#include “iostream.h”
class point
{int x1;
public:
int x2;
public:
point(int x, int y);
//......
};
void main()
{ point data(5,5);
cout << data.x1 << endl;
cout << data.x2 << endl;
}
//答案：構造函數定義不正確，在main()中對數據成員x1訪問不正確
改正：
#include “iostream.h”
class point
{int x1;
public:
int x2;
public:
point(int x)
{
x1=x;
}
void disp()
{
cout << x1 << endl;
}
};
void main()
{
point data(5);
data.disp();
cout << data.x2 << endl;
}
或
#include “iostream.h”
class point
{
int x1;
public:
int x2;
public:
point(int x)
{
x1=x;
}
int disp()
{
return x1;
}
};
void main()
{
point data(5);
cout << data.disp() << endl;
cout << data.x2 << endl;
}
66、分析以下程序的執行的順序以及輸出結果
#include "iostream.h"
class Sample
{
public:
Sample()
{
cout << "構造函數" << endl;
}
};
void fn(int i)
{
static Sample c;
cout << "i=" << i << endl;
}
void main()
{
fn(10);
fn(20);
}
//答案：
程序中fn(int i)函數中的static Sample c; 語句定義的是一個靜態對象，僅在函數第一次進入時創建該對象，以后在進入時，c對象便始終存在，fn(int i)函數不再為其創建，所以程序執行結果如下：
構造函數
i=10
i=20
67、給出程序執行結果
#include <iostream.h>
class MyDataType
{
protected:
int m_nData;
public:
MyDataType( ) {
m_nData = -1;
cout << "Constructor MyDataType" << endl; }
MyDataType & operator = (int n) {
m_nData = n;
return *this; }
MyDataType & operator = (MyDataType & obj) {
m_nData = obj.m_nData;
return *this; }
MyDataType & operator + (MyDataType & obj2) {
static MyDataType tempData;
tempData = m_nData + obj2.m_nData;
return tempData; }
operator int() { return m_nData; }//定義一個從MyDataType類型到int類型的轉換
};
void main()
{
MyDataType Obj1,Obj2;
Obj1 = 10;
Obj2 = Obj1;
MyDataType Obj3 = Obj1 + Obj2;
int nValue = (int)Obj3;
cout << "nValue = " << nValue << endl;
}
//答案：
Constructor MyDataType
Constructor MyDataType
Constructor MyDataType
nValue = 20
68、指出程序中的錯誤，改正并簡述原因
#include <iostream.h>
class Base
{
public:
void SetX(int i) {x = i;}
int GetX() {return x;}
private:
int x;
};
class Derived : public Base
{
public:
void SetY(int i) {y = i;}
int GetY() {return y;}
private:
int y;
};
void main()
{
Base *p;
Base b_ob;
Derived d_ob;
p = &b_ob;
p->SetX(11);
cout << "base object x:" << p->GetX() << endl;
p = &d_ob;
p->SetX(55);
cout << "base object x:" << p->GetX() << endl;
p->SetY(99);
cout << "derived object y:" << p->GetY() << endl;
}
//答案：p->SetY(99)是錯誤的，改為d_ob.SetY(99)
基類指針雖然可以指向派生類的對象，但是只可以訪問派生類中從該基類繼承下來的的那些成員（如GetX()）。基類指針指向的對象只認識基類，而不知道關于派生類的成員信息。
69、分析程序給出運行結果
#include <iostream.h>
class Base
{
public:
virtual void show()
{cout<<"Parent class.\n";}
};
class First: public Base
{
public:
void show()
{cout<<"First Derived class.\n";}
};
class Second :public Base
{
public:
void show()
{cout<<"Second Derived class.\n";}
};
void main()
{
Base b1, *ptr;
First f1;
Second s1;
ptr = &b1;
ptr->show();
ptr = &f1;
ptr->show();
ptr = &s1;
ptr->show();
}
//答案：
Parent class.
First Derived class.
Second Derived class.
70、分析程序給出運行結果，說明原因
#include <iostream.h>
class Base
{
public:
void show()
{cout<<"Parent class.\n";}
};
class First: public Base
{
public:
void show()
{cout<<"First Derived class.\n";}
};
class Second :public Base
{
public:
void show()
{cout<<"Second Derived class.\n";}
};
void main()
{
Base b1, *ptr;
First f1;
Second s1;
ptr = &b1;
ptr->show();
ptr = &f1;
ptr->show();
ptr = &s1;
ptr->show();
}
//答案：
Parent class.
Parent class.
Parent class.
由于基類中show函數沒聲明成虛函數，這時的函數調用是在編譯時靜態聯編的。
posted on 2011-05-31 22:05
DoubleW 閱讀(2722)
評論(0) 編輯 收藏 引用