类的继承——父子间的冲突_sv中派生类可以通过类作用域操作符来访问父类的变量和方法-CSDN博客

本文链接：https://blog.csdn.net/small_prince_/article/details/80505780

本文参照于狄泰软件学院，唐佐林老师的——《C++深度剖析教程》

问题：既然子类继承了父类的属性和行为。那么如果子类中是否可以定义父类中的同名成员呢？如果可以，程序是如何进行区分的？如果不可以，为什么？

父类同名成员变量

示例代码：同名成员变量

#include <iostream>
#include <string>
using namespace std;
class Parent
{
public:
    int mi;
};
class Child : public Parent
{
public:
    int mi;
};

int main()
{
    Parent p;
    Child c;

    c.mi = 100;    // mi 究竟是子类自定义的，还是从父类继承得到的？

    cout << "c.mi = " << c.mi << endl;
    cout << "p.mi = " << p.mi << endl;

    return 0;
}

在输出前我们可以进行猜测。c.mi = 100到底是赋值给子类还是父类的变量。
1. 根据字面语义：c.mi是子类Child的变量。
2. 猜测编译器的行为：当我们使用一个成员变量时，首先会在子类中寻找，只有在子类找不到的情况下，才去使用父类的成员变量。

输出结果：
c.mi = 100
p.mi = -1075139656

从输出结果可以知道：
1. 子类可以定义父类中的同名成员
2. 子类中的成员将隐藏父类中的同名成员。
我们无法直接从子类访问到父类的同名成员。

通过作用域操作符访问父类同名成员

问题：那么父类的同名成员就真的无法访问到了吗？

实际上，父类中的同名成员依然存在于子类中，我们可以通过作用域操作符(::)访问父类的同名成员
c.mi = 100; //子类中的mi
c.Parent::mi = 1000; //父类中的mi

问题：为什么子类可以存在于父类同名的成员变量？

示例代码：同名成员变量深度分析

#include <iostream>
#include <string>

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.Parent::mi = " << c.Parent::mi << endl;

    return 0;
}

输出结果：
Parent() : &mi = 0xbfd507f8
Child() : &mi = 0xbfd507fc
&c.mi = 0xbfd507fc
c.mi = 100
&c.Parent::mi = 0xbfd507f8
c.Parent::mi = 1000

从输出结果我们可以知道
1. 子类和父类中的同名变量本质为不同的两个变量
2. 子类和父类的同名成员可以共存其实是C++的命名空间特性。

同名成员函数

问题：子类中可以存在与父类同名的函数吗？会产生函数重载的现象吗？

我们来回忆一下函数重载的特点：
1. 重载函数的本质为多个不同的函数
2. 函数名和参数列表是唯一的标识
3. 函数重载必须发生在同一个作用域。
我们上面已经验证了，子类继承父类后并不是同一个作用域，所以子类的同名函数并不会产生函数重载。

示例代码：父子间的函数重载

#include <iostream>
#include <string>

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.Parent::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;
}