【C++碎碎念】面向对象（继承中的非静态同名成员、静态同名成员处理、多重继承）

目录

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

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

 三、多重继承

---

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

1、如果子类和父类出现同名成员，那么通过子类对象去访问同名函数的成员，访问的是子类中的；

2、通过子类对象访问父类中的同名的非静态成员，需要加上作用域。

3、如果子类中出现了父类同名的成员函数，子类的成员函数会隐藏掉父类中所有同名的成员函数；

4、子类重定义父类的成员函数，如果想要调用父类中同名的成员函数，必须加上作用域。

5、如果子类想调用父类的非同名函数，则可以加也可以不加定义域。

#include <iostream>
using namespace std;
class Base{
public:
    int m_A;
    Base(){
        this->m_A=10;
    }
    void func(){
         cout<<"this is func Base"<<endl;
    }
    
};
class Son : public Base{
public:
    int m_A;
    Son(){
        this->m_A=20;
    }
    void func(){
        cout<<"this is func Son"<<endl;
    }
};
int main()
{
    Son s;
    cout<<s.m_A<<endl;//直接读取子类中的数据
    Base b;
    cout<<b.m_A<<endl;//直接读取父类中的数据
    cout<<s.Base :: m_A<<endl;//通过子类去调用父类中的数据，需要加定义域
    cout<<"**************"<<endl;
    s.func();//当子类出现和父类同名的成员函数，子类的成员函数会隐藏掉父类中的同名函数
    s.Base::func();//子类重定义父类的成员函数，如果想调用父类的成员函数，则需要加上定义域
    return 0;

}

输出结果为：

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

1、静态成员在编译的时候就分配好了内存，类的所有对象共享，类内声明，类外初始化；

2、当子类重定义父类中的同名func后，父类中的所有同名函数func都会被隐藏；

3、子类要想调用父类的同名函数，必须加上定义域；

#include <iostream>
using namespace std;
class Base{
public:
    static int m_A;//类内声明
    static func(){
        cout<<"Base..func()"<<endl;
    }
    static func(int a)
    {
        cout<<"Base..func(int a)"<<endl;
    }
};
int Base::m_A=10;//类外初始化
class Son : public Base{
puclic:
    static int m_A;//类内声明
    static func(){
        cout<<"Son...func()"<<endl;
    }
};
int Son::m_A=20;//类外初始化
int main()
{
    Son s;
    cout<<s.m_A<<endl;
    cout<<s.Base::m_A<<endl;
    cout<<s.Son::m_A<<endl;//等价于s.m_A
    cout<<"**************"<<endl;
    Base::func();//通过类名去访问静态成员变量
    Son::func();//通过类名去访问静态成员变量
    Son::Base::func();//第一个Son表示访问Son中的成员变量，第二个Base表示定义域
    return 0;
}

 三、多重继承

一个类可以继承另外一个类，一个类也可以同时继承多个类，这就是多继承；

例如：类A，继承了类B，同时又继承类C

多继承的语法：

class 子类 ： 继承方式 父类1，继承方式  父类2，...

注意事项：继承方式最好不要省略，如果省略，默认是私有继承；

多继承是非常受争议的，从多个类继承可能导致成员方法和成员变量产生歧义。

#include <iostream>
using namespace std;
class Base1{
public:
    int m_A;
    Base1(){
        this->m_A=10;
    }
};
class Base2{
public:
    int m_A;
    int m_B;
    Base2(){
        this->m_A=20;
        this->m_B=30;
    }
};
class Son : public Base1,public Base2{
public:
    int m_C;
    Son(){
        this->m_C=40;
    }
};
int main()
{
    Son s;
    //cout<<s.m_A<<endl;//ambiguous,模糊的，系统不知道要调用Base1还是Base2
//以防万一，最好在成员变量的前面加上定义域
    cout<<s.Base1::m_A<<endl;//10
    cout<<s.Base2::m_A<<endl;//20
    cout<<s.m_B<<endl;//30
    cout<<s.m_C<<endl;//40

    cout<<sizeof(Son)<<endl; //16个字节
    return 0;
}