黑马教程学习笔记--继承

1.继承方式

1.1公共继承

#include<string>
using namespace std;

//继承方式

//1.公共继承
class Base1
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;

};
class Son1 :public Base1//继承函数语法 class 子类 ：继承方式 父类
{
	void func()
	{
		m_A = 10;//父类中的公共权限成员 到子类中依然是公共权限
		m_B = 10;//父类中的保护权限成员 到子类中依然是保护权限
		//m_C = 10;//报错 父类中的私有权限成员 子类访问不到
	}
};

void test01()
{
	Son1 s1;//创建子类对象s1
	s1.m_A = 100;//m_A属于公共权限，类内类外均可访问
	//1.m_B = 100;//报错 m_B属于保护权限，类外不可访问
}

int main()
{
	test01();
	system("pause");
	return 0;
}

1.2保护继承

//2.保护继承
class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son2 :protected Base2
{
public:
	void func()
	{
		m_A = 10;//父类中的公共权限成员 到子类中变为保护权限
		m_B = 10;//父类中的保护权限成员 到子类中依然是保护权限
		//m_C = 10;//报错 父类中的私有权限成员 子类访问不到
	}
};
void test02()
{
	Son2 s1;//创建子类对象s1
	//s1.m_A = 100;//报错 m_A变为保护权限，类外不可访问
	//s1.m_B = 100;//报错 m_B属于保护权限，类外不可访问
}

1.3私有继承

//3.私有继承
class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son3 :private Base3
{
public:
	void func()
	{
		m_A = 10;//父类中的公共权限成员 到子类中变为私有权限
		m_B = 10;//父类中的保护权限成员 到子类变为私有权限
		//m_C = 10;//报错 父类中的私有权限成员 子类访问不到
	}
};
class GrandSon3 :public Son3
{
public:
	void func()
	{
		//m_A = 1000;//报错 到了Son3中，m_A变为私有，即使是儿子，也访问不到
		//m_B = 1000;//报错 到了Son3中，m_A变为私有，即使是儿子，也访问不到
	}
};
void test03()
{
	Son3 s1;//创建子类对象s1
	//s1.m_A = 100;//报错 m_A变为私有权限，类外不可访问
	//s1.m_B = 100;//报错 m_B变为私有权限，类外不可访问
	//m_C = 100;//报错 父类中的私有权限成员 子类访问不到
}

2.继承中的对象模型

//继承中的对象模型
class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;

};
class Son :public Base//继承函数语法 class 子类 ：继承方式 父类
{
public:
	int m_D;
};
//利用开发人员命令提示工具查看对象模型
//跳转盘符 F:
//跳转文件路径 cd 具体路径
//查看命名
// cl /d1 reportSingleClassLayout类名 文件名

void test01()
{
	//在父类中所有非静态成员属性都会被子类继承下去
	//父类中私有成员属性 是被编译器给隐藏了，因此是访问不到，但是确实被继承下去了
	cout << "size of Son=" << sizeof(Son) << endl;//size of Son=16
}

3.继承中的同名成员处理

#include<iostream>
#include<string>
using namespace std;

//继承中同名成员处理
class Base
{
public:
	Base()
	{
		m_A = 100;
	}
	void func()
	{
		cout << "Base-func()调用" << endl;
	}
	void func(int a)
	{
		cout << "Base-func(int a)调用" << endl;
	}
	int m_A;
};
class Son :public Base//继承函数语法 class 子类 ：继承方式 父类
{
public:
	Son()
	{
		m_A = 200;
	}
	void func()
	{
		cout << "Son-func()调用" << endl;
	}
	int m_A;
};
//同名成员处理方式
void test01()
{
	Son s;
	cout << "m_A= " << s.m_A << endl;//直接调用，得子类200本身
	//如果通过子类对象 访问到父类中同名成员，需加作用域
	cout << "m_A= " << s.Base::m_A << endl;//得100
}
void test02()
{
	Son s;
	s.func();//直接调用 调用是子类中的同名成员
	s.Base::func();//调用父类同名成员函数，加作用域
	//如果子类中出现和父类同名的成员函数，
	//子类的同名成员会隐藏掉父类中所有同名成员函数
	//如果想访问到父类中被隐藏的同名成员函数，需要加作用域
	s.Base::func(100);
}
int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}
//总结：
//1.子类对象可以直接访问到子类中同名成员
//2.子类对象加作用域可以访问到父类同名成员
//3.当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，
//加作用域可以访问到父类中的同名函数

4.继承中的同名静态成员处理方式

#include<iostream>
#include<string>
using namespace std;

//继承中的同名静态成员处理方式
class Base
{
public:
	static int m_A;
	static void func()
	{
		cout << "Base-static void func()" << endl;
	}
	static void func(int a)
	{
		cout << "Base-static void func(int a)" << endl;
	}
};
int Base::m_A = 100;

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

//同名静态成员属性
void test01()
{
	//1.通过对象访问
	cout << "通过对象访问:" << endl;
	Son s;
	cout << "Son 下的m_A= " << s.m_A << endl;//直接调用，得子类200本身
	//如果通过子类对象 访问到父类中同名成员，需加作用域
	cout << "Base 下的m_A= " << s.Base::m_A << endl;//得100
	//2.通过类名访问
	cout << "通过类名访问:" << endl;
	cout << "Son 下的m_A= " << Son::m_A << endl;//200
	//cout << "Base 下的m_A= " << Base::m_A << endl;//100 这样写也行，和下面完全一致
	//第一个：：代表 通过类名方式访问
	//第二个：：代表 通过父类作用域下访问
	cout << "Base 下的m_A= " << Son::Base::m_A << endl;//100
}

void test02()
{
	//1.通过对象访问
	cout << "通过对象访问:" << endl;
	Son s;
	s.func();//直接调用 调用是子类中的同名函数成员
	s.Base::func();//调用父类同名成员函数，加作用域
	//2.通过类名访问
	cout << "通过类名访问:" << endl;
	Son::func();
	Son::Base::func();
	//子类出现和父类同名静态成员函数，也会隐藏父类中所有同名成员函数
	//如果想访问父类中被隐藏同名成员，需要加作用域
	//Son::func(100);
	Son::Base::func(100);
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}
//总结：
//同名静态成员处理方式和非静态处理方式一样，只不过有两种访问方式（通过对象和通过类名）