1.思考

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

代码示例：

#include <iostream>
#include <string>
 
using namespace std;
 
class Parent
{
public:
    int mi;
};
 
class Child : public Parent
{
public:
    int mi;
};
 
int main()
{
    Child c;
    
    c.mi = 100;    // mi 究竟是子类自定义的，还是从父类继承得到的？
    
    return 0;
}

结果：编译正确，可以通过。

父类和子类是可以存在同名变量的。

2.父类和子类之间的同名冲突

-> 子类可以定义父类中的同名成员。

-> 子类中的成员将隐藏父类中的同名成员。

-> 父类中的同名成员依然存在于子类中。

-> 通过作用域分辨符（::）访问父类中的同名成员。

Child c;
c.mi = 100;           //子类中的mi
c.Parent::mi = 1000;  //父类中的mi

java父子类同名变量 c++父类子类同名变量_子类

 代码示例：同名变量

#include <iostream>
#include <string>
 
using namespace std;
 
namespace A
{
    int g_i = 0;
}
 
namespace B
{
    int g_i = 1;
}
 
class Parent
{
public:
    int mi;
    
    Parent()
    {
        cout << "Parent() : " << "&mi = " << &mi << endl;  
    }   //确认成员变量地址，定位类Parent
};
 
class Child : public Parent
{
public:
    int mi;
    
    Child()
    {
        cout << "Child() : " << "&mi = " << &mi << endl;
    }   //确认成员变量地址，定位类Child
};
 
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 = 0xbfb99188
Child() : &mi = 0xbfb918c
&c.mi = 0xbfb9918c   //证明调用的子类mi
c.mi = 100     //打印子类中的mi
&c.Parent::mi = 0xbfb99188    //证明调用的子类继承自父类的mi
c.Parent::mi = 1000    //打印父类中的mi

分析：

当子类和父类有同名成员时，父类成员被子类覆盖，但是它依然存在子类中。

子类中的mi和父类中mi地址相差4，父类Parent只有int类型mi，类Parent占用4字节，子类Child也只有同名int类型mi，占用4字节。在栈上分配内存时，会被连续分配。

类的大小并不包含成员函数的大小。

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;
};
 
int main()
{
    Child c;
    
    c.mi = 100;    //访问子类的mi
    
    c.Parent::mi = 1000;    //访问子类继承父类的mi
    
    cout << "c.mi = " << c.mi << endl;
    
    cout << "c.Parent::mi = " << c.Parent::mi << endl;
    
    c.add(1);
    c.add(2, 3);
 
    cout << "c.mi = " << c.mi << endl;
    
    cout << "c.Parent::mi = " << c.Parent::mi << endl;
    
    return 0;
}

结果：

c.mi = 100            //打印子类mi数值
c.Parent::mi = 1000   //打印继承自父类的mi数值
c.mi = 100            //打印子类mi值
c.Parent::mi = 1006   //打印继承自父类的mi值

分析：

c.Parent::mi = 1006因为子类没有任何成员函数，调用c.add(1)和c.add(2,3)时，执行的是继承自父类的add()函数。因此打印1006。

在子类Child重写累加函数：

#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 x, int y, int z)
    {
        mi += (x + y + z);
    }
};
 
int main()
{
    Child c;
    
    c.mi = 100;    //访问子类的mi
    
    c.Parent::mi = 1000;    //访问子类继承父类的mi
    
    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;
}

结果：编译错误

47-3.cpp: In function ‘int main()’:
47-3.cpp:57:9: error: no matching function for call to ‘Child::add(int)’
  c.add(1);
         ^
错误：没有匹配'Child::add(int)'函数
    c.add(1);
47-3.cpp:57:9: note: candidate is:
47-3.cpp:37:7: note: void Child::add(int, int, int)
  void add(int x, int y, int z)
       ^
47-3.cpp:37:7: note:   candidate expects 3 arguments, 1 provided
47-3.cpp:58:12: error: no matching function for call to ‘Child::add(int, int)’
  c.add(2, 3);
            ^
错误：没有匹配'Child::add(int, int)'函数
    c.add(2, 3)
47-3.cpp:58:12: note: candidate is:
47-3.cpp:37:7: note: void Child::add(int, int, int)
  void add(int x, int y, int z)
       ^ 
47-3.cpp:37:7: note:   candidate expects 3 arguments, 2 provided

分析：

因为子类重载了add()函数，调用c.add(1)和c.add(2, 3)时是在子类中查找(错误提示显示)，因此报错。

子类定义了和父类同名的函数add，子类同名函数会覆盖掉父类中的同名函数。

解决方案：c.Parent::add

#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 x, int y, int z)
    {
        mi += (x + y + z);
    }
};
 
int main()
{
    Child c;
    
    c.mi = 100;    //访问子类的mi
    
    c.Parent::mi = 1000;    //访问子类继承父类的mi
    
    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;
}

结果：

c.mi = 100
c.Parent::mi = 1000    
c.mi = 115             //调用子类add(4, 5, 6)
c.Parent::mi = 1006    //调用父类add(1)和add(2,3)

4.父子间的冲突

-> 子类可以定义父类中的同名成员。

-> 子类中的函数将隐藏父类的同名函数。

-> 子类无法重载父类中的成员函数（作用域不同）。

-> 使用作用域分辨符c.Parent::add访问父类中的同名函数。

-> 子类和父类中的函数不能构成重载关系。

-> 子类可以定义父类中完全相同的成员函数。