C++第六篇（接上）

复习：

一、友元

1.全局函数做友元：

class A
{
        friend void fun(int _n1);
}；

2.类做友元

class A
{
         friend class B;
}；

3.成员函数做友元

class A;
class B
{
        public:
         void fun(A & a1);
}；
class A
{
         friend void B::fun(A  &);
}；

今日内容：

二、继承

1.当定义一个新的类时，发现该类具备之前某一个类的基本属性及方法时，就可使用继承技术.
2.意义：减少代码重复率，增加代码利用率

1、继承对象模型

1、C++对象中，成员属性 与 成员函数是分开存储的，类的内存大小和成员函数没有关系.
但是成员函数在逻辑上是属于类的.

例如：以下：sizeof(A) = 8

class A

{

public:

        void fun() //成员函数

        {

        }

private:

        int num;

        short age;

        char ch;

};

2、继承关系中，子类会继承所有父类的成员属性 以及 成员函数， 但是私有成员被继承后被编译器屏蔽，所以私有成员是不能访问的.
3、继承关系中，先构造父对象、再构造子对象，析构顺序相反.
4、如果出现子类成员 与 父类成员同名情况，则父类的成员会被隐藏，对象直接访问的话，访问到的是子类自己的成员. 如果想要访问父类成员，则需要使用作用域符号  ::    例如：

#include <iostream>
using namespace std;

class A
{
public:
    void fun()
    {
        cout << "A" << endl;
    }
};

class B: public A
{
public:
    void fun()
    {
        cout << "B" << endl;
    }
};

int main()
{
    B b1;
    b1.fun();    
    b1.A::fun();

    A *a1 = new B;
    a1->fun();
    return 0;
}

答案：B     A    A

5、在继承模型中，父类中的静态成员变量 以及 静态成员函数，也会被子类的所有对象共享. !!!!

2、多继承

class A: <继承权限> <类名>，<继承权限> <类名>
{
}；

注意：实际开发应减少多继承方式，因为当你继承多个基类时，基类里面的成员名一样时，将会产生二义性。（例如以下代码）

#include <iostream>
using namespace std;

class Sheep
{
public:
    Sheep():s_kind("山羊")
    {
        age = 2;
    }
    int age;
    string s_kind;
};

class Cow
{
public:
    Cow():c_kind("牦牛")
    {
        age = 3;
    }
    int age;
    string c_kind;
};

class SiBuXiang:public Sheep, public Cow
{
public:
    int age;
};

void test01()
{
    SiBuXiang s1;
    cout << s1.c_kind << endl;
    cout << s1.age << endl;    //二义性
    cout << s1.Cow::age << endl;
    cout << s1.Sheep::age << endl;
}
int main()
{
    test01();
    return 0;
}

 以上代码答案为：耗牛   随机数   3   2

3、虚继承

1.在多继承基础上，如果多个父类又是继承于同一个父类，那么成员访问就会出现问题.
这种继承方式又称 菱形继承
2.虚继承方式:

class B:virtual public A
{
}；

作用：虚继承不是真正的继承成员属性，而是生成一个虚基类指针(vbptr)，该指针可以实现访问
同一个属性，而不出现二义性.
原理：虚基类指针vbptr指向一个虚基类表vbtable，表中记录了到虚基类中成员变量的偏移量，通
过偏移量就能够正确找到同一个成员变量.

三、多态

一个函数接口可以实现多种状态（一个函数接口多个功能）

例如：

#include <iostream>
using namespace std;

class Animal
{
public:
    virtual void Speak()
    {
        cout << "animal speak" << endl;
    }
};

class Cat: public Animal
{
public:
    virtual void Speak()
    {
        cout << "cat speak" << endl;
    }
};

class Dog: public Animal
{
public:
    virtual void Speak()
    {
        cout << "dog speak" << endl;
    }
};

void AnimalSpeak(Animal &a1)  //函数接口，AnimalSpeak() 谁调用就只会调用自己的
{
    a1.Speak();
}

void test01()
{
    Animal a2;     
    AnimalSpeak(a2);  //答案：animal speak
    Dog d1;
    AnimalSpeak(d1);   //答案：dog speak
    Cat c1;
    AnimalSpeak(c1);  //答案：cat speak
}

int main()
{
    test01();
    return 0;
}

1.多态分类

实现条件：
1. 类之间需要有继承关系.
2. 实现多态的函数需要以 virtual 来进行声明. （被称为虚函数）
3. 父类中的虚函数需要被子类重写
重写：返回值、函数名、参数都必须一致.

语法：

        class A 
        {
                 virtual void fun(int _n1);
        };
        class B:public A
        {
                 virtual void fun(int _n1);  //重写A中的虚函数.
        };

多态的优点: 实际开发中，建议多用多态来设计程序
1. 结构清晰，便于理解.
2. 利于后期代码扩展、维护. 实现了对修改屏蔽、对扩展开放.
多态接口实现：
需要使用父类指针 或 父类引用 指向子类对象!!!，直接将子类对象赋值给父类对象是不行的.

Base *b = new Son1;  //父类指针指向子类对象
b->fun();   //调用子类中的函数

Son1 s1;
Base &b = s1;
b.fun();   //调用子类中的函数

Base b2;
b2 = s1;   //直接赋值，调用父类函数，没有实现多态

四、虚函数

1.就是 virtual 修饰的成员函数.
2.虚函数要求必须有实现过程，不能只是声明.

class A
{
        virtual void fun(int);  //声明
}；
void A::fun(int _n1)   //实现过程
{
}；

3.纯虚函数：
有时候，父类里面的虚函数根本没有实现的必要，此时可以声明为纯虚函数. 纯虚函数不需要
具体实现：

class A
{
        virtual void fun(int) = 0;  //纯虚函数声明
}；

有纯虚函数的类被称为抽象类，抽象类不能实例化对象.