47、父子间的冲突

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;

	return 0;
}

提出问题：c.mi 这个mi是父类的成员变量还是子类的成员变量？

2、父子间的冲突

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

访问父类中的同名成员

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

	return 0;
}

3、再论函数重载

• 类中的成员函数可以进行重载
  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;
};
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);
	cout << "c.mi = " << c.mi << endl;
	cout << "c.Parent::mi = " << c.Parent::mi << endl;
	return 0;
}

如果子类没有定义父类里面的函数，那么子类对象可以直接调用父类里面的函数。
子类中定义的函数不可以重载父类中的同名函数，作用域不同

#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;
	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;
}

如果子类中定义父类里面的同名函数，那么父类里面的同名函数会被隐藏，子类对象不能直接调用父类里面的函数，要加上作用域分辨符。

如何修改？

主函数里面的调用要加上作用域分辨符

#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;
	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 <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.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; 
}

结果就是只会调用子类的函数，父类的直接被隐藏了，不加作用域分辨符不会调用父类的成员函数。除非你子类没有和父类同名的成员函数。

父子间的冲突

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

小结

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

子类和父类定义一样的成员变量，从得出的地址其实我们可以判断，父类和子类里面存放的东西，其实是放在同一片内存空间，类似于结构体存放的类型。
继承：意思是子类能用父类中的东西，只不过在访问的时候有访问权限。