20150310的一些总结

1.今天被朋友问了一个问题：

#include <iostream>
#include <string>
#include <vector>
#include <stdio.h>

using namespace std;

class father{
    public:
        void run()
        {
            start();
        }
    protected:
        virtual void start(){

            cout << "father start" << endl;
        }
    private:
        int a;
        int dd;
        double fd;
};

class child : public father
{
    public:
        virtual void start(){
            cout << "child start" << endl;
        }
        void getfather(){
            father* ff = this;
            father fd = *ff;
            fd.run();
        }
    private:
        int b;
        double d;
};

int main(int argc, const char *argv[])
{
    child chi;
    chi.run();
    return 0;
}

这个示例的输出结果：实际是：child start

此时run中调用的start()方法是派生类的start而不是基类中的start!问题是此时的访问start的方法是静态联编还是动态绑定？

先看一个示例：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class D
{
    public:
        void printA(){
            cout << "A" << endl;
            printB();
        }
        virtual void printB(){
            cout << "B" << endl;
        }

};

int main(int argc, const char *argv[])
{
    D *d = NULL;
    d->printA();//错误，输出：A segmentfault 11
    D d2;
    d2.printA();//正常输出
    return 0;
}

分析：printA()是非虚成员函数，d-> 和d2. 都可以实现对它的访问，但是当访问虚函数时(多态性)d->实际指向的对象是空的，所以肯定会出错！

总结：虚函数的多态性表现不是基类指针指向派生类，实际上可以让一个派生类指针指向另一个派生类（同一个基类），实现多态！

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class A{
    public:
        void run(){
            cout << " type:" << typeid(*this).name() << endl;
            print();
        }
    virtual void print(){
           cout << " type:" << typeid(*this).name() << endl;
           cout << "A" << endl;
        }
};

class B : public A{
    public:
        void print(){//隐藏了父类的print函数
            cout << "B" << endl;
        }
};

class C : public A{
    public:
        virtual void print(){
            cout << "C" << endl;
        }
};

int main(int argc, const char *argv[])
{
//    C *c = (C*)(A*)new B();
//    c->print();
    B *b = new B();
    b->run();
    cout << "----" << endl;
    B b2 ;
    b2.run();
    //    B *b2 = NULL;
//    b2->run();
    return 0;
}

当print是虚函数时输出：

 type:1B
B
----
 type:1B
B

当print是非虚函数时的输出:

 type:1A
 type:1A
A
----
 type:1A
 type:1A
A
分析：