C++ 核心编程 继承

#include<iostream>
using namespace std;
//普通实现页面

//Java 页面
class Java {
public:
    void header() 
    {
        cout << "首页、公开课、登录、注册>>>>（公共头部）" << endl;
    
    }
    void footer()
    {
        cout << "帮助中心、合作（公共底部）" << endl;

    }
    void lest() 
    {
        cout << "Java python c++ (公共列表分类)" << endl;
    
    }
    void content()
    {
        cout << "Java 学科视频" << endl;
    
    }

};

//Python 页面
class Python {
public:
    void header()
    {
        cout << "首页、公开课、登录、注册>>>>（公共头部）" << endl;

    }
    void footer()
    {
        cout << "帮助中心、合作（公共底部）" << endl;

    }
    void lest()
    {
        cout << "Java python c++ (公共列表分类)" << endl;

    }
    void content()
    {
        cout << "Python 学科视频" << endl;

    }

};
//C++ 页面
class CPlus {
public:
    void header()
    {
        cout << "首页、公开课、登录、注册>>>>（公共头部）" << endl;

    }
    void footer()
    {
        cout << "帮助中心、合作（公共底部）" << endl;

    }
    void lest()
    {
        cout << "Java python c++ (公共列表分类)" << endl;

    }
    void content()
    {
        cout << "C++ 学科视频" << endl;

    }

};
void test01()
{

    cout << "Java下载视频页面如下" << endl;
    Java ja;
    ja.header();
    ja.footer(); 
    ja.lest();
    ja.content();


    cout << "________________________" << endl;
    cout << "python下载视频页面如下" << endl;
    Python py;
    py.header();
    py.footer();
    py.lest();
    py.content();

    cout << "________________________" << endl;
    cout << "c++下载视频页面如下" << endl;
    CPlus c;
    c.header();
    c.footer();
    c.lest();
    c.content();
}

int main() {

    test01();

    system("pause");
    return 0;

}

继承的写法

#include<iostream>
using namespace std;
//普通实现页面

//继承实现页面
class BasePage {
    public:
        void header()
        {
            cout << "首页、公开课、登录、注册>>>>（公共头部）" << endl;
    
        }
        void footer()
        {
            cout << "帮助中心、合作（公共底部）" << endl;
    
        }
        void lest()
        {
            cout << "Java python c++ (公共列表分类)" << endl;
    
        }
};
//继承好处 ：减少重复代码
//语法 ：class 子类 ： 继承方式 父类
//子类也称为派生类
//父类也称为 基类

//Java 页面
class Java :public BasePage {
public:
        void content()
        {
            cout << "Java 学科视频" << endl;
        
        }
};
//Python 页面
class Python :public BasePage {
public:
    void content()
    {
        cout << "Python 学科视频" << endl;

    }
};
//CPlus 页面
class CPlus :public BasePage {
public:
    void content()
    {
        cout << "CPlus 学科视频" << endl;

    }
};


void test01()
{

    cout << "Java下载视频页面如下" << endl;
    Java ja;
    ja.header();
    ja.footer(); 
    ja.lest();
    ja.content();


    cout << "________________________" << endl;
    cout << "python下载视频页面如下" << endl;
    Python py;
    py.header();
    py.footer();
    py.lest();
    py.content();

    cout << "________________________" << endl;
    cout << "c++下载视频页面如下" << endl;
    CPlus c;
    c.header();
    c.footer();
    c.lest();
    c.content();
}

int main() {

    test01();

    system("pause");
    return 0;

}

 

#include<iostream>
using namespace std;

//继承方式 
//公共继承

class Base1 {
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

//公有继承
class BaseA :public Base1 {
public:
    void func() {
    
        m_A = 10;//父类中的公共权限成员  到子类中依然是公共权限
        m_B = 10;//父类中保护权限成员 到子类中依然是保护权限 可以访问
        //m_C = 10;//父类中的私有权限成员  到子类中不可以访问
    }
};

void test01() {
    BaseA s1;
    s1.m_A = 100;
    //s1.m_B = 100;//成员函数在类内可以访问，在类外访问不到

}

class Base2 {
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};
//保护继承
class BaseB : protected Base2 {
public:
    void func() {

        m_A = 100;//父类中的公共成员  到子类中变为保护权限
        m_B = 100;//父类中保护权限成员 到子类中依然是保护权限 可以访问
        //m_C = 100;//m_C = 10;//父类中的私有成员子类中不可以访问
    }

};

void test02() {
    BaseB s1;
    //s1.m_A = 1000;//在BaseB中 m_A变为了保护权限  因此类外不可以访问
    //s1.m_B = 1000;//在BaseB中 m_B保护权限  类外不可以访问

}

class Base3 {
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};
//私有继承
class BaseC : private Base3{
public:
    void func() {

        m_A = 100;//父类中的公共成员  到子类中变为私有成员
        m_B = 100;//父类中保护权限成员 到子类中依然是私有成员
        //m_C = 100//m_C = 10;//父类中的私有成员子类中不可以访问
    }

};

class GrandSon3 :public Base3 {
public:
    void func() {
        //m_A = 100;//到了 Base3中   m_A变为私有  即使是儿子  也是访问不到
        //m_B = 100;//
    }

};
void test03() 
{
    BaseC s1;
    //s1.m_A = 1000;//在此类中  变为私有成员 访问不到
    //s1.m_B = 1000;//
}
int main() {

    system("pause");
    return 0;

}

 

 

 

 

#include<iostream>
using namespace std;

//继承中的对象模型

class Base {
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};
class son :public Base {

public:
    int m_D;

};
//利用开发人员命令提示工具查看对象模型
//跳转盘符 F：
//跳转文件路径 cd 具体路径下
//查看命名
//cl /d1 reportSingleClassLayout 类名 文件名 
void test01() {
    //16
    //父类中所有非静态成员属性都会被子类继承下去
    //父类中私有成员属性  是被编译器给隐藏了 因此是访问不到 但是确实被继承下去了

    cout << "size of son =" << sizeof(son) << endl;

}
int main() {

    test01();
    system("pause");
    return 0;
}

结论：父类中的私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到

 

 

#include<iostream>
using namespace std;

class Person {
public:
    Person() {
        m_A = 200;
    }

    void func() 
    {
        cout << "Base-func()下函数调用" << endl;
    }
    void func(int a)
    {
        cout << "son-func(int a)下函数调用" << endl;
    }
    int m_A;
};

class son :public Person {
public:
    son() {
        m_A = 100;

    }

    void func()
    {
        cout << "son-func()下函数调用" << endl;
    }

    int m_A;
};

//同名成员属性
void test01() {
    son s;
    cout << " son 里的m_A" <<s.m_A<< endl;
    //通过子类对象，访问到父类同名成员，需要加作用域
    cout << "Person 里的m_A" << s.Person::m_A << endl;
}
//同名成员函数
void test02()
{
    son s;
    s.func();
    //如何调用到父类中的同名成员函数
    s.Person::func();
    //如果子类中出现了和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
    //如果想访问父类中被隐藏的同名成员函数，需要加作用域
    //s.func(100); //c错误模式
    s.Person::func(100);//成功
}
int main() {
    test02();

    system("pause");
    return 0;
}

 

#include<iostream>
using namespace std;
//继承中的同名静态成员处理方式

class Base {
public:
    static int m_A;//类内声明  类外初始化
    void func() {
        cout << "Base --静态函数关键字" << endl;
    
    }


};
 int Base::m_A=100;

 class Son :public Base {
 public:
     static int m_A;//类内声明  类外初始化 
     void func() {
         cout << "Son --静态函数关键字" << endl;

     }
 
 };
 int Son::m_A = 200;
//同名的静态成员属性
 void test01() {
     //通过对象来访问数据
     Son s;
     cout << "Son 下m_A =" << s.m_A << endl;
     cout << "Base 下m_A =" << s.Base::m_A << endl;
     
     //2 通过类名方式访问
     cout << "通过类名的方式访问" << endl;
     cout << "Son 下m_A" << Son::m_A << endl;
     cout << "Base 下m_A" << Base::m_A << endl;
     //子类对象访问父类中的m_A数据，并且通过类名的方式访问
     //第一个::代表通过类名的方式访问，  第二个::代表访问父类作用域下
     cout << "Son：：Base 下m_A" << Son::Base::m_A << endl;

 
 }
 //同名静态成员函数
 void test01() {
    // //通过对象访问
    // cout << "通过对象访问" << endl;
    // Son s;
    // s.func();
    // s.Base::func();
    // //通过类名访问
    // cout << "通过类名的方式访问:" << endl;
    // //Son::func();
    //// Son::Base::func();
 }


 void test02() {
     //通过对象访问
     cout << "通过对象访问" << endl;
     Son s;
     s.func();
     s.Base::func();
     //通过类名访问
     cout << "通过类名的方式访问:" << endl;
     //子类出现和父类同名静态成员函数  也会隐藏父类中所有同名成员函数
     //如果想访问父类中被隐藏同名成员 需要加作用域
    // Son::func();
    //  Son::Base::func();
 
 
 }
int main() {
    //test01();
    test02();

    system("pause");
    return 0;
}