C++程序员面试指南第8章

面试题1：谈谈你对面向对象的认识
答案：面向对象可以理解成成对待每一个问题，都是首先要确定这个问题由几个部分组成，而每一个部分其实就
是一个对象。然后再分别设计这些对象，最后得到整个程序。传统的程序设计多是基于功能的思想来进行考虑和
设计的，而面向对象的程序设计则是基于对象的角度来考虑问题，这样做能够使得程序更加简洁、清晰。


面试题2：面向对象的三大特征    面向对象的三大特征是什么？请简述之。
答案：面向对象的三大特征是封装性、继承性和多态性。
*封装性：将客观事物封装成类，每个类对自身的数据和方法实行protection（private、protected、public）.
*继承性：广义的继承有三种实现形式：实现继承（使用基类的属性和方法而无需额外编码的能力）、可视继承
（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现之后到子类实现）。
*多态性：是将父类对象设置成为和一个或更多它的子对象相等的技术。用子类对象给父类对象赋值之后，父类
对象就可以根据当前赋值给它的子对象的特征以不同的方式运作。


面试题3： 面向过程和面向对象有什么区别？
答案：面向过程就是指分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个
一个一次调用就可以了。
面向对象是把构问题的事物分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描述某个事物
在整个解决问题步骤中的行为。


面试题4：简述类public、protected、private的作用
答案：public的变量和函数在类的内部外部都可以访问，private修饰的变量和函数只有在类的内部可以访问，
protected修饰的变量和函数在类的内部可以访问，还可以在派生类中访问。


面试题5：写出下列代码的打印结果
#include <stdio.h>
class A{};
class B{};
class C:public A,public B{};
class D:virtual public A{};
class E:virtual public A,virtual public B{};


void main(void)
{
printf("%d\n",sizeof(A));
printf("%d\n",sizeof(B));
printf("%d\n",sizeof(C));
printf("%d\n",sizeof(D));
printf("%d\n",sizeof(E));
}
答案：
1
1
1
4
8
运行结果：
1
1
1
4
8
面试题6：写出以下程序的打印结果。


# include <stdio.h>
class A
{
public:
virtual void fun();
};
void A::fun()
{
printf("output A");
return;
}


class B:A
{
public:
virtual void fun();
B(int, char );
int a;
char b;
void funtion() {}
};
B::B(int a1,char b1)
{
a = a1;
b = b1;
}
void B::fun()
{
printf("output B");
return;
}


int main()
{
B test(258,'y');
B *p;
p = &test;


char ch = *((char*)p + 5);
printf("%d\n",ch);


int size_test = sizeof(test);
printf("%d\n",size_test);


return 0;
}
运行结果：
1
12
面试题7：C++的空类有哪些成员函数
C++中的空类，默认产生哪些类成员函数？
答案：
*缺省构造函数。
*缺省拷贝构造函数。
*缺省析构函数。
*缺省赋值运算符。
*缺省取值运算符。
*缺省取值运算符const。


面试题8： 构造函数能否为虚函数
构造函数能否为虚函数，能否为纯虚函数，析构函数呢？
答案:  构造函数不能是虚函数。而且不能在构造函数中调用虚函数，因为那样实际执行的是父类的对应函数，
因为自己还没有构造好。析构函数可以使虚函数，而且在一个复杂类结构中，这往往是必须的。析构函数也
可以是纯虚函数，但纯虚析构函数必须有定义体，因为析构函数的调用是在子类中隐含的。


面试题9：简述子类与父类的析构、构造函数的调用顺序。
答案：构造函数的调用顺序是先基类后派生类，即定义一个对象时先调用基类的构造函数，然后调用派生类的构
造函数。而析构过程恰好相反，先析构子类对象，再调用父类的析构函数。


面试题10：编写String的构造函数、析构函数和赋值函数。
已知类String的原型为：
class String
{
public:
String(const char *str = NULL);  //普通构造函数
String(const String &other);     //拷贝构造函数
~String(void);  //析构函数
String & operator = (const String &other); //赋值函数
private:
char *m_data;  //用于保存字符串
};
请编写String的上述4个函数。
答案：
String::String(const char *str)  //String的普通构造函数
{
int length = strlen(str);
m_data = new char[length+1];  //此处可加上NULL判断
strcpy(m_data,str);
}
String::~String(void)   //String的析构函数
{
delete[] m_data;  //也可以写成delete m_data;
}


String::String(const String &other)//拷贝构造函数
{
int length = strlen(other,m_data);
m_data = new char[length+1];  //若能加NULL判断则更好
strcpy(m_data,other.m_data);
}


String & String::operator =(const String &other) //赋值函数
{
if(this == &other)  //检查自赋值
return *this;
if(m_data != NULL)
delete [] m_data; //释放原有的内存资源
int length = strlen(other.m_data);  //分配新的内存资源
m_data = new char[length+1]; //此处可加上NULL判断
strcpy(m_data,other.m_data); //赋值内容
return *this; //返回本对象的引用
}
面试题11：谈谈对拷贝构造函数和复制运算符的认识
谈谈你对拷贝构造函数和复制运算符的认识，两者有何异同？
答案： 拷贝构造函数和复制运算符重载有以下两个不同之处：
（1）拷贝构造函数生成新的类对象，而赋值运算符不能。
（2）由于拷贝构造函数是直接构造一个新的类对象，所以在初始化这个对象之前不用检验源对象是否和新建对
象相同。而复制运算符则需要这个操作，另外赋值运算符中如果原来的对象中有内存分配，要先把内存释放掉。


面试题12：写出当定义#define _INMAIN 0和不定义时代码打印结果


#include <iostream.h>
#define _INMAIN 0
class B
{
public:
B():data(0)
{
cout<<"default constructor"<<endl;
}
~B()
{
cout<<"destructed by parameter "<<data<<endl;
}
B(int i):data(i)
{
cout<<"constructed by parameter "<<data<<endl;
}
private:
int data;
};


B Play(B b)
{
return b;
}
#ifdef _INMAIN
void main(void)
{
B t1 = Play(5);
B t2 = Play(t1);
return;
}
#else if
void main(void)
{
B t1 = Play(5);
B t2 = Play(10);
return;
}
#endif




答案：
（1）定义#define _INMAIN 0 输出结果：
constructed by parameter 5
destructed by parameter 5
destructed by parameter 5
destructed by parameter 5
destructed by parameter 5


（2）不定义#define _INMAIN 输出结果：
constructed by parameter 5
destructed by parameter 5
constructed by parameter 10
destructed by parameter 10
destructed by parameter 10
destructed by parameter 5