C++习题1——24、30—

24、C++程序下列说法正确的有（ )  

A)对调用的虚函数和模板类都进行迟后编译     

B)基类与子类中函数如果要构成虚函数，除了要求在基类中用virtual声明，而且必须名字相同且参数类型相同返回类型相同  

C)重载的类成员函数都必须要：或者返回类型不同，或者参数数目不同，或者参数序列的类型不同

D)静态成员函数和内联函数不能是虚函数，友员函数和构造函数也不能使虚函数，但是析构函数可以。

ABD

迟后编译：编译的时候，无法确定具体的执行情况

调用虚函数与多态不同，多态分为静态多态和动态多态，动态多态是动态捆绑的，是迟后编译

但静态多态是通过重载或模板实现，静态编译发时候可以确定

模板的迟后编译：定义时，无法确定类型，所以是迟后编译，调用时会再次编译

template和class MyTemplate{};没有区别，但第二个更好

eg：vector 当没给具体类型时，无法确定，只有使用时才能确定

C错误 返回类型没有要求

30、 一动态链接库发布的导出类如下，以下哪种做法对该类的更新是没有问题的？（只列出改动部分）

class __declspec(dellexport)PubliClass

{

public:

 virtual void A();

 virtual void B();

 void C();

 friend void D();

 //...

};  // 和以前不同不行

A:       class PubliClass{/*...*/ };

B:       virtual void B(); virtual void A();

C:       void C()const;

D:       void D();

B

动态链接库（Dynamic Link Library，简称DLL）是一种在Windows操作系统中使用的可执行文件格式，它包含了可以被其他程序或DLL在运行时调用的函数和数据。在Linux和其他类Unix系统中，类似的文件被称为共享库（Shared Library），通常以.so为文件扩展名。

动态链接库发布的导出类是指在一个DLL中定义并可以被其他程序或DLL使用的类。这些类通常包含一些可以被外部访问的成员函数和数据成员。为了使这些类在DLL外部可用，需要使用特定的关键字或宏来声明它们，以便它们在DLL的导出表中可见。

A错误 A完全重定义了类，而没有提供任何成员函数的实现，这显然会破坏二进制兼容性，因为类的所有成员函数都需要重新链接到新的实现上。

B正确 B仅仅改变了成员函数的声明顺序。在C++中，虚函数的顺序变化不会影响二进制兼容性，只要函数的签名（返回类型、函数名、参数类型和数量）没有改变

C错误 C改变了成员函数C的签名，添加了const关键字。这是一个二进制不兼容的改动，因为const成员函数和非const成员函数被视为不同的函数，这会破坏已有代码的链接

D错误 D试图将友元函数D变成类的成员函数。这是不正确的，因为友元函数不是类的成员，这种改动会改变类的接口，导致二进制不兼容__declspec(dllexport) 是Microsoft Visual C++中的一个特定于编译器的扩展，它用于在编译时指示编译器，随后的声明或定义应该被导出，使其在生成的动态链接库（DLL）中对外部可见。

__declspec(dellexport)PubliClass：
__declspec: 这是一个编译器特定的关键字，用于指定变量的存储类信息。
(dllexport): 这是 __declspec 的一个参数，用于指示随后的项（在本例中是类 PubliClass）应该被导出，即它应该在DLL的导出表中列出，这样其他程序或DLL就可以使用它。
PubliClass: 这是你要导出的类的名称。
当你在DLL项目中使用 __declspec(dllexport) 时，它告诉编译器和链接器，PubliClass 类的所有公共成员（包括构造函数、析构函数、成员函数和数据成员）都应该被导出，使得其他应用程序或DLL可以创建这个类的实例，调用其成员函数，或者访问其数据成员。
例如：
// MyDll.h
#ifdef EXPORTING_DLL
#define DLL_API __declspec(dllexport)
#else
#define DLL_API __declspec(dllimport)
#endif
class DLL_API PubliClass {
public:
    PubliClass();
    virtual ~PubliClass();
    // ... 其他公共成员 ...
};
在这个例子中，EXPORTING_DLL 宏在DLL项目的编译时定义，而 DLL_API 宏则根据是否导出或导入来展开为 __declspec(dllexport) 或 __declspec(dllimport)。当其他应用程序或DLL想要使用 PubliClass 时，它们会包含这个头文件，并定义 DLL_API 为 __declspec(dllimport)，这样它们就可以导入 PubliClass 类而不需要知道其实现细节。

31、有一段年代久远的C++代码，内部逻辑复杂，现在需要利用其实现一个新的需求，假定有以下可行的方案，

应当优先选择：

A、修改老代码的接口，满足新的需求

B、将老代码抛弃，自己重新实现类似的逻辑

C、修改老代码的内部逻辑，满足新的需求

D、这段代码之外，写一段代码，调用该代码的一些模块，完成新功能需求

D

32.下面那个操作符不能重载（）   

A. =

B. <

C.sizeof

D.%

C sizeof内建，是根基，不可以重载

33.派生类的对象对它的基类成员中，（）是可以访问的   

A、公有继承的公有成员

B、公有继承的私有成员

C、公有继承的保护成员

D、私有继承的公有成员

A 对象如果在类外，保护的不可以；对象在类内，可以

34.下面关于顺序容器使用的描述哪个是错误的（）

A、需要随机访问某个元素应该使用vector或者deque

B、需要在头部和尾部插入元素的应该使用vector

C、需要在中间插入或者删除元素的应该使用list

D、如果需要考虑空间问题，元素较多时，尽量不使用list

AB

A错误 随机访问指查找到在O(1)时间内找到，与存储位置无关，使用链表查找慢

B错误

D正确 list里面含有数据域和指针域，数据多，要分出一般的空间存储指针

35.类B是类A的公有派生类，类A和类B都定义了虚函数func(), ptr是指向类B的指针，则ptr->A::func()将  

A、即调用类A的函数也调用B类的函数

B、根据ptr所指的对象类型确定调用类A或类B中的函数

C、调用类B中的函数

D、调用类A中的函数

D 含有A::，确定调用A类的函数，编译时确定

36.下面程序的输出是什么（）

#include

class A

{public:

A() {      std::cout << "A is created." << std::endl;    }

~A(){     std::cout << "A is deleted." << std::endl;    }

};

class B :public A

{public:

B(){       std::cout << "B is created." << std::endl;     }

~B(){     std::cout << "B is deleted." << std::endl;    }

};

int _tmain(int argc, _TCHAR *argv[])

{

A *pA = new B();

delete pA;

return 0;

}

A.B is created.A is deleted.

B.B is created.B is deleted.

C.A is created.B is created.A is deleted.

D.A is created.B is created.B is deleted.A is deleted.

C 只有父类的被回收

37.下列的程序的输出结果是（）

#include

using namespace std;

class A

{public:

int _a;

A(){  _a = 1;     }

void print(){  printf("%d",_a);   }

};

class B:public A

{public:

int _a;

B(){    _a = 2;   }

};

int main()

{

B b;

b.print(); 

printf("%d",b._a);   

return 0;

}

A 2 2

B 1 1

C 1 2

D 2 1

C 空间独立，不会覆盖

38. 下列情况中，哪一种情况不会调用拷贝构造函数（）

A 用派生类的对象取初始化基类对象时     

B 将类的一个对象赋值给该类的另一个对象时 

C 函数的形参是类的对象，调用函数进行形参和实参结合时

D 函数的返回值是类的对象，函数执行返回调用者时

B不会 赋值是重载操作符

class A
{
    A(const A&a)
    {

    }
}

class B:public A
{

}

B b;
A a(b);

39.下面关于构造函数和析构函数的描述，错误的是（）

A 析构函数中调用虚函数采用静态联编   

B 对析构函数的调用可以采用动态联编   

C 当基类的析构函数是虚函数时，其派生类的析构函数也一定是虚函数

D 构造函数可以声明为虚函数

A正确 在构造和析构中，调用虚函数，一定是静态的，是编译时确定的

D

40.下列有关于继承和派生的叙述中，正确的是（）  

A 派生类不能访问积基类的保护成员 

B 作为虚基类的类不能被实例化

C 派生类应当向基类的构造函数传递参数

D 虚函数必须在派生类中重新实现

C

B 虚基类的类：虚继承的父类可以实例化

41.函数参数使用的空间是在（）中申请的，malloc和new实在（）中申请的    

A 堆，栈

B 栈 ，堆

C 栈，栈

D堆，堆

B

42.适宜采用inline 定义函数情况是（） 

A 函数体含有循环语句

B 函数体含有递归语句

C 函数代码少 频繁调用

D 函数代码多 不常调用

C 编译建议，不是强制内联

43.下列不能作为类的成员的是（）  

A 自身类对象的指针

B 自身类对象

C 自身类对象的引用

D 另一个类的对象

B 会循环构造

C 可以

44.友元关系不能  

A 提高程序的运行效率

B 是类与类的关系

C 是一个类的成员函数与另一个类的关系

D 继承

D

45.有关C++编译指令，以下叙述正确的是（） 

A C++的编译指令可以以#或//开始  

B C++中不管#if后的常量表达式是否为真，该部分都需要编译    

C C++每行不可以写多条编译指令   

D #include指令中的文件名不可以含有路径信息

C

编译指令：#...编译指令

A错误 注释不行

B错误 #if为假，灰色的，不参与编译

46.假定A为一个类，则执行"A a(2),b[3],*p[4];"语句时调用该类构造函数的次数为（） 

A.3

B.4

C.5

D.9

B 在执行语句 "A a(2), b[3], *p[4];" 时，构造函数的调用次数如下：
A a(2); 调用了一次构造函数，以初始化对象 a。
A b[3]; 是一个对象数组，它包含3个 A 类型的对象，所以构造函数被调用了3次，分别用于初始化 b[0]、b[1] 和 b[2]。
A *p[4]; 是一个指针数组，它本身不调用构造函数，因为它只是分配了4个指向 A 类型的指针的空间，而没有创建 A 类型的对象。
因此，构造函数总共被调用了 1 + 3 = 4 次。

加A a1(a)调用拷贝构造 加A&refa=a;是起别名

47.已知p是一个指向类A数据成员m的指针，a是类A的一个对象。如果要给m赋值为5正确的是（）

A.a.p=5;

B.a->p=5;

C.a.*p=5;

D.*a.p=5;

A·

48.已知f1和f2是同一类的两个成员函数，但f1不能直接调用f2,这说明()  

A.f1和f2都是静态函数

B.f1不是静态函数，f2是静态函数

C.f1是静态函数,f2不是静态函数

D.f1和f2都不是静态函数

C

49.下列说明语句中正确的是:（）

A.int a,&ra=a,&&ref=ra;

B.int &refa[[10];

C.int a,&ra=a,&*refp=&ra; 

D.int *pi,*&pref=pi;

C
A. int a, &raa, &&refra;
int a; 是正确的，声明了一个整型变量 a。
&raa; 是正确的，声明了一个整型引用 raa。但是，由于它没有在声明时立即初始化，这在某些编译器上可能会报错，因为引用在声明时必须初始化。
&&refra; 是错误的，因为在 C++ 中不存在 "引用的引用" 这种类型。引用必须是直接绑定到一个对象上，不能引用另一个引用。
B. int &refa[[10];
int &refa[[10]; 是错误的，因为它的语法不正确。首先，方括号 [[ 应该是单个方括号 [，其次，引用不能用于声明数组。正确的数组声明应该是 int refa[10];，但 refa 不能是引用，因为数组元素需要具体的地址来分配空间，而引用只是一个已存在对象的别名。
C. int a, &raa, &refp&ra;
int a; 是正确的，声明了一个整型变量 a。
&raa; 是正确的，声明了一个整型引用 raa，但同样需要在声明时初始化。
&refp&ra; 是错误的，因为这部分语法没有意义。&refp 看起来像是要声明一个引用，但是紧接着的 &ra 是一个错误的操作。引用不能这样声明，且 ra 在这里没有先被声明。
D. int pi, &prefpi;
int pi; 是正确的，声明了一个整型变量 pi。
&prefpi; 是正确的，声明了一个整型引用 prefpi。但是，这个引用没有在声明时初始化，所以这可能会在编译时产生错误。如果 prefpi 在后面被正确地初始化为指向 pi 的引用，那么这个声明就是有效的。
综上所述，所有选项都有问题，但如果考虑到初始化的问题，选项 D 在语法上是正确的，只要确保 prefpi 在使用前被正确初始化。在实际编程中，引用必须在声明时初始化，所以如果这些选项出现在实际的代码中，它们都需要修正。

50.此设计模式定义一组可选算法，执行逻辑时根据环境选择算法，不同算法产生不同输出结果. 以下哪种设计模式符合描述（） 

A.工厂facttory

B.抽象工厂abstract factory

C.策略strategy

D.观察者observer

C

51.请为以下场合选择合适的容器，需要频繁进行插入和删除_(1)_，需要在内存中快速查找_(2)_,需要在磁盘中快速查找_(3)_（）

A.vector/map/list

B.list/hash map/b tree

C.deque/tree map/vector

D.list/vector/map

B 磁盘红黑树

52.C++STL中list使用的迭代器类型是（）

A.Input iterator    B.Forward iterator

C.Bidirectional iterator    D.Random Access iterator

C

53.如果在一个有序的vector/map/set中进行数据查找，哪一个查找复杂度更低（ ）

A.vector    B.map    C.set    D.时间复杂度一样

D

54.以下关于STL容器描述正确的是（C）

A.STL容器是多线程安全的

B.STL容器中vector查找效率一般比map快

C.往STL容器放入对象是直接拷贝了一份对象到容器中，这部分内存由容器管理释放 拷贝构造

D.STL中的stack是采用红黑树实现的

mapm_map;

实现A的时候需要注意什么？重载操作符<>

map由红黑树实现

unordered_mapm_map;

实现A的时候需要注意什么?重载操作符==判断相等 实现取哈希的函数

unordered_map由哈希表实现

55.一个类的友元函数能够访问该类（D）

A.私有成员

B.保护成员

C.公有成员

D.所有成员

56.下列关于赋值运算符"=" 重载的描述中，正确的是(A).

A.赋值运算符只能作为类的成员函数重载   

B.默认的赋值运算符实现了“深层赋值”功能  

C.重载的赋值运算符函数有两个本类对象作为形参  

D.如果已经定义了复制（拷贝构造函数），就不能重载赋值运算符

57.已知fl(int )是类A的公有成员函数，P是指向成员函数f1()的指针，以下赋值写法正确的是p = &A::f1;   

58.抽象基类是指（C）

A.嵌套类

B.派生类

C.含有纯虚函数

D.多继承类

59. 下面说法正确的是（BC）

A:static函数在内存中只有一份，而其他非static函数每被调用一次内存中就会维持一份拷贝      

B:程序的局部变量存在于堆栈中，全局变量存在与静态区中，动态申请数据存在于堆中

C:char *const p,语句定义了常用量指针，p的值不可以修改，char const *p;语句中指向常量的指针，指向的常量值不可更改。

D: (void*)ptr和（*(void**)）ptr的结果是相同的。其中（ptr为同一个指针）

60. 关于delete描述符下列描述正确的是BD 

A:它必须用于new返回的指针    

B:使用它删除对象时会调用析构函数

C:对于一个指针可以使用多次该运算符

D:( 使用delete删除数组时 )指针名前只有一对方括号符号，不管所删除数组的位数

61.请问这个程序输出是什么？并说出原因?调用一次析构函数，程序会崩溃

#include"stdafx.h"

#include

class Book

{

public:

     Book(){ std::cout << "Book\n";}

     ~Book(){ std::cout << "~Book\n";}

};

int main()

{

Book* pBook = new Book[3];

delete pBook;

return 0;

}

62.请写出下面程序的执行结果

class base

{

public:

virtual void vrfun(){printf("base::vrfun()\n");}

void fun(){printf("base::fun()\n");}       

};

class derive : public base

{

public:

virtual void vrfun(){printf("derive::vrfun()\n");}

void fun(){printf("derive::fun()\n");}   

};

void main()

{

base baseObj;

derive deriveObj;

base* pBase = &baseObj;

pBase->vrfun();//base::vrfun()  

pBase->fun();//base::fun() 

pBase = &deriveObj;

pBase->vrfun(); //derive::vrfun()

pBase->fun();//base::fun()   

}

63.请挑出下述代码执行过程中会发生的事件，并按顺序排列父类构造 子类构造 父类析构；

struct Base

{

int val;

Base():val(0){}

~Base(){};

};

struct Derived : public Base{

Derived(){}

~Derived(){};

};

Base *p = new Derived;

delete p;

64.下列代码运行的结果是：a:2 b:3 a:2 2 

struct Foo

{

Foo(const char* name,int *p):m_name(name),m_p(p){

printf("%s:%d",name,++*p);

}

~Foo(){   printf("%s:%d",m_name,--*m_p);  }

const char* m_name;

int* m_p;

};

void fun(int *p){

Foo a("a",p);

new Foo("b",p);

}

int main(){

int a =1;

fun(&a);

printf("%d\n",a);

return 0;

}

65.下列程序

class A

{

public:

void print(){cout << "This is A " << endl; }

};

class B : public A

{

public:

void print(){cout << "This is B " << endl; }

};

int main(){

A a; B b;

A* p1 = &a;

A* p2 = &b;

p1->print();

p2->print();

}

上述函数的会输出什么？

This is A

This is A

若A类print定义为虚函数，结果又是什么？

This is A

This is B

是不是一个父类写了一个virtual函数，如果子类覆盖它的函数不加virtual，也能实现多态？

是

static变量能否继承，为什么？

不能，静态是共用，不能继承

66.请考虑标记为A到J的语句在编译时可能出现的情况。如果能编译成功，请记为“RIGHT”，否则记为“ERROR”。

#include

#include

class Parent

{

public:

Parent(int var = -1){

m_nPub = var;

m_nPtd = var;

m_nPrt = var;

}

public:

int m_nPub;

protected:

int m_nPtd;

private:

int m_nPrt;

};

class Child1 : public Parent

{

public:

int GetPub(){return m_nPub;};

int GetPtd(){return m_nPtd;};

int GetPrt(){return m_nPrt;};     //A  ERROR

};

class Child2 : protected Parent

{

public:

int GetPub(){return m_nPub;};

int GetPtd(){return m_nPtd;};

int GetPrt(){return m_nPrt;};     //B   ERROR

};

class Child3 : private Parent

{

public:

int GetPub(){return m_nPub;};

int GetPtd(){return m_nPtd;};

int GetPrt(){return m_nPrt;};     //C  ERROR

};

int main()

{

Child1 cd1;

Child2 cd2;

Child3 cd3;

int nVar = 0;

//public inherited

cd1.m_nPub = nVar;      //D  RIGHT

cd1.m_nPtd = nVar;        //E   ERROR

nVar = cd1.GetPtd();        //F  RIGHT

//protected inherited       

cd2.m_nPub = nVar;        //G  ERROR

nVar = cd2.GetPtd();        //H   RIGHT

//private inherited       

cd3.m_nPub = nVar;        //I  ERROR

nVar = cd3.GetPtd();        //J  RIGHT 

return 0;

}

67.下列程序的结果是什么？

#include

#include

#include

using namespace std;

class A

{

public:

char k[3];

virtual void aa(){};   

};  

class B : public virtual A  

{

public:

char j[3];

virtual void bb(){};

};

class C : public virtual B

{

public:

char i[3];

virtual void cc(){};

};

int main(int argc,char *argv[])

{

cout<<"sizeof(A):"<

cout<<"sizeof(B):"<

cout<<"sizeof(C):"<

return 0;

}

68.Find the defects in each of the following programs,and explain why it id incorrect.

#include

using namespace std;

class Base{

public:

int val;

Base(){val=1;};

};

class Derive:Base{//默认为私有继承    

public:

int val;

Derive(int i){val = Base::val+i;};

};

int main(int , char **, char**)

{

Derive d(10);

cout<

return 0;

}

69.Find the defects in each of the following programs,and explain why it id incorrect.

class base

{

private:

int i;

public:

base(int x){i=x;}

};

class derived:public base{

private int i;

public:

derived(int x,int y){i=x;}

void printTotal(){int total = i+base::i;}//base::i为私有，不可见

};

70.下面的程序有何错误？

#include

using namespace std;

class Shape

{

public:

Shape(){};

~Shape(){};

virtual void Dram()=0;

};

int main()

{

Shape s1;

}

含有纯虚函数的类不能实例化对象

71.哪一种成员变量可以在同一个类的实例中共享？静态

72.请问下面程序打印的结果是什么？

#include

#include

using namespace std;

class base

{

private:

int m_i;

int m_j;

public:

base(int i):m_j(i),m_i(m_j){}   

base():m_j(0),m_i(m_j){}

int get_i(){return m_i;}

int get_j(){return m_j;}

};

int main()

{

base obj(98);

cout << obj.get_i() << endl; //不确定值     

cout << obj.get_j() << endl; //98

return 0;

}

73.请看下面一段程序：

#include

#include

using namespace std;

class B

{

private:

int data;

public:

(1)B(){cout << "default constructor" << endl;    }

(2)B(const B & b){ cout << " copy constructor" <

(3)B& operator = ( const B & b) {cout << " operator = " <

(4)~B(){    cout << "destructed" << endl;}

(5)B(int i):data(i) {    cout << "constructed by parameter" << data << endl;}

};

B play(B b){//类型转换，给形参有参构造(5)

return b;//给返回值(临时对象)拷贝构造(2) 形参回收(4)

}

int main(){

B temp = play(5);//类型转换，临时对象给temp拷贝构造(2)，临时对象回收(4)

return 0;//temp回收(4)

}

1).该程序输出的结果是什么？为什么会有这样的输出？

本是(5) (2) (4) (2) (4) (4)，但是由于返回值优化，temp给临时对象拷贝构造，临时对象给temp拷贝构造，构造两次没有必要，只需要形参给temp拷贝构造，然后形参回收就可以了，这样就避免了临时对象的创建和销毁。

(5)类型转换，给形参有参构造

(2)形参给temp拷贝构造

(4)形参回收

(4)temp回收

2).B(int i):data(i) ,这种用法的专业术语叫什么？初始化列表

3).play(5),形参类型是类，而5是个常量，这样写合法吗？为什么？

合法，发生了隐式类型转换。

4)B temp ;

temp = play(5);

=处发生了一次拷贝构造(给临时对象拷贝构造)，临时对象给temp赋值。

所以输出为(1)temp的无参构造(5)类型转换，形参的有参构造(2)返回值(临时对象)的拷贝构造(4)形参的回收(3)临时对象给temp赋值(4)临时对象的回收(4)temp的回收

关键字explicit防止发生类型转换而产生对象。

74.阅读下面的程序段，写出运行结果

#include

#include

using namespace std;

int main(int argc ,char *argv[])

{

string eName(“Innovation Works”);

string cName(“创新工场”);

string& rs = eName;

string*ps = &eName;

rs = cName;//赋值  

cout <

ps = &eName;

cout << *ps<

}

75.class A

{

Public:

Fun1()    {printf(“Hello,world!\n”);}

Fun2()    {printf(“a=%d\n”,a);}

Private:

int a;

}

A *p = NULL;

p->Fun1();//正常输出  

p->Fun2();//崩溃，使用了this指针，而指针为空  

问：p->Fun1(),p->Fun2()有一个能正常输出，请指出函数并解释原因。

76.

class CSample

{

public:

CSample(){}

virtual ~CSample(){}; //虚析构，也是虚函数，有虚指针

short m_A;

char m_B;

int m_C;

};

32位系统下编译器以四字节对齐的方式编译代码时，sizeof（CSample）的值是：12。

77. 看下面的代码，写出运行结果

#include

using namespace std;

class A{

public:

A(){

cout<<”A::A()called”<

init();//构造或析构中调用虚函数是静态联编    

}

virtual ~A(){cout<<”A::~A()called”<

virtual void init(){cout<<”A::init()called”<

virtual void method(){cout<<”A::method()called”<

};

class B:public A

{

public:

B():A(){   cout<<”B::B()called”<

~B(){    cout<<”B::~B()called”<

void init(){   cout<<”B::init()called”<

void method(){  cout<<”B::method()called”<

};

void main(){

A *a=new B();   

a->method();  

delete a;    

}   

A::A()called

A::init()called

B::B()called

B::method()called

B::~B()called

A::~A()called

78.请仔细阅读以下代码，你觉得有问题吗？若没有问题，请将运行写出来，若有问题，请在更正后将运行结果写出来。

class A

{

public:

A(){};

~A(){};

void allocateMemory(char* lpTarget)  

{

lpTarget = (char*)malloc(29);   

}

void setNewData()

{

this->allocateMemory(this->m_lpNewData);

strcpy(m_lpNewData,”Roman wasn’t built in a day.\n”);    

printf(m_lpNewData);

}

private:

char * m_lpNewData;

char m_cMyChar;

short int m_siMyAge;

long m_lMyYear;

};

int main(int argc,char *argv[])

{

A a;

printf(“len(a)=%02x.\n”,sizeof(A));

a. setNewData();

}

allocateMemory的参数类型有问题，应为char*&；发生了内存泄漏，所以要在析构函数中释放空间。

输出为len(a) = 0c.Roman wasn't built in a day.

79.假定Myclass为一个类，则执行Myclass a[12],*p[30]；语句时，自动调用该类构造函数12次。

80.C++通过模板可以把类型定义为参数，从而实现了真正的代码可重用性。  

81.请看以下程序，其实现了一个简单算法:取两个对象中较小的值。

//Test.cpp

#include

using std::cout;

using std::endl;

//请在下面填上恰当的语句，使得函数定义完整。

template

T min(T x, T y)

{

return (x < y)? x:y;

}

void main()

{

int n1 =2, n2 = 10:

double d1 = 1.5,d2 = 5.6;

cout <<"较小整数"<< min(n1,n2)<

cout<<"较小实数"<< min(n1,n2)<< endl;

system("PAUSE");

}

82.设px是指向一个类动态对象的指针变量，则执行“delete px”；语句时，将自动调用该类析构函数.   

83.在C++语言程序中，有如下函数定义：

void fun(int a,int &b){a++;b++;}

执行代码段：

int x=0,y=1;

fun(x,y);

则变量x，y的值分别是（0,2）

84.抽象类中至少要有一个纯虚函数。

85.根据下面模板类的声明，请写出其构造函数.

template

class NamePtr

{

public:

NamePtr(const string& initName,T *initPtr);

private:

const string name;

T *const ptr;

}

template

NamePtr::NamePtr(const string& initName,T *initPtr){

}

86.C++函数可以通过以下方式重载(overload):函数名相同，参数列表不同.不能通过返回值实现函数重载，因为程序执行时返回值可能会丢弃.

87.为避免在不知情的情况下构造出某个C++类的对象，应在此类的构造函数前使用explicit关键字.

88.设类A有成员函数void f(void);若要定义一个指向类成员函数的指针变量pf来指向f,该指针变量的声明语句是void (A::*pf)(void) = &A::f;.

89.找出下列代码段中有错误或可以优化的地方，简述理由

#include

using namespace std;

class BaseObject

{

public:

BaseObject(){

m_nCount = 0;

m_pData = new int[100];

}

~BaseObject(){

if(m_pData)delete []m_pData;

}

BaseObject(const BaseObject &t){

m_nCount = t.m_nCount;  

//给m_pData辅赋值，深拷贝，memcpy

}

int Squre(volatile int *p){//volatile不在缓存中取值，每次都在内存取，避免缓存和内存不一致的情况

return *p * *p;//int temp = *p;return temp * temp;   

}

void ChangeData()const{

m_nCount++;//常函数不能修改值  

}

private:

int m_nCount;

int *m_pData;

};

int main(){

BaseObject object1;

BaseObject object2 = object1;

return 0;

}

90.有以下类的定义及调用代码片断:

class A

{

public:

A(){printf("A1\n");}

virtual ~A(){printf("A2\n");}

};

class B: public A

{

public:

B(){printf("B1\n");}

B(const B&o){printf("B2\n");}

B&operator=(const B&o){

printf("B3\n");

return *this;

}

~B(){printf("B4\n");}

};

void Test()

{

B b1;//A1 B1  

B b2=b1;//A1 B2  

b2=b1;//B3 

B&b3(b1);//无输出    

B&b4=b2;//无输出  

}//B4 A2 B4 A2  

请写出调用Test函数后的屏幕输出结果。