c++，类和对象 继承 多部分

c++，类和对象，继承，基本语法
#include <iostream>
#include<malloc.h>
#include<stdio.h>
#define MAX 1000
using namespace std;

//继承实现页面
//继承的好处 减少重复代码
class Basepage
{
public:

    void header()
    {
        cout<<"首页登录"<<endl;
    }
    void footer()
    {
        cout<<"帮助中心 交流合作"<<endl;
    }
    void left()
    {
        cout<<"链接"<<endl;
    }

};
class java :public Basepage
{
public:
        void content()
        {
            cout<<"java 视频下载"<<endl;
        }
};
class python :public Basepage
{
public:
        void content()
        {
            cout<<"python 视频下载"<<endl;
        }
};
class cpp :public Basepage
{
public:
        void content()
        {
            cout<<"cpp视频下载"<<endl;
        }
};
void test()
{
    java ja;
    ja.header();
    ja.footer();

    python py;
    py.header();

}

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

c++，类和对象-继承+继承方式
#include <iostream>
#include<malloc.h>
#include<stdio.h>
#define MAX 1000
using namespace std;
class Base1
{
public:
    int m_a;
protected:
    int m_b;
private:
    int m_c;
};
class son1 :public Base1
{
public:
    void func()
    {
        m_a=10;
        m_b=10;//父类中的保护权限成员 到子类中依然是保护权限成员
    }
};
void test()
{
    son1 s1;
    s1.m_a=100; //保护权限类外不可以访问
}
class Base2
{
public:
    int m_a;
protected:
    int m_b;
private:
    int m_c;
};
class son2 :protected Base2
{
public:
    void func()
    {
        m_a=10;//父类中公共成员 到子类中变为保护权限
        m_b=10;//父类中的保护权限成员 到子类中依然是保护权限成员
        //父类中私有成员 子类访问不到
    }
};
void test02()
{
   // son2 s1;
    //s1.m_a=100; //在son2中m_a变为保护权限 ，类外访问不到
}
class Base3
{
public:
    int m_a;
protected:
    int m_b;
private:
    int m_c;
};
class son3:private Base3
{
public:
    void func()
    {
        //m_a=100; //父类中公共成员 到子类中变为私有成员
        //m_b=100；//父类中保护成员 到子类变为私有成员
    }
};
void test03()
{
    son3 s1;
    //s1.m_a=10;

}
class Grandson3:public son3
{
public:
    void func()
    {
        m_a=100;//继承不到
        
    }
};
int main()
{
    system("pause");
    return 0;
}

继承中的对象模型
class Base
{
public:
    int m_a;
protected:
    int m_b;
private:
    int m_c;
};
class son:public Base
{
public:
    int m_d;
    int m_f;
};
void test()
{
    //父类中所有非静态成员属性都会被子类访问下去
    
    cout<<"size of son"<<sizeof(son)<<endl;
}
int main()
{
    test();
    system("pause");
    return 0;
}
//继承 -构造和析构顺序
class Base
{
public:
    Base()
    {
        cout<<"父类构造"<<endl;
    }
    ~Base()
    {
        cout<<"父类析构"<<endl;
    }
};
class Son:public Base
{
public:

    Son()
    {
        cout<<"儿子构造"<<endl;
    }
    ~Son()
    {
        cout<<"儿子析构"<<endl;
    }
};
void test()
{
    Son s;
}
int main()
{
    test();
    system("pause");
    return 0;
}
//同名成员函数处理

using namespace std;
class Base
{
public:
    Base()
    {
        m_a=100;
    }
    void func()
    {
        cout<<"Base-func()调用";
    }
     void func(int a)
    {
        cout<<"int  a a ileoi-func()调用";
    }
    int m_a;
};
class Son :public Base
{
public:
    Son()
    {
        m_a=200;
    }
    void func()
    {
        cout<<"zileoi-func()调用";
    }
    int m_a;
};
void test()
{
    Son s;
    cout<<"son  "<<s.m_a<<endl;
    cout<<"fulei  "<<s.Base::m_a<<endl;
}
void test02()
{
    Son s;
    s.Base::func();
    //s.func(100);
    s.Base::func(100);
    //如果子类中出现和父类同名的成员函数，子类的同名函数会隐藏掉父类中所有的同名函数
}
int main()
{
    // test();
    test02();
    system("pause");
    return 0;
}

c++，同名静态成员函数
#include <iostream>
#include<malloc.h>
#include<stdio.h>
#define MAX 1000
using namespace std;
class Base
{
public:

    static int m_a;
    static void func()
    {
        cout<<"Base-"<<endl;
    }
};
int Base::m_a=100;
class Son:public Base
{
public:
    static int m_a;//静态属于全局变量
    static void func()
    {
        cout<<"sonsss"<<endl;
    }
};
int Son::m_a=100;
void test()
{
    Son s;
    cout<<"sssm_a="<<s.m_a<<endl;
    cout<<"bbbm_a="<<s.Base::m_a<<endl;

    cout<<"通过类名访问"<<endl;
    cout<<"aa"<<Son::m_a<<endl;//通过类名访问
    cout<<"bb"<<Son::Base::m_a<<endl;//代表访问父类作用
}
void test02()
{
    Son s;
    //s.func();
    //s.Base::func();

    cout<<"leiming"<<endl;
    Son::func();
    Son::Base::func();
}
int main()
{
    test();
    system("pause");
    return 0;
}