c++——类 继承

    //继承
    //继承原则：基类为private，则是可继承，不可访问的
    //其余的是 谁的等级 机密性高 就取谁
    //protected是 不能 在子类外部，中访问的
    //子类&父类  派生类&基类

    //内存的问题：：派生类理解为在派生类的内存中包含了一个无名的基类内存，基类内存在派生类内存区间前面；多继承也是如此

    //构造顺序
    //每一个类的构造分为三步：
    //1.检查是否有基类，如果有就构造基类
    //2.检查是否有子对象，如果有就构造子对象，，，子对象就是有一个其他的类在这个类中去声明定义了一个对象，即，进去给他构造
    //3.构造自身

    //如果没有自己写的带参构造，那么就不用初始化了，但是一旦有自己的构造函数，那么在后面的派生类中的构造函数就要也有参数，来满足对基类的构造，初始化

    //析构顺序：：怎么构造的，就怎么反过来析构
#pragma once
class CNpc
{
    int hp;
public:
    CNpc();
    CNpc(int h, int m);
    ~CNpc();
};

            #include "stdafx.h"
            #include "Npc.h"

            CNpc::CNpc()
            {
                printf("cnpc-1\n");
            }
            CNpc::CNpc(int h, int m)
            {
                printf("cnpc-2\n");
                hp = h;
            }

//*****************************************************
#include "Npc.h"
    class CShopNpc : public CNpc
    {
    public:
        CShopNpc(int h);
        ~CShopNpc();
    };
    
        #include "stdafx.h"
        #include "ShopNpc.h"
        CShopNpc::CShopNpc(int h) : CNpc(h, 2)//,m(3)
        {
            printf("cshopnpc\n");
        }

//******************************************************
#pragma once
#include "ShopNpc.h"
class CM
{
public:
    CM(int  m) { printf("cm\n"); }
    int m;                //这里面的a是没有内存的，只有当定义对象后，才分配内存。
};

class CX : public CShopNpc
{
public:
    CX(int h);
    ~CX();
public:
    CM m;//子对象，类的数据成员为类对象，这个类对象被称为子对象
};

//**************************************************************

CX::CX(int h) : CShopNpc(h), m(4)                    //位置，基类和子类
{
    printf("cx\n");
}

//********************************************************
    class Book
    {
    //构造函数
        Book(const char *the_title, int pages, const char *the_writer):num_pages(pages)
        {
            title=new char[strlen(the_title)+1];
            strcpy(title,the_title);

            writer = new char[strlen(the_writer) + 1];
            strcpy(writer,the_writer);
        }
        ~Book(){ delete[] title,writer; }  //书写形式
        }

    class TeachingMaterial: public Book
    {
        char *course;
    public: //派生类的构造函数必须使用成员初始化列表法来给基类进行初始化
        TeachingMaterial(const char *the_title, int pages, const char *the_writer, const char *the_course): Book(the_title, pages, the_writer)
    {
        course=new char[strlen(the_course)+1];
        strcpy(course,the_course);
    }
}
    //AB两个类，B是A的派生类，show()是全局函数，main函数里有A a; B b; show(a);show(b)，，show的参数就是A类型的，即，基类类型的参数

        //派生类对象必然是一个基类对象，基类对象不是派生类对象
        CFoodBox fb;
        CBox b(1, 2);
        b = fb;
        CFood f(rice);
        f = fb;                

//多继承对于多个基类的构造顺序和继承的声明有关，和成员初始化列表的调用无关
        //子对象的构造顺序和子对象在类中的声明的顺序有关，和成员初始化列表无关。
        class CFoodBox :public CBox, public CFoodBox
        {
        public:
            CFoodBox();
            ~CFoodBox();
        private:
            CY y;
            CX x;
        };        //构造顺序： 基类 子对象 自身： CBox  CFoodBox CY CX CFoodBox；；析构顺序完全相反

//派生类的同名变量赋值
        CE test;
        test.a = 100; //派生类同名变量赋值  自身的
        test.CD::a = 123;    //派生类中的CD基类的a的赋值
        test.CB::a = 456;    //派生类其中一个CB基类的a赋值
        test.CD::CA::a = 200;    //派生类其中的一个CD基类CA基类的a赋值
        test.CB::CA::a = 300;    //派生类其中的一个CB基类CA基类的a赋值
        //都可以访问，实现