Cdoc面试题.docx

Cdoc面试题.docx

《Cdoc面试题.docx》由会员分享，可在线阅读，更多相关《Cdoc面试题.docx（13页珍藏版）》请在冰点文库上搜索。

Cdoc面试题

111.怎样消除多重继承中的二义性？

1．成员限定符

2．虚基类

112什么叫静态关联，什么叫动态关联

在多态中，如果程序在编译阶段就能确定实际执行动作，则称静态关联，

如果等到程序运行才能确定叫动态关联。

113多态的两个必要条件

1.一个基类的指针或引用指向一个派生类对象，

2.虚函数

114.什么叫智能指针？

当一个类中，存在一个指向另一个类对象的指针时，对指针运算符进行重载，那么当前类对象可以通过指针像调用自身成员一样调用另一个类的成员。

当类中有指针成员时，一般有两种方式来管理指针成员：

一是采用值型的方式管理，每个类对象都保留一份指针指向的对象的拷贝；另一种更优雅的方式是使用智能指针，从而实现指针指向的对象的共享。

　　智能指针（smartpointer）的一种通用实现技术是使用引用计数（referencecount）。

智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。

　　每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，析构函数减少引用计数（如果引用计数减至0，则删除基础对象）。

　　实现引用计数有两种经典策略：

一是引入辅助类，二是使用句柄类。

下面分别介绍这些内容

　　问题描述

　　　　假设有一个名为TestPtr的类，里面有一个指针成员，简化为如下代码

　　classTestPtr

　　{

　　public:

　　TestPtr（int*p）:

ptr（p）{}

　　~TestPtr（）{deleteptr;}

　　private:

　　int*ptr;

　　};

　　在这种情况下，类TestPtr对象的任何拷贝、赋值操作都会使多个TestPtr对象共享相同的指针。

但在一个对象发生析构时，指针指向的对象将被释放，从而可能引起悬垂指针。

　　现在我们使用引用计数来解决这个问题，一个新的问题是引用计数放在哪里。

显然，不能放在TestPtr类中，因为多个对象共享指针时无法同步更新引用计数。

　　方案一

　　这里给出的解决方案是，定义一个单独的具体类（RefPtr）来封装指针和相应的引用计数。

由于这个类只是用于对类TestPtr中的成员指针ptr进行了封装，无其它用途，所以把引用计数类RefPtr的所有成员均定义为private，并把类TestPtr声明为它的友元类，使TestPtr类可以访问RefPtr类。

示例代码如下：

　　classRefPtr

　　{

　　friendclassTestPtr;

　　int*ptr;

　　count;

　　RefPtr（int*p）:

ptr（p）,count

（1）{}

　　~RefPtr（）{deleteptr;}

　　};

　　classTestPtr

　　{

　　public:

　　TestPtr（int*p）:

ptr（newRefPtr（p））{}

　　TestPtr（constTestPtr&src）:

ptr（src.ptr）{

　　++ptr->count;

　　}

　　TestPtr&operator=（constTestPtr&rhs）{

　　//self-assigningisalsoright

　　++rhs.ptr->count;

　　if（--ptr->count==0）

　　deleteptr;

　　ptr=rhs.ptr;

　　return*this;

　　}

　　~TestPtr（）{

　　if（--ptr->count==0）

　　deleteptr;

　　}

　　private:

　　RefPtr*ptr;

　　};

　　当希望每个TestPtr对象中的指针所指向的内容改变而不影响其它对象的指针所指向的内容时，可以在发生修改时，创建新的对象，并修改相应的引用计数。

这种技术的一个实例就是写时拷贝（Copy-On-Write）。

　　这种方案的缺点是每个含有指针的类的实现代码中都要自己控制引用计数，比较繁琐。

特别是当有多个这类指针时，维护引用计数比较困难。

　　方案二

　　为了避免上面方案中每个使用指针的类自己去控制引用计数，可以用一个类把指针封装起来。

封装好后，这个类对象可以出现在用户类使用指针的任何地方，表现为一个指针的行为。

我们可以像指针一样使用它，而不用担心普通成员指针所带来的问题，我们把这样的类叫句柄类。

在封装句柄类时，需要申请一个动态分配的引用计数空间，指针与引用计数分开存储。

实现示例如下

115.什么时候需要用虚析构函数？

当基类指针指向用new运算符生成的派生类对象时，delete基类指针时，派生类部分没有释放掉而造成释放不彻底现象，需要虚析构函数。

116.MFC中，大部分类是从哪个类继承而来?

Cobject

117.什么是平衡二叉树？

答：

左右子树都是平衡二叉树，而且左右子树的深度差值的约对值不大于1

118.语句for（；1；）有什么问题？

它是什么意思？

答：

无限循环，和while

（1）相同。

119．派生新类的过程要经历三个步骤

1.吸收基类成员

2.改造基类成员

3.添加新成员

121.TCP/IP建立连接的过程

在TCP/IP协议中，TCP协议提供可靠的连接服务，采用三次握手建立一个连接。

第一次握手：

建立连接时，客户端发送连接请求到服务器，并进入SYN_SEND状态，等待服务器确认；

第二次握手：

服务器收到客户端连接请求，向客户端发送允许连接应答，此时服务器进入SYN_RECV状态；

第三次握手：

客户端收到服务器的允许连接应答，向服务器发送确认，客户端和服务器进入通信状态，完成三次握手

122.memset,memcpy的区别

memset用来对一段内存空间全部设置为某个字符，一般用在对定义的字符串进行初始化为'\0'。

memcpy用来做内存拷贝，你可以拿它拷贝任何数据类型的对象，可以指定拷贝的数据长度；

123.在C++程序中调用被C编译器编译后的函数，为什么要加extern“C”？

答：

C++语言支持函数重载，C语言不支持函数重载。

函数被C++编译后在库中的名字与C语言的不同。

假设某个函数的原型为：

voidfoo（intx,inty）;该函数被C编译器编译后在库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。

C++提供了C连接交换指定符号extern“C”来解决名字匹配问题。

124.怎样定义一个纯虚函数？

含有纯虚函数的类称为什么？

在虚函数的后面加=0，含有虚函数的类称为抽象类。

126．已知类String的原型为：

classString

{

public:

String（constchar*str=NULL）;//普通构造函数

String（constString&other）;//拷贝构造函数

~String（void）;//析构函数

String&operate=（constString&other）;//赋值函数

private:

char*m_data;//用于保存字符串

};

请编写String的上述4个函数。

答案：

String:

:

String（constchar*str）

{

if（str==NULL）//strlen在参数为NULL时会抛异常才会有这步判断

{

m_data=newchar[1];

m_data[0]='';

}

else

{

m_data=newchar[strlen（str）+1];

strcpy（m_data,str）;

}

}

String:

:

String（constString&other）

{

m_data=newchar[strlen（other.m_data）+1];

strcpy（m_data,other.m_data）;

}

String&String:

:

operator=（constString&other）

{

if（this==&other）

return*this;

delete[]m_data;

m_data=newchar[strlen（other.m_data）+1];

strcpy（m_data,other.m_data）;

return*this;

}

String:

:

~String（void）

{

delete[]m_data;

}

127．类成员函数的重载、覆盖和隐藏区别

答案：

成员函数被重载的特征：

（1）相同的范围（在同一个类中）；

（2）函数名字相同；

（3）参数不同；

（4）virtual关键字可有可无。

覆盖是指派生类函数覆盖基类函数，特征是：

（1）不同的范围（分别位于派生类与基类）；

（2）函数名字相同；

（3）参数相同；

（4）基类函数必须有virtual关键字。

“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

（1）如果派生类的函数与基类的函数同名，但是参数不同。

此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。

（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。

此时，基类的函数被隐藏（注意别与覆盖混淆）

128．如何打印出当前源文件的文件名以及源文件的当前行号？

答案：

cout<<__FILE__;

cout<<__LINE__;

__FILE__和__LINE__是系统预定义宏，这种宏并不是在某个文件中定义的，而是由编译器定义的。

129．文件中有一组整数，要求排序后输出到另一个文件中

答案：

voidOrder（vector&data）//起泡排序

{

intcount=data.size（）;

inttag=false;

for（inti=0;i

{

for（intj=0;j

{

if（data[j]>data[j+1]）

{

tag=true;

inttemp=data[j];

data[j]=data[j+1];

data[j+1]=temp;

}

}

if（!

tag）

break;

}

}

voidmain（void）

{

vectordata;

ifstreamin（"c:

\\data.txt"）;

if（!

in）

{

cout<<"fileerror!

";

exit

（1）;

}

inttemp;

while（!

in.eof（））

{

in>>temp;

data.push_back（temp）;

}

in.close（）;

Order（data）;

ofstreamout（"c:

\\result.txt"）;

if（!

out）

{

cout<<"fileerror!

";

exit

（1）;

}

for（i=0;i

out<

out.close（）;

}

130．一个链表的结点结构

structNode

{

intdata;

Node*next;

};

typedefstructNodeNode;已知链表的头结点head,写一个函数把这个链表逆序（Intel）

Node*ReverseList（Node*head）//链表逆序

{

if（head==NULL||head->next==NULL）

returnhead;

Node*p1=head;

Node*p2=p1->next;

Node*p3=p2->next;

p1->next=NULL;

while（p3!

=NULL）

{

p2->next=p1;

p1=p2;

p2=p3;

p3=p3->next;

}

p2->next=p1;

head=p2;

returnhead;

}

131.一个链表的结点结构

structNode

{

intdata;

Node*next;

};

typedefstructNodeNode;

已知两个链表head1和head2各自有序，请把它们合并成一个链表依然有序。

Node*Merge（Node*head1,Node*head2）

{

if（head1==NULL）

returnhead2;

if（head2==NULL）

returnhead1;

Node*head=NULL;

Node*p1=NULL;

Node*p2=NULL;

if（head1->datadata）

{

head=head1;

p1=head1->next;

p2=head2;

}

else

{

head=head2;

p2=head2->next;

p1=head1;

}

Node*pcurrent=head;

while（p1!

=NULL&&p2!

=NULL）

{

if（p1->data<=p2->data）

{

pcurrent->next=p1;

pcurrent=p1;

p1=p1->next;

}

else

{

pcurrent->next=p2;

pcurrent=p2;

p2=p2->next;

}

}

if（p1!

=NULL）

pcurrent->next=p1;

if（p2!

=NULL）

pcurrent->next=p2;

returnhead;

}

132.已知两个链表head1和head2各自有序，请把它们合并成一个链表依然有序，这次要求用递归方法进行。

（Autodesk）

答案：

Node*MergeRecursive（Node*head1,Node*head2）

{

if（head1==NULL）

returnhead2;

if（head2==NULL）

returnhead1;

Node*head=NULL;

if（head1->datadata）

{

head=head1;

head->next=MergeRecursive（head1->next,head2）;

}

else

{

head=head2;

head->next=MergeRecursive（head1,head2->next）;

}

returnhead;

}

133．分析一下这段程序的输出（Autodesk）

classB

{

public:

B（）{

cout<<"defaultconstructor"<

}

~B（）{

cout<<"destructed"<

}

B（inti）:

data（i）{

cout<<"constructedbyparameter"<

}

private:

intdata;

};

BPlay（Bb）{//constructedbyparameter隐式转换构造

returnb;//暂时不析构

}

intmain（intargc,char*argv[]）

{

Btemp=Play（5）;//拷贝构造//destructed析构

return0;//析构

}

133将“引用”作为函数参数有哪些特点？

（1）传递引用给函数与传递指针的效果是一样的。

这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。

（2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。

因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。

（3）使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用"*指针变量名"的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。

而引用更容易使用，更清晰。

134.什么时候需要“引用”？

流操作符（<<、>>）和赋值操作符（=）的返回值、拷贝构造函数的参数、赋值操作符的参数、其它情况都推荐使用引用。

135.面向对象的三个基本特征，并简单叙述之？

1.封装：

将客观事物抽象成类，每个类对自身的数据和方法实行protection（private,protected,public）

2.继承：

广义的继承有三种实现形式：

实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。

前两种（类继承）和后一种（对象组合=>接口继承以及纯虚函数）构成了功能复用的两种方式。

3.多态：

是将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。

简单的说，就是一句话：

允许将子类类型的指针赋值给父类类型的指针。