在类中继承时，如果父类和子类含有同名的成员函数和成员变量，应该按如下规则调用

同名普通成员普通函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
class Father
{
public:
    Father()
    {
    }

    void func()
    {
        cout<<"run father func() "<<endl;
    }
    void func(int a)
    {
        cout<<"run father func(int a)  "<<endl;
    }

public:
    int m_a=100;
};

class son :public Father
{
public:
    son()
    {
    }
    void func()
    {
        cout<<"run son func() "<<endl;
    }


public:
    int m_a=200;

};

void test()
{
    son P;

    // 执行同名非静态变量
    cout << "son.p= " << P.m_a << endl;
	cout << "Father.p= " << P.Father::m_a << endl;

    // 执行同名成员函数
    P.func();
    P.Father::func();

    // P.func(100); //报错 父类的func(int a) 函数被隐藏
    P.Father::func(123);
}
/*
执行结果
son.p= 200
Father.p= 100
son - func() run
Father - func() run
father - func(int a) run
*/

  1. 子类对象可以直接访问到子类中同名成员
  2. 子类对象加作用域可以访问到父类同名成员
  3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，需要加作用域才可以访问到父类中同名函数

同名静态成员静态函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
class Base {
public:
	static void func()
	{
		cout << "Base - static void func()" << endl;
	}
	static void func(int a)
	{
		cout << "Base - static void func(int a)" << endl;
	}

	static int m_A;
};

int Base::m_A = 100;

class Son : public Base {
public:
	static void func()
	{
		cout << "Son - static void func()" << endl;
	}
	static int m_A;
};

int Son::m_A = 200;

//同名成员属性
void test01()
{
	//通过对象访问
	Son s;
	cout << "Son  下 m_A = " << s.m_A << endl;
	cout << "Base 下 m_A = " << s.Base::m_A << endl;

	cout << "-------------" << endl;
    
    //通过类名访问
	cout << "Son  下 m_A = " << Son::m_A << endl;
	cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}
/*
Son  下 m_A = 200
Base 下 m_A = 100
-------------
Son  下 m_A = 200
Base 下 m_A = 100
*/


//同名成员函数
void test02()
{
	//通过对象访问
	cout << "通过对象访问： " << endl;
	Son s;
	s.func();
	s.Base::func();

	cout << "通过类名访问： " << endl;
	Son::func();
	Son::Base::func();
	//出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
	Son::Base::func(100);
}
/**
通过对象访问： 
Son - static void func()
Base - static void func()
通过类名访问：
Son - static void func()
Base - static void func()
Base - static void func(int a)
*/

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