C++面试题

如何让一个类不能创建实例

1虚基类，2构造函数为私有函数。

explicit的作用 

解析：explicit构造函数是用来防止隐式转换的。请看下面的代码：
class Test1
{ 　　
public: 　　
Test1(int n)
{ num = n; } //普通构造函数 　　
private: 　　
int num; 　　
}; 　　
class Test2 　　
{ 　　
public: 　　
explicit Test2(int n) { num = n; } //explicit(显式)构造函数 　　
private: 　　
int num; 　　
}; 　　
int main() 　　
{ 　　
Test1 t1 = 12; //隐式调用其构造函数, 成功，执行了隐式转换,等价于Test1 temp(12);t1(temp);注意这个地方调用了 编译器为我们提供的默认复制构造函数  　　
Test2 t2 = 12; //编译错误,不能隐式调用其构造函数 　　
Test2 t3(12); //显示调用成功 　　
return 0; 　　
}

C++用new来创建对象和非new来创建对象的区别

#include <iostream>
using namespace std;

class A
{
private:
    int n;
public:
    A(int m):n(m)
    {
    }
    ~A(){}
};

int main()
{
    A a(1);  //栈中分配
    A b = A(1);  //栈中分配
    A* c = new A(1);  //堆中分配
　　delete c;
    return 0;
}

第一种和第二种没什么区别，一个隐式调用，一个显式调用，两者都是在进程虚拟地址空间中的栈中分配内存，而第三种使用了new，在堆中分配了内存，而栈中内存的分配和释放是由系统管理，而堆中内存的分配和释放必须由程序员手动释放，所以这就产生一个问题是把对象放在栈中还是放在堆中的问题，这个问题又和堆和栈本身的区别有关。

空类占多少个字节？

class CBase
{
};
sizeof(CBase)=1；
为什么空的什么都没有是1呢？
c++要求每个实例在内存中都有独一无二的地址。//注意这句话！！！！！！！！！！
空类也会被实例化，所以编译器会给空类隐含的添加一个字节，这样空类实例化之后就有了独一无二的地址了。所以空类的sizeof为1。

引入库

#pragma comment(lib,”*.lib”)

加入库的预编译指令，这种方法优点是可以利用条件预编译指令链接不同版本的lib文件。

联编，动态联编，虚函数
函数联编：将一个调用函数者联结上正确的被调用函数的过程，一般称为联编。
    C++中的联编分两种：
    (1)静态联编；
    (2)动态联编；
动态联编的定义
    成员函数必须声明为virtual，即为虚函数，该函数是动态联编；
    动态联编：指联编工作出现在运行时阶段，这种联编又称为晚期联编；
    编译程序：在编译阶段并不能确切知道将要调用的函数，只有在程序运行时才能确定将要调用的函数，为此要确切知道该调用的函数，要求联编工作要在程序运行时进行；
    注：这样的好处是实现多态性和比较灵活，但是就要牺牲速度，因为每个函数调用在运行前是不可确定的，要随着用户的操作来执行相应的函数，相应地大大增加了系统的开销。
多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。如果函数的调用，在编译器编译期间就可以确定函数的调用地址，并生产代码，是静态的，就是说地址是早绑定的。而如果函数调用的地址不能在编译器期间确定，需要在运行时才确定，这就属于晚绑定。
最常见的用法就是声明基类的指针，利用该指针指向任意一个子类对象，调用相应的虚函数，可以根据指向的子类的不同而实现不同的方法。如果没有使用虚函数的话，即没有利用C++多态性，则利用基类指针调用相应的函数的时候，将总被限制在基类函数本身，而无法调用到子类中被重写过的函数。因为没有多态性，函数调用的地址将是一定的，而固定的地址将始终调用到同一个函数，这就无法实现一个接口，多种方法的目的了。

类的两种初始化

     在执行构造函数的时候，如果存在有初始化列表，则先执行初始化列表，之后再执行构造函数的函数体。
类对象的构造顺序是这样的：
1.分配内存，调用构造函数时，隐式／显示的初始化各数据成员；
2.进入构造函数后在构造函数中执行一般赋值与计算。
使用初始化列表有两个原因：
原因1.必须这样做：
《C++ Primer》中提到在以下三种情况下需要使用初始化成员列表：
   情况一、需要初始化的数据成员是对象的情况(这里包含了继承情况下，通过显示调用父类的构造函数对父类数据成员进行初始化)；
   情况二、需要初始化const修饰的类成员或初始化引用成员数据；
   情况三、子类初始化父类的私有成员；
一般我们进行成员变量初始化用两种方法
第一种是通过在构造函数内赋值
class Point
{
public:
Point(){ _x = 0; _y = 0;};
Point( int x, int y ){ _x = 0; _y = 0; }
private:
int _x, _y;
};
第二种是使用初始化列表
class Point
{
public:
Point():_x(0),_y(0){};
Point( int x, int y ):_x(x),_y(y){}
private:
int _x, _y;
};
一 特别是const和引用数据成员被初始化时，必须使用初始化列表。
二、是从效率方面来说的，对于内置类型或复合类型，差异不会太大，但对于非内置数据类型，差异还是很明显的
如我们再给Point类添加一个新的string类型的成员变量
class Point
{
const int _x, _y;
string _name;
};
构造函数内赋值进行初始化
Point( int x, int y, string name ){ _x = 0; _y = 0; _name = name; }
_name = name 这个表达式会调用string类的缺省构造函数一次，再调用Operator=函数进行赋值一次。所以需调用两次函数：一次构造，一次赋值
用初始化列表进行初始化
Point( int x, int y, string name ):_x(x),_y(y), _name(name){}
_name会通过拷贝构造函数仅以一个函数调用的代码完成初始化
即使是一个很简单的string类型，不必要的函数调用也会造成很高的代价。随着类越来越大，越来越复杂，它们的构造函数也越来越大而复杂，那么对象创建的代价也越来越高，所以一般情况下建议使用初始化列表进行初始化，不但可以满足const和引用成员的初始化要求，还可以避免低效的初始化数据成员。