C++ 学习（类的继承，派生）

私有继承总，在不进行显示类转换的情况下，不能将指向派生类的引用或者指针复制给基类引用或者指针，在公有继承中是可以得。基类指针或引用只能调用基类方法，但基类只能跟引用之只能调用基类继承过来的方法， 不可以将基类指针或引用赋值给派生类指针或者引用

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

using namespace std;


class Person
{
    public:
    string name;
    int age;
    Person(){};
    Person(string _name){ name = _name;}
    void show( )
    {
        cout<<name<<" ---- "<<age<<endl;
    }
};

class student: public Person
{
    public:
    string stu_id;
    student (){};
    void get_inf(){
       cout<<stu_id<<endl;
       cout<<name<<endl;
       cout<<age<<endl;
    }

};
int main()
{
    student stu;
    stu.name = "a";
    stu.stu_id = "1";
    stu.age = 11;
    Person &p =  stu;
    p.show();
    Person *q = &stu;
    q->show();
    //q-> get_inf(); error！！！！！
    return 0;
}

对于形参为指向基类的指针的函数，它可以使用基类对象的地址或派生类对象的地址作为实参

 Person per = Person(stu);

要初始化Person, Person( student &stu) 这样的函数是不存在的，
但是存在隐式复制构造函数Person( Person &p) ；由于形参是基类引用，所以它可以引用派生类。

虚函数， 纯虚函数
http://www.cnblogs.com/bluestorm/archive/2012/08/29/2662350.html
http://www.cnblogs.com/fzhe/archive/2013/01/02/2842513.html
1. 虚函数和纯虚函数可以定义在同一个类(class)中，含有纯虚函数的类被称为抽象类(abstract class)，而只含有虚函数的类(class)不能被称为抽象类(abstract class)。

1. 虚函数可以被直接使用，也可以被子类(sub class)重载以后以多态的形式调用，而纯虚函数必须在子类(sub class)中实现该函数才可以使用，因为纯虚函数在基类(base class)只有声明而没有定义。

2. 虚函数和纯虚函数都可以在子类(sub class)中被重载，以多态的形式被调用。

3. 虚函数和纯虚函数通常存在于抽象基类(abstract base class -ABC)之中，被继承的子类重载，目的是提供一个统一的接口。

4. 虚函数的定义形式：virtual {method body}

   　　纯虚函数的定义形式：virtual { } = 0;

在虚函数和纯虚函数的定义中不能有static标识符，原因很简单，被static修饰的函数在编译时候要求前期bind,然而虚函数却是动态绑定(run-time bind)，而且被两者修饰的函数生命周期(life recycle)也不一样。

1. 虚函数必须实现，如果不实现，编译器将报错，错误提示为：

error LNK****: unresolved external symbol “public: virtual void __thiscall
ClassName::virtualFunctionName(void)”

1. 对于虚函数来说，父类和子类都有各自的版本。由多态方式调用的时候动态绑定。

虚析构函数[参考](http://blog.csdn.net/starlee/article/details/619827)

我们知道，用C++开发的时候，用来做基类的类的析构函数一般都是虚函数。可是，为什么要这样做呢？下面用一个小例子来说明：

class ClxBase
{
public:
    ClxBase() {};
    virtual ~ClxBase() {};

    virtual void DoSomething() { cout << "Do something in class ClxBase!" << endl; };
};

class ClxDerived : public ClxBase
{
public:
    ClxDerived() {};
    ~ClxDerived() { cout << "Output from the destructor of class ClxDerived!" << endl; }; 

    void DoSomething() { cout << "Do something in class ClxDerived!" << endl; };
};

ClxBase *pTest = new ClxDerived;
pTest->DoSomething();
delete pTest;
的输出结果是：

Do something in class ClxDerived!
Output from the destructor of class ClxDerived!
这个很简单，非常好理解。
但是，如果把类ClxBase析构函数前的virtual去掉，那输出结果就是下面的样子了：

Do something in class ClxDerived!
也就是说，类ClxDerived的析构函数根本没有被调用！一般情况下类的析构函数里面都是释放内存资源，而析构函数不被调用的话就会造成内存泄漏。我想所有的C++程序员都知道这样的危险性。当然，如果在析构函数中做了其他工作的话，那你的所有努力也都是白费力气。
所以，文章开头的那个问题的答案就是－－这样做是为了当用一个基类的指针删除一个派生类的对象时，派生类的析构函数会被调用。
析构函数执行时先调用派生类的析构函数，其次才调用基类的析构函数。如果析构函数不是虚函数，而程序执行时又要通过基类的指针去销毁派生类的动态对象，那么用delete销毁对象时，只调用了基类的析构函数，未调用派生类的析构函数。这样会造成销毁对象不完全。