【C++基础入门】41.C++中父子间的冲突

一、思考

        子类中是否可以定义父类中的同名成员？如果可以，如何区分？如果不可以，为什么？

        下面看一段代码：

#include 

using namespace std;

class Parent
{
public:
    int mi;
};

class Child
{
public:
    int mi;
};

int main()
{
    Child c;
    
    c.mi = 100; //mi究竟是子类定义的，还是从父类继承得到的？
    
    return 0;
}

        编译也可以正常通过，只是引出一个问题， mi究竟是子类定义的，还是从父类继承得到的？

二、父子间的冲突

• 子类可以定义父类中的同名成员
• 子类的成员将隐藏父类中的同名成员
• 父类中的同名成员依然存在于子类中
• 通过作用域分辨符（ :: ）访问父类中的同名成员
• 访问父类中的同名成员

        下面看一段代码：

#include 

using namespace std;

class Parent
{
public:
    int mi;
    
    Parent()
    {
        cout << "Parent() : " << "&mi = " << &mi << endl;
    }
};

class Child : public Parent
{
public:
    int mi;
    
    Child()
    {
        cout << "Child() : " << "&mi = " << &mi << endl;
    }
};

int main()
{
    Child c;
    
    c.mi = 100; 
    
    c.Parent::mi = 1000;
    
    cout << "&c.mi = " << &c.mi << endl;
    cout << "c.mi" << c.mi << endl;
    
    cout << "&c.Parent::mi = " << &c.Parent::mi << endl;
    cout << "c.mi = " << c.Parent::mi << endl;
    
    return 0;
}

         输出结果如下：

        通过打印信息中父类和子类中 mi 的地址可以看出，通过直接访问的方式访问的 mi 是子类中的 mi ， 使用父类的作用域分辨符访问的 mi 是父类中的 mi

三、再论重载

        下面看一段代码：

#include 

using namespace std;

class Parent
{
public:
    int mi;
    
    void add(int v)
    {
        mi += v;
    }
    
    void add(int a, int b)
    {
        mi += (a + b);
    }
};

class Child : public Parent
{
public:
    int mi;
    
    void add(int x, int y, int z)
    {
        mi += (x + y + z);
    }
};

int main()
{
    Child c;
    
    c.mi = 100;
    
    c.Parent::mi = 100;
    
    cout << "c.mi = " << c.mi << endl;
    cout << "c.Parent:: mi = " << c.Parent::mi << endl;
    
    c.add(1);
    c.add(2, 3);
    c.add(4, 5, 6);
    
    cout << "c.mi = " << c.mi << endl;
    cout << "c.Parent::mi = " << c.Parent::mi << endl;
    
    return 0;
}

        编译后报错，输出如下： 

• 这是因为子类中定义的同名成员函数会覆盖父类中的同名成员函数， 产生的效果是父类中的两个add函数被隐藏，无法通过子类对象访问调用
• 这也不是重载，因为函数重载必须发生在同一个作用域中，因此这里发生的是同名覆盖

•  类中的成员函数可以进行重载
  • 重载函数的本质为多个不同的函数
  • 函数名和参数列表是唯一的标识
  • 函数重载必须发生在同一个作用域中

        问题：子类中定义的函数是否能重载父类中的同名函数?（答案是不能，因为子类和父类不在同一作用域）

       要想代码能够正常编译通过，解决方法就是加上作用域分辨符，如下：

#include 

using namespace std;

class Parent
{
public:
    int mi;
    
    void add(int v)
    {
        mi += v;
    }
    
    void add(int a, int b)
    {
        mi += (a + b);
    }
};

class Child : public Parent
{
public:
    int mi;
    
    void add(int x, int y, int z)
    {
        mi += (x + y + z);
    }
};

int main()
{
    Child c;
    
    c.mi = 100;
    
    c.Parent::mi = 1000;
    
    cout << "c.mi = " << c.mi << endl;
    cout << "c.Parent:: mi = " << c.Parent::mi << endl;
    
    c.Parent::add(1);
    c.Parent::add(2, 3);
    c.add(4, 5, 6);
    
    cout << "c.mi = " << c.mi << endl;
    cout << "c.Parent::mi = " << c.Parent::mi << endl;
    
    return 0;
}

        输出结果如下：

四、结论

• 子类中的函数将隐藏父类的同名函数
• 子类无法重载父类中的成员函数
• 使用作用域分辨符访问父类中的同名函数
• 子类可以定义父类中完全相同的成员函数

        对于子类可以定义父类中完全相同的成员函数，可以通过下面的代码表示：

#include 

using namespace std;

class Parent
{
public:
    int mi;
    
    void add(int v)
    {
        mi += v;
    }
    
    void add(int a, int b)
    {
        mi += (a + b);
    }
};

class Child : public Parent
{
public:
    int mi;
    
    void add(int v)
    {
        mi += v;
    }
    
    void add(int a, int b)
    {
        mi += (a + b);
    }
    
    void add(int x, int y, int z)
    {
        mi += (x + y + z);
    }
};

int main()
{
    Child c;
    
    c.mi = 100;
    
    c.Parent::mi = 1000;
    
    cout << "c.mi = " << c.mi << endl;
    cout << "c.Parent:: mi = " << c.Parent::mi << endl;
    
    c.add(1);
    c.add(2, 3);
    c.add(4, 5, 6);
    
    cout << "c.mi = " << c.mi << endl;
    cout << "c.Parent::mi = " << c.Parent::mi << endl;
    
    return 0;
}

        输出结果如下： 

五、小结

• 子类可以定义父类中的同名成员
• 子类中的成员将隐藏父类中的同名成员
• 子类和父类中的函数不能构成重载关系
• 子类可以定义父类中完全相同的成员函数
• 使用作用域分辨符访问父类中的同名成员