一、继承中同名隐藏

（1）同名成员属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class A
{
public:
	int _a;
};

class B : public A
{
public:
	int _a;			//这个_a
public:
	void fun()
	{
		_a = 10;	//就近原则
		A::_a = 20;	//加上作用域访问
	}
};

（2）同名成员方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class A
{
public:
	void fun(){ cout << "A::fun" << endl;}
};

class B : public A
{
public:
	void fun(){ cout << "B::fun" << endl;}
};
int main()
{
	B b;
	b.fun();
	b.A::fun();
	return 0;
}

错误理解：函数重载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class A
{
public:
	void fun(int x){ cout << "A::fun(int)" << endl;}
};

class B : public A
{
public:
	void fun(){ cout << "B::fun" << endl;}
};
int main()
{
	B b;
	b.fun();
	b.fun(10);	//编译器报错：参数太多 （B::fun隐藏了A:fun(int) 想要调用A中fun必须使用A::）b.A::fun(10);
	return 0;
}

总结：

  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
class Person
{
private:
	int _age;
public:
	Person(int _a = 0): _age(_a){}
};

class Student : public Person
{
private:
	int score;
public:
	Student(int _s = 0): Person(), score(_s)
	{}
};

int main()
{
	Student stu(0);
	Person p(0);
	p = stu;			//赋值兼容规则（切片）
	
	Person* ptr = &stu;	//赋值兼容规则（切片）
	
	Person& per = stu;	//赋值兼容规则（切片）
	return 0;
}

总结：

  1. 公有继承是一个的概念： 派生类对象是一个基类对象
  2. 公有继承下，可以使用派生来对象给基类对象进行赋值（赋值兼容规则）
  3. 公有继承下，可以使用基类指针或者基类引用去 访问派生类对象。