zoukankan      html  css  js  c++  java
  • C++学习笔记之 继承

    继承

    一个类继承另一个类,被继承的叫父类,另一个则是子类,子类可以继承、拓展、重写父类的方法

    基本语法

    class 子类:public 父类
    {}
    

    例:

    #include <iostream>
    #include <string>
    
    using namespace std;
    
    class A
    {
    public:
        void run()
        {
            about();
            cout << "A class is running..." << endl;
        }
    
        void about()
        {
            cout << "This is a class..." << endl;
        }
    };
    
    class B : public A
    {
    public:
        void run()
        {
            about();
            cout << "B class is running..." << endl;
        }
    };
    
    int main()
    {
        A a;
        B b;
        a.run();
        b.run();
        return 0;
    }
    
    This is a class...
    A class is running...
    This is a class...
    B class is running...
    

    派生类

    利用继承机制,新的类可以从已有的类中派生。那些用于派生的类称为这些特别派生出的类的“基类”

    语法

    class 派生类 : 继承方式 基类
    {}
    

    继承方式

    父类中的构造和析构

    #include <iostream>
    #include <cstdio>
    #define print(text) printf("--------------%s--------------
    ",text)
    
    using namespace std;
    
    class Base
    {
    public:
        Base() {
            cout << "Base的默认构造函数调用" << endl;
        }
    
        ~Base() {
            cout << "Base的析构函数调用" << endl;
        }
    };
    
    class Other
    {
    public:
        Other() {
            cout << "Other的默认构造函数调用" << endl;
        }
    
        ~Other() {
            cout << "Other的析构函数调用" << endl;
        }
    };
    
    class Son : public Base
    {
    public:
        Son() {
            cout << "Son的默认构造函数调用" << endl;
        }
    
        ~Son() {
            cout << "Son的析构函数调用" << endl;
        }
    
        Other other;
    };
    
    class Base2
    {
    public:
        Base2(int a) {
            cout << "Base2的有参构造函数调用" << endl;
            this->m_A = a;
        }
    
        ~Base2() {
            cout << "Base2的析构函数调用" << endl;
        }
        
        int m_A;
    };
    
    class Son2 : public Base2
    {
    public:
        Son2(int a = 100):Base2(a) // 通过初始化列表,显示调用父类中的其他的构造函数
        {
            cout << "Son2的有参构造函数调用" << endl;
        }
        
        ~Son2() {
            cout << "Son2的析构函数调用" << endl;
        }
    };
    
    void test01() {
        print("test01");
        // Base b;
        Son s; // 当创建子类对象时,先调用父类构造函数,再调用其他类的构造函数,最后调用子类构造函数,析构函数相反
    }
    
    void test02() {
        print("test02");
        Son2 s = Son2(10);
        cout << s.m_A << endl;
    }
    
    int main() {
        test01();
        test02();
        print("end");
    
        return EXIT_SUCCESS;
    }
    
    --------------test01--------------
    Base的默认构造函数调用
    Other的默认构造函数调用
    Son的默认构造函数调用
    Son的析构函数调用
    Other的析构函数调用
    Base的析构函数调用
    --------------test02--------------
    Base2的有参构造函数调用
    Son2的有参构造函数调用
    10
    Son2的析构函数调用
    Base2的析构函数调用
    --------------end--------------
    

    同名成员

    继承中的非静态同名成员处理

    #include <iostream>
    #include <cstdio>
    #define print(text) printf("--------------%s--------------
    ",text)
    
    using namespace std;
    
    class Base
    {
    public:
        int m_A;
    
        Base() {
            this->m_A = 10;
        }
    
        void run() {
            cout << "Base running..." << endl;
        }
    
        void run(int a) {
            cout << "Base running " << a << "..." << endl;
        }
    };
    
    class Son : public Base
    {
    public:
        Son() {
            this->m_A = 100;
        }
    
        void run() {
            cout << "Son running..." << endl;
        }
    };
    
    void test01() {
        print("test01");
        Son s;
        cout << "Son.m_A = " << s.m_A << endl;
    
        // 如果想访问父类中同名的非静态成员变量,需要加作用域
        cout << "Base.m_A = " << s.Base::m_A << endl;
    }
    
    void test02() {
        print("test02");
        Son s;
        s.run();
        s.Base::run(); // 如果想访问父类中同名的非静态成员函数,需要加作用域
    
        // 如果子类中出现了和父类同名的非静态成员函数,子类的成员函数会隐藏掉父类中所有的成员函数
        s.Base::run(2);
    }
    
    int main() {
        test01();
        test02();
        print("end");
    
        return EXIT_SUCCESS;
    }
    
    --------------test01--------------
    Son.m_A = 100
    Base.m_A = 100
    --------------test02--------------
    Son running...
    Base running...
    Base running 2...
    --------------end--------------
    

    继承中的静态同名成员处理

    #include <iostream>
    #include <cstdio>
    #define print(text) printf("--------------%s--------------
    ",text)
    
    using namespace std;
    
    class Base
    {
    public:
        // 共享同一个数据
        // 编译阶段分配内存
        // 类内声明,类外初始化
        static int m_A;
    
        static void run() {
            cout << "Base下的run调用" << endl;
        }
    
        static void run(int a) {
            cout << "Base下的run(int)调用" << endl;
        }
    };
    int Base::m_A = 10;
    
    class Son : public Base
    {
    public:
        static int m_A;
    
        static void run() {
            cout << "Son下的run调用" << endl;
        }
    };
    int Son::m_A = 20;
    
    void test01() {
        print("test01");
    
        // 通过对象访问
        Son s;
        cout << "Son m_A = " << s.m_A << endl;
        cout << "Base m_A = " << s.Base::m_A << endl;
    
        // 通过类名访问
        cout << "Son m_A = " << Son::m_A << endl;
        cout << "Base m_A = " << Son::Base::m_A << endl;
    }
    
    void test02() {
        print("test02");
        // 通过对象访问
        Son s;
        s.run();
        s.Base::run();
        s.Base::run(1);
    
        // 通过类名
        Son::run();
        Son::Base::run();
        Son::Base::run(1);
    }
    
    int main() {
        test01();
        test02();
        print("end");
    
        return EXIT_SUCCESS;
    }
    
    --------------test01--------------
    Son m_A = 20
    Base m_A = 10
    Son m_A = 20
    Base m_A = 10
    --------------test02--------------
    Son下的run调用
    Base下的run调用
    Base下的run(int)调用
    Son下的run调用
    Base下的run调用
    Base下的run(int)调用
    --------------end--------------
    

    多继承

    基本语法

    class 子类 : 继承方式 父类1, 继承方式 父类2
    {}
    

    一般不建议使用多继承

  • 相关阅读:
    configure.ac:91: error: possibly undefined macro: AC_SEARCH_LIBS
    debian上安装tmux
    ssh: Bad configuration option: usedns
    mysql启动失败“MySQL Daemon failed to start”
    批量查询文件的编码格式
    mysql计算QPS
    网络资源汇总
    jQuery Mobile + HTML5
    配置SQL Server 2008 R2 Reporting Services
    分享一个C#创建Barcode的DLL
  • 原文地址:https://www.cnblogs.com/zhujiangyu/p/14090917.html
Copyright © 2011-2022 走看看