C++中的继承

1、继承的相关概念：
继承是不修改已存在的类，而是采取这个已存在类的形式，并将代码加入其中的方法，是面向对象复用的重要手段。继承的语法是：在代码中和原来一样给出该类的名字，但是在左括号的前面加一个冒号和基类的名字（对于多重继承，要给出多个基类名，用逗号隔开）。

（1）派生类将继承基类的数据和函数
【例】

class A  //基类（父类）
{
public:
    void Func1(void);
    void Func2(void);
    int i = 100; 
};

class B :public A //子类（派生类），继承关系是public
{
public:
    void Func3(void);
    void Func4(void);
};

int main()
{
    B b;
   b.i;       //B从A继承数据i
    b.Func1();//B从A继承函数func1()
    b.Func2();//B从A继承函数func2()
    b.Func3();
    b.Func4();
}

（2）继承可以调用基类的函数来实现自己的函数。
【例】

class A
{
public:
    void Func1(void);
    void Func2(void);
};

class B : public A   //B继承A
{
public:
    void Func3(void)
    {
        A::Func1();//先调用基类的函数（1.为何要调用而不直接引用？？？）
        ...        //自己的实现代码
    }
    void Func4(void)
    {
        ...  //自己的实现代吗
            A::Func2(); //后调用基类的函数
    }
};

2、成员访问限定符与继承的关系
如图1：

图1 成员访问限定符与继承的关系

三种继承关系下基类成员在派生类的访问关系变化，如表1：
表1 继承与基类成员在派生类中的访问关系表

总结：
1）基类的私有成员在派生类中不能被访问，如果一些基类成员不想被基类对象直接访问，可以定义为保护成员。
2）public继承是一个接口继承，保持is-a原则（2.是什么？？），每个父类可用的成员对子类也可用，因为每个子类对象也是一个父类对象。
3）protect/private继承基类的部分成员并未成为子类的一部分，是has-a的关系原则（3.是什么？？），这种继承关系很少用，一般用public继承关系。
4）不管哪种继承关系，在派生类内部都可以访问基类中的公有成员和保护成员，但是子类中的成员不能访问父类中的私有成员。
5）使用struct时的默认继承关系是public,而class时的默认继承关系是private，最好是把继承方式写出来。

3、继承与转换
1）子类对象可以赋值给父类对象。
2）父类对象不可以赋值给子类对象。
3）父类对象的指针和引用可以指向子类对象。
4）子类对象的指针和引用不能指向父类对象，但是可以通过强制转化完成。
【例】

class Person
{
public:
    void Display()
    {
        cout << _name << endl;
    }
protected:
    string _name;
};

class Student : public Person
{
public:
    int _num;
};

void Test()
{
    Person p;
    Student s;

    //子类对象可以赋值给父类对象
    p = s;
    //父类对象不可以赋值给子类对象
    //s = p;//error

    //父类对象的指针和引用可以指向子类对象
    Person *p1 = &s;
    Person& r1 = s;

    //子类对象的指针和引用不能指向父类的对象(但是可以通过强制类型转化完成)
    Student *p2 = (Student*)&p;
    Student& r2 = (Student&)p;
}

4、继承体系中的作用域
（1）在继承体系中基类和派生类都有独立的作用域。
（2）子类和父类中有同名成员，子类成员将屏蔽父类成员的直接访问。（在子类成员函数中，可以使用基类：：基类成员访问）
（3）注意尽量不要在继承体系中定义同名的成员。
【例】

class Person
{
public:
    Person(const char* name = "", int id = 0)
        :_name(name)
        , _num(id)
    {}
protected:
    string _name;  //姓名
    int _num;      //身份证
};

class Student : public Person
{
public:
    Student(const char *name, int id, int stuNum)
        :Person(name, id)
        , _num(stuNum)
    {}

    void DisplayNum()
    {
        cout << "身份证：" << Person::_num << endl;
        cout << "学号" << _num << endl;
    }
protected:
    int _num;  //学号
};

void Test()
{
    Student s1("paul", 110, 1);
    s1.DisplayNum();
}

int main()
{
    Test();
    system("pause");
    return 0;
}

4、派生类的默认成员函数
在继承关系里，派生类中如果没有显示定义这六个成员函数，编译系统则会默认合成六个成员函数，即构造函数、拷贝构造函数、析构函数、赋值操作符重载、取地址操作符重载、const修饰的取地址操作符重载。
【例】

class Person
{
public:
    Person(const char* name)
        :_name(name)
    {
        cout << "Person()" << endl;
    }

    Person(const Person& p)
        :_name(p._name)
    {
        cout << "Person(const Person& p)" << endl;
    }

    Person& operator = (const Person& p)
    {
        cout << "Person operatpr = (const Person& p)" << endl;
        if (this != &p)
        {
            _name = p._name;
        }
        return *this;
    }

    ~Person()
    {
        cout << "~person()" << endl;
    }

protected:
    string _name;//姓名
};


class Student : public Person
{
public:
    Student(const char* name, int num)
        :Person(name)
        , _num(num)
    {
        cout << "student()" << endl;
    }

    Student(const Student& s)
        :Person(s)
        ,_num(s._num)
    {
        cout << "Student(const Student& s)" << endl;
    }

    Student& operator = (const Student& s)
    {
        cout << "Student& operator = (const Student& s)" << endl;
        if (this != &s)
        {
            Person::operator=(s);
            _num = s._num;
        }
        return *this;
    }

    ~Student()
    {
        cout << "~Student()" << endl;
    }
private:
    int _num; //学号
};

void Test()
{
    Student s1("jack", 18);
    Student s2(s1);
    Student s3("rose", 17);
    s1 = s3;
}

int main()
{
    Test();
    system("pause");
    return 0;
}

5、单继承和多重继承
（1）单继承：一个子类只有一个直接父类
（2）多继承：一个子类有两个或以上个直接父类
如图2：

图2 单继承与多继承图

6、菱型继承
如图3：

图3 菱形继承图

菱形继承对象模型，如图4：

图4 菱形继承对象模型图
【例】

//菱形继承
class Person
{
public:
    string _name;//姓名
};

class Student : public Person
{
protected:
    int _num; //学号
};

class Teacher : public Person
{
protected:
    int _id; //职工编号
};

class Assistant : public Student, public Teacher
{
protected:
    string _majorCorse; //主修课程
};

void Test()
{
    Assistant a;
    a.Student::_name = "xxx";
    a.Teacher::_name = "yyy";
}

int main()
{
    Test();
    system("pause");
    return 0;
}

7、友元与继承
友元关系不能继承，也就是说基类友元不能访问子类私有和保护的成员。
【例】

//友元与继承
class Person
{
    friend void Display(Person& p, Student& s);
protected:
        string _name; //姓名
};

class Student : public Person
{
protected:
    int _stuNum; //学号
};

void Display(Person& p, Student& s)
{
    cout << p._name << endl;
    cout << s._name << endl;
    cout << s._stuNum << endl;
}

void Test()
{
    Person p;
    Student s;
    Display(p, s);
}

8、继承与静态成员
基类定义了static成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例。即：如果我们重新定义了一个静态成员，所有在基类中的其他重载函数会被隐藏。如果我们改变了基类中一个函数的特征，所有使用函数名字的基类版本都将会被隐藏。
【例】

//继承与静态成员
class Person
{
public:
    Person()
    {
        ++_count;
    }
protected:
    string __name;  //姓名
public:
    static int _count; //统计人的个数
};

int Person::_count = 0;

class Student : public Person
{
protected:
    int _stuNum; //学号
};

class Graduate : public Student
{
protected:
    string _seminarCourse; //研究科目
};

void Test()
{
    Student s1;
    Student s2;
    Student s3;

    Graduate s4;

    cout << "人数" << Person::_count << endl;

    Student::_count = 0;

    cout << "人数:" << Person::_count << endl;
}

int main()
{
    Test();
    system("pause");
    return 0;
}

9、虚函数
（1）概念：类的成员函数前面加virtual关键字。
（2）虚函数重写：当在子类中定义了一个与父类完全相同的虚函数时，则称子类的这个函数重写了父类的这个虚函数。如图5所示：

图5 虚函数表示图

（3）总结：
1）派生类重写基类的虚函数实现多态，要求函数名、参数列表、返回值完全相同（协变除外）。
2）基类中定义了虚函数，在派生类中该函数始终保持虚函数的特性。
3）只有类的成员函数才能定义虚函数。
4）如果在类外定义虚函数，只能在声明函数是加virtual，在类外定义函数时不能加virtual。
5）静态成员函数不能定义虚函数。
6）构造函数不能为虚函数，虽然可以将operator=定义为虚函数，但是最好不要，因为容易在使用时混淆。
7）不要在构造函数和析构函数里调用虚函数，在构造函数和析构函数中，对象是不完整的，可能会发生未定义的行为。
8）最好把析构函数声明为虚函数。因为派生类的析构函数跟基类的析构函数名称不一样，但是构成覆盖。看图6：
【例】

//虚函数
class Person
{
public:
    virtual void BuyTickets()
    {
        cout << "买票" << endl;
    }
protected:
    string _name; // 姓名
};

class Student : public Person
{
public:
    virtual void BuyTickets()
    {
        cout << "买票-半价" << endl;
    }
protected:
    int _num;//学号
};


void Fun(Person& p)
{
    p.BuyTickets();
}

void Test()
{
    Person p;
    Student s;
    Fun(p);
    Fun(s);
}

int main()
{
    Test();
    system("pause");
    return 0;
}