C++陷阱系列(2):让面试官倒掉的题--续

    上回出了几道有挑战的题，当然那些不会真的做面试题的，让一大半人都挂的题目是没有出的必要的。C++是一个语言标准，不是一个实现标准，语言标准只规定了源代码长什么样合法，没有规定看到想到的和编译出来的东西就一定一样。例如，一个类有virtual关键字修饰的函数，那么就会有这个类就会有虚函数表吗? 不一定啊，因为C++标准压根就没有规定要如何实现虚函数！所谓的虚函数表只是一种流行的，实现虚函数的方式而已。
    C++是马，而某个具体的C++编译器实现是"白马"。白马非马也！有了上一篇文章的基础，我们继续讨论和构造/析构/赋值相关的话题。
【第一题】用VC2008/VC2012/GCC4.7编译下面的代码Release版，输出多少?

#include<iostream>
using namespace std;
static int i=0;
class My{
public:
    My() {i+=1;}
    My(const My&){i+=2;}
    My& operator=(const My&){
        i+=3;
        return *this;
    }
};
class Derived: public My
{
public:
    Derived(){}
    Derived(const Derived&d){}
};
int main(int argc, char* argv[])
{
    Derived d;
    Derived d2(d);
    cout<<i<<endl;
    return 0;
}

    这题的关键是Derived d2(d)这句话，继承类的拷贝构造函数，会调用基类的哪个构造函数呢? 没有显示指定初始化列表，那就是调用基类的默认构造函数，因此本题的答案是2。
【第二题】用VC2008/VC2012/GCC4.7编译下面的代码Release版，输出多少?

#include<iostream>
using namespace std;
static int i=0;
class My{
public:
      My() {f();}
    virtual void f(){i+=1;}
};
class Derived: public My
{
public:
    Derived(){}
    virtual void f(){i+=2;}
};
int main(void)
{
    My* pD=new Derived();
    cout<<i<<endl;
    delete pD;
    return 0;
}

    这道题的关键是，基类构造函数里面调用了一个虚函数f，那么实际是调的基类的f还是继承累的f呢？<>这本书的条款"Nevel call virtual functions during construction or destruction"有很好的说明，但是书上举例还是不够充分，解释的也不算清楚。因为：
    C++的"类"和"对象"只是语言级的概念，C++标准根本就没有规定编译的结果里面也存在对象，这样就能给编译器和优化器以无穷的空间----反过来说，我们不能假设对象真的有物理存在，因为构造函数有可能被内联，甚至release版连对象都优化得没有了，"多态"这个概念也是可以被编译器优化掉的。因此ctor/dtor要调用类内部的虚函数而根本把所谓多态置之脑后。
    所以，C++在ctor/dtor当中遇到虚函数调用的时候，直接当成非虚函数调用类内部的版本。这道题调用的是My::f()，输出是1。如果允许在基类构造期间调用继承类的函数，那么该函数需要访问继承类的成员例如指针，可此时继承类还没有构造，指针错误，崩溃了。
【第三题】用VC2008/VC2012/GCC4.7编译下面的代码Release版，输出多少?【第二题】用VC2008/VC2012/GCC4.7编译下面的代码Release版，输出多少?【第二题】用VC2008/VC2012/GCC4.7编译下面的代码Release版，输出多少?【第三题】以下程序的运行结果是什么:

class My
{
    My* pSelf;
public:
    My(){pSelf=this;}
    ~My(){delete pSelf;}
};
int main(void)
{
    My m;
    return 0;
}

    析构函数无限递归，堆栈溢出崩溃。
【第四题】以下代码有什么问题?
用VC2008/VC2012/GCC4.7编译下面的代码，会有什么问题?用VC2008/VC2012/GCC4.7编译下面的代码，会有什么问题?用VC2008/VC2012/GCC4.7编译下面的代码，会有什么问题?用VC2008/VC2012/GCC4.7编译下面的代码，会有什么问题?

#include<iostream>
using namespace std;
class My{
public:
    virtual void f()=0;
    void haha(){f();}
    virtual ~My(){
        cout<<__FUNCTION__<<endl;
        f();
    }
};
class You:public My{
public:
    void f(){cout<<__FUNCTION__<<endl;}
    ~You(){
        cout<<__FUNCTION__<<endl;
        haha();
    }
};
int main(){
    My *p=new You;
    delete p;
    return 0;
}

    不要着急说，调用一个haha()调用一个不存在的虚函数导致空指针错误。因为上面的代码根本编译不过。因为编译器让析构函数~My()调用本累的f()，而本类的f()是纯虚的，没有实现体，因此提示undefined reference to 'My::f()'。把上面的代码改一改，就能编过了：

#include<iostream>
using namespace std;
class My
{
public:
     virtual void f() = 0;
     void haha() { f(); }
     virtual ~My(){
         cout<<__FUNCTION__<<endl;
         haha();
     }
};
class You: public My
{
public:
     void f(){cout<<__FUNCTION__<<endl;}
     ~You(){
         cout<<__FUNCTION__<<endl;
         haha();
     }
};
int main(int argc, char* argv[])
{
     My* pm=new You();
     delete pm;
     return 0;
}

    此时~My调用了一个非纯虚的函数haha，没有问题，而haha里面去调用f。运行到delete pm的时候，~My()->haha调用了My::f()，这是虚函数调用，指向一个纯虚(空指针)，因此崩溃(pure virtual function call)。如果我把My* pm=new You()改成You* py=new You()会让这个错误错误消失吗? 不会，因为析构函数先~You析构继承类的部分，然后进入~My。这个~My调用的时候，继承类的部分已经不存在了，因此此时虚函数的调用路径回到了基类，程序还是崩溃了。
-----------------------------------------------------------------
    虚拟机语言如C#/Java对象生命周期是GC全局管理，因此不存在这样的陷阱，多态的基类引用在ctor里面调用虚函数，是调进继承类。一下两段代码都是输出两个"Derived"。

class Base
    {
        public Base() { f(); }
        public virtual void f() { Console.WriteLine("Base"); }
    }
    class Derived : Base
    {
        public Derived() { f(); }
        public override void f() { Console.WriteLine("Derived"); }
    }
    [STAThread]
    static void Main(string[] args)
    {
        Base pb = new Derived();
    }

public class JavaApplication1 {

    /**
     * @param args the command line arguments
     */
    static public class Base
    {
        public Base() { f(); }
        public void f() { System.out.println("Base"); }
    }
    static public class Derived extends Base
    {
        public Derived() { f(); }
        public void f() { System.out.println("Derived"); }
    }
    public static void main(String[] args) {
        // TODO code application logic here
        JavaApplication1.Base pb = new JavaApplication1.Derived();
    }
}