继承中同名成员的处理方法

同名成员

同名成员的处理方法可以归纳以下几点：

• 子类对象可以直接访问到子类中同名成员。
• 子类对象加作用域可以访问到父类同名成员。
• 当子类与父类拥有同名的成员函数，子类隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数。

归纳的这几点可能有点难以消化，下面给出了相关实例。

代码展示

#include <iostream>
using namespace std;
class Base
{
public:
       Base()
       {
               m_A = 100;
       }
       int m_A;
       void func()
       {
              cout << "Base-func()调用" << endl;
       }
};
class Son:public Base
{
public:
       Son()
       {
              m_A = 200;
       }
       int  m_A;
       void func()
       {
              cout << "Son-func()调用" << endl;
       }
};
void test02()
{
       Son s;
       s.func();        //直接调用 调用是子类中的同名函数
       s.Base::func();  //当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数
}
void test01()
{
       Son s;
       cout << "m_A = " << s.m_A << endl; //子类对象可以直接访问到子类中同名成员
       cout << "m_A = " << s.Base::m_A << endl;//子类对象加作用域可以访问到父类同名成员
}
int main()
{
       test01();
       test02();
       system("pause");
       return 0;
}

运行结果

可以这样解释，先构造父类，再构造子类，析构的顺序与构造的顺序相反，那这个问题就解决了。

静态成员

说到这，大家想一想，对于同名静态成员如何处理呢？我们先来说说静态成员变量和函数有哪些特征。对于静态成员变量它有以下特征：

1. 所有对象都共享一份数据。
2. 便于阶段就分配内存。
3. 类内声明，类外初始化。

对于静态成员函数的特征有：

1. 只能访问静态成员变量，不能访问非静态变量。
2. 共享一份数据。

只了解这些还不够，问题是要解决继承中同名的静态成员在子类对象上如何进行访问！

其实，静态成员和非静态成员出现同名，处理方式保持一致。

• 访问子类同名成员 直接访问即可。
• 访问父类同名函数 需要加作用域。

用下面这段代码解释一下。

代码展示

#include <iostream>
using namespace std;
class Base
{
public:
       static int m_A;
       static void func()
       {
              cout << " Base - static void func(): " << endl;
       }
       static void func(int a)  //函数重载
       {
              cout << " Base - static void func(int a): " << endl;
       }
};
int Base::m_A = 100;
class Son :public Base
{
public:
       static int m_B ;  //类内声明
       static void  func()
       {
              cout << " Son - static void func(): " << endl;
       }
       static void func(int a)  //函数重载
       {
              cout << " Son - static void func(int a): " << endl;
       }
};
int Son::m_B = 200;  //类外定义
//1、访问静态成员变量
void test01()
{
       
       //1、通过对象访问
       Son s;
       cout << "Son::m_B = " << s.m_B << endl;
       cout << "Base::m_A = " << s.Base::m_A << endl;//注意书写方式
       //2、通过类名访问
       cout << "Son :: m_B" << Son::m_B << endl;
       //第一个::表示通过类名的方式询问，第二个::表示通过作用域的方式询问
       cout << "Son:: Base :: m_A" << Son::Base::m_A << endl;
}
//访问静态成员函数
void test02()
{
       //1、通过对象访问
       Son s;
       s.func();
       s.Base::func();
       //2、通过类名访问
       Son::func();
       Son::Base::func();
       Son::Base::func(100);
}
int main()
{
       
       //test01();
       test02();
       system("pause");
       return 0;
}

运行结果 

总结 

同名静态成员处理方式与静态成员处理方式相同，有两种访问方式，一种是对象访问，还有一种时类名访问。