因为：对虚函数的调用是通过虚指针+偏移地址构成，由于对虚函数的调用都是通过这种方式，所以对同一个虚函数的偏移值就必须相同。
2.为防止对象切片有什么办法？
可以将基类定义为纯虚类
3.为什么构造函数里面的虚机制不起作用？
a.如果构造函数调用层次上，中间构造函数调用的虚函数属于派生类，由于派生类为初始化完成，所以会有问题。
b.调用层次上的每一个构造函数，都会使虚指针指向该构造函数所属的类的虚表，而对象最终的虚指针是由最后调用的构造函数决定(辈分最小的类)，如果在中间层次的构造函数调用虚函数，由于当前构造函数设置的虚指针是指向这个类的虚表，所以调用的虚函数还是自己的函数。
4.为什么纯虚析构函数必须有函数体？
因为，基类的析构函数总会被子类的析构函数调用，如果没有函数体，就不知道该怎么析构一个纯虚类。
5.如果一个派生类没有重定义基类的纯虚函数，会发生什么？
该派生类不能实例化。
6.为什么在析构函数中的虚机制不起作用。
因为虚函数归属的类可能已经被删除。
7.为什么在使用dynamic_cast时需要格外小心。
因为dynamic_cast用来做向下类型转换，操作结果不一定总是成功的，在失败的情况下返回的指针值是零，如果继续使用会coredump.
8.为什么对不带有虚函数的类层次执行向下类型转换，使用static_cast比dynamic_cast好
因为，dynamic_cast会使用虚表里面的类型信息，所以不合理，就算没有虚表，额外的调用会导致效率比较低。
9.为什么头文件的规则：不要把分配存储单元的东西放到头文件 ？
分配存储单元必须指定一个名字，二头文件会被多次包括，如果没有使用排重宏，则会造成多次定义的错误，另一方面就算是有排重宏，由于多个单元可见，怎么协调和同步访问该块存储也是一个问题。
10.c语言的setjump和longjump在c++中有什么问题？
a.保存点和返回点紧耦合
b.不会调用析构函数。试想如果析构函数里面有关闭文件，关闭网络连接，释放内存等操作。
11.c++的异常机制有什么好处？
将业务逻辑代码和错误处理代码解耦，使代码结构清晰，易理解。
12.为什么类型转换构造函数在异常处理机制中不工作？
？？？？，也许是因为异常处理器需要的是更原始，更真实，更具体的信息，如果发生转换这些信息很可能打折扣。
13. catch(...)存在的意义是什么？
释放资源本层，配合不带参数的throw可以将异常完整的传递到上一级，上一级可以继续获取异常信息进行处理。
14.如果被抛出的异常对象，析构函数会抛出异常，会发生什么？
本层处理器将不会处理该异常，如果没有上一层处理器，则terminate会被调用；如果有上一层处理器，上层可以 捕获这个异常，但是这种情况被认为是糟糕的设计或编码。
15.如果构造函数里边会抛出异常应该怎么做，因为析构函数不会被调用？
a.可以在构造函数里边进行异常捕获用于释放资源！
b.也可以将需要释放资源的指针封装成对象，然后将这些对象作为成员变量放在类里面，因为成员变量是对象，所以会在构造函数之前调用其构造函数，所以如果这个时候抛出了异常那么栈反解的时候就会把已经成功构造的给释放掉。
{
T x;
istringstream inStr(str);
inStr>>x;
return x;
}
template <class T> string toString(const T & t)
{
ostringstream ostr;
ostr<<t;
return ostr.str();
{
istringstream iStrDoub(strDouble);
iStrDoub>>pre>>aft;
}
using namespace std;
//牛奶类
class Milk
{
public:
friend ostream & operator << (ostream & os,const Milk &)
{
return os<<"Milk";
}
};
//压缩牛奶类
class CondensedMilk
{
public:
friend ostream & operator << (ostream & os,const CondensedMilk &)
{
return os<<"CondensedMilk";
}
};
//蜂蜜类
class Honey
{
friend ostream & operator<<(ostream & os,const Honey &)
{
return os<<"Honey";
}
};
// 饼干类
class Cookies
{
friend ostream & operator<<(ostream & os,const Cookies &)
{
return os<<"Cookies";
}
};
//定义几个访客类
//熊类
class Bear
{
public:
friend ostream & operator<<(ostream & os,const Bear&)
{
return os<<"Big bear";
}
};
//小孩类
class Boy
{
public:
friend ostream & operator << (ostream & os ,const Boy &)
{
return os<<"Little boy";
}
};
//主要traits模板(空模板可以持有所有普通类型)
template <class Guest> class GuestTraits;
//特化的traits类
template<> class GuestTraits<Bear>
{
public:
typedef CondensedMilk beverage_type;
typedef Honey snack_type;
};
template<> class GuestTraits<Boy>
{
public:
typedef Milk beverage_type;
typedef Cookies snack_type;
};
class MixedUpTraits
{
public:
typedef Milk beverage_type;
typedef Honey snack_type;
};
//驱动类
template<class Guest,class traits=GuestTraits<Guest> >
class BearCorner
{
Guest theGuest;
typedef typename traits::beverage_type beverage_type;
typedef typename traits::snack_type snack_type;
beverage_type bev;
snack_type snack;
public:
BearCorner(const Guest & g):theGuest(g){}
void entertain()
{
cout<<"Entertaining "<<theGuest
<< " serving "<<bev
<< " and "<<snack<<endl;
}
};
int main(int argv,char ** args, char ** env)
{
Boy boy;
Bear bear;
BearCorner<Boy> bc1(boy);
bc1.entertain();
BearCorner<Bear> bc2(bear);
bc2.entertain();
BearCorner<Boy,MixedUpTraits> bc3(boy);
bc3.entertain();
return 0;
using namespace std;
template<class T>
class ObjCount
{
static int cnt;
public:
ObjCount(){++cnt;}
ObjCount(const ObjCount<T> & cnt){++cnt;}
~ObjCount(){--cnt;}
static int getCount(){return cnt;}
};
template<class T> int ObjCount<T>::cnt=0;
{
TestCnt1 t11,t12;
TestCnt2 t21,t22;
cout<<"TestCnt1::getCount="<<TestCnt1::getCount()<<endl;
cout<<"TestCnt2::getCount="<<TestCnt2::getCount()<<endl;
return 0;