1、不要在C++中调用longjmp，因为他会打破析构函数将被调用的顺序。
http://blog.sina.com.cn/s/blog_4d8498800100bonm.html
2.inline函数是否可以访问静态成员变量
可以啊,内联函数就相当于把函数展开,所以就相当于一系列语句,并不是真正的函数。
可以，inline 只是提供给编译器的一个建议，具体怎么做要看实际情况而定，比如说如果函数内出现循环，那么编译器通常不会将其内联。而且是否内联可以通过一系列编译选项和宏来控制，即便如此，具体怎么做仍要看编译器，也可以使用 #pragma auto_inline( [{on | off}] ) 来告知编译器使之自动决定是否内联某些函数 。对于直接在类定义内部实现的函数就相当于前面加上 inline 关键字。
综上所述，内联函数在功能上与普通函数相同 。
3、C++函数中那些不可以被声明为虚函数
常见的不不能声明为虚函数的有：普通函数（非成员函数）；静态成员函数；内联成员函数；构造函数；友元函数。
(1)．为什么C++不支持普通函数为虚函数？
普通函数（非成员函数）只能被overload，不能被override，声明为虚函数也没有什么意思，因此编译器会在编译时邦定函数。
(2)．为什么C++不支持构造函数为虚函数？
这个原因很简单，主要是从语义上考虑，所以不支持。因为构造函数本来就是为了明确初始化对象成员才产生的，然而virtual function主要是为了再不完全了解细节的情况下也能正确处理对象。另外，virtual函数是在不同类型的对象产生不同的动作，现在对象还没有产生，如何使用virtual函数来完成你想完成的动作。（这不就是典型的悖论）
(3)．为什么C++不支持内联成员函数为虚函数？
其实很简单，那内联函数就是为了在代码中直接展开，减少函数调用花费的代价，虚函数是为了在继承后对象能够准确的执行自己的动作，这是不可能统一的。（再说了，inline函数在编译时被展开，虚函数在运行时才能动态的邦定函数）
4．为什么C++不支持静态成员函数为虚函数？
这也很简单，静态成员函数对于每个类来说只有一份代码，所有的对象都共享这一份代码，他也没有要动态邦定的必要性。
5．为什么C++不支持友元函数为虚函数？
因为C++不支持友元函数的继承，对于没有继承特性的函数没有虚函数的说法。
*********************************************************************
1.顶层函数：多态的运行期行为体现在虚函数上，虚函数通过继承方式来体现出多态作用，顶层函数不属于成员函数，是不能被继承的。
2.构造函数：
（1）构造函数不能被继承，因而不能声明为virtual函数
（2）构造函数一般是用来初始化对象，只有在一个对象生成之后，才能发挥多态作用，如果将构造函数声明为virtual函数，则表现为在对象还没有生成的情
5、什么时候调用拷贝构造函数？
通过数值传递、数值返回、明确地拷贝一个对象的时候。
6、当使用布局new语法时，程序员将单独承担释放对象的责任。通过明确地调用析构函数可以做到这一点，它是少有的几个需要明确调用析构函数的情况之一。
- using namespace std;
- //在构造函数中调用虚函数，不会产生多态的效果，只会调用自己的成员函数
- class Base
- {
- public:
- Base();
- virtual void f();
- virtual ~Base(){}
- };
- class Derived : public Base
- {
- public:
- Derived();
- virtual void f();
- };
- Base::Base()
- {
- cout<<"Base::Base() calling f()!"<<endl;
- f(); //为了明了，此处应改为Base::f();
- }
- void Base::f()
- {
- cout<<"Base::f()!"<<endl;
- }
- Derived::Derived():Base()
- {
- cout<<"Derived::Derived() calling f()!"<<endl;
- f(); //为了明了，此处应改为Derived::f();
- }
- void Derived::f()
- {
- cout<<"Derived::f()!"<<endl;
- }
- int main()
- {
- cout<<"Create a Derived!"<<endl;
- Derived d;
- return 0;
- }
private:和protected:赋值运算符返回的是什么？
返回对this对象的一个引用或者void
private:和protected:赋值运算符不必返回*this，这是因为该类的运算符只有非常少的用户，因此限制了返回*this的优点。
我们经常声明赋值运算符为private:以便阻止用户对该类的对象赋值。
为了防止偶然一个成员函数或者一个友元函数调用，我们经常不对其进行定义。
在抽象类中，我们经常把赋值运算符声明为：protected:以便确保当目标是一个抽象类的引用时，赋值操作不会发生。
如何在派生类内使用赋值运算符？
派生类中的赋值运算符首先调用其直接基类的赋值运算符，然后在调用它的成员对象的赋值运算符。
- /假如基类的赋值运算符是虚拟的，那么派生类应该做什么？
- //开发人员应该覆盖基类的赋值运算符，并且提供一个重载的赋值运算符。
- #include <iostream>
- using namespace std;
- class B
- {
- public:
- virtual ~B();
- virtual B& operator= (const B& b);
- };
- B::~B(){}
- B& B::operator= (const B& b)
- {
- cout<<"B::operator= (const B& b)"<<endl;
- return *this;
- }
- class D : public B
- {
- public:
- virtual D& oeprator= (const B& b); //覆盖父类的
- D& operator= (const D& d); //重载
- }；
- D& D::operator= (const B& b) //覆盖
- {
- cout<<"D::operator= (const B& b)"<<endl;
- return *this;
- }
- D& D::operator= (const D& d)
- {
- cout<<"D::operator= (const D& d)"<<endl;
- return *this;
- }
- void Sample(D& d, B&b, D& d2, B& b2)
- {
- cout<<"d = d2: "; d = d2;
- cout<<"d = b2: "; d = b2;
- cout<<"b = b2: "; b = b2;
- cout<<"b = d2: "; b = d2;
- }
- int main()
- {
- D d, b, d2, b2;
- // Sample(d, b, d2, b2);
- return 0;
- }
什么是最终类/
最终类（也称叶子类）是一个永久地禁止产生派生类的类。
仅当设计者决定永久地禁止任何将来的类从一个类派生时，才能声明该类为最终类。
C++不支持“finnal”关键词，因此我们一般只是对其加以注释。
使编译器强制某个类成为最终类并不困难：只需使构造函数private：并且提供public：static create()成员函数。这样阻止派生类的存在，因为派生类不能调用最终类(private：)构造函数。
最终类不应该有protected：数据成员——它所有的数据成员都应该是private：。类似地，最终类也不应该声明任何新的虚拟函数（尽管它经常覆盖继承的虚拟函数）。
转载： http://blog.csdn.net/wangyangkobe/article/details/6118748