C++继承

继承

继承的基本语法

---

class 派生类：public 基类

代码：

#include<iostream>
using namespace std;
//继承，可以减少许多重复的代码 
class BasePage 
{
public:
	void header()
	{
		cout<<"首页，公开课，登录，注册...(公共头部)"<<endl; 
	}
	void footer()
	{
			cout<<"帮助中心，交流合作，站内地图...(公共低部)"<<endl;
	}
	void left()
	{
		cout<<"Java,Python,C++/C...(公共左部)"<<endl;
	}
}; 

//Python页面
class Python:public BasePage
{
public:
	void content()
	{
		cout<<"python学科视频"<<endl;
	}
};
//C++/C页面
class C:public BasePage
{
public:
	void content()
	{
		cout<<"C++/C学科视频"<<endl;
	}
};
class Java:public BasePage
{
public:
	void content()
	{
		cout<<"Java学科视频"<<endl;
	}
};
void test()
{
	Python python;
	python.header();
	python.footer();
	python.left();
	python.content();
	cout<<"-----------------"<<endl;
	C c;
	c.header();
	c.footer();
	c.left();
	c.content();
	cout<<"-----------------"<<endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
}
int main()
{
	test(); 
	system("pause");
	return 0;
} 

继承方式

---

三种继承方式：公共继承，保护继承，私有继承

#include<iostream>
using namespace std;
//继承方式
//公共继承，保护继承，私有继承 
class BasePage
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

//1.公共继承
class Son1:public BasePage
{
public:
	void func()
	{
		m_A=100;//可以访问，m_A到子类中还是public 
		m_B=120;//可以访问，m_B到子类中还是protected
		//m_C=130;//不能访问 
	}
};
void test1()
{
	Son1 son;
	son.m_A=200;
	//son.m_B//不能访问，因为到子类中位protected,类外不能访问 
}

//2.保护继承
class Son2:protected BasePage
{
public:
	void func()
	{
		//子类可以访问public和protected 
		m_A=10;//但是m_A在子类中变为protected权限 
		m_B=20;//m_A在子类中还是为protected权限 
	} 
};
void tese2()
{
	Son2 son;
	//son.m_A//保护权限类外不能访问 
}

//3.私有继承
class Son3:private BasePage
{
public:
	void func()
	{//私有继承可以访问基类的public和protected 
		m_A=12;//在子类中，m_A位private 
		m_B=13;//在子类中，m_A位private 
	}
};
int main()
{
	test1();
	//test2();
	//test3(); 
	system("pause");
	return 0;
}

继承中的对象模型

---

基类中所有非静态成员属性都会被子类继承下去
基类中私有成员属性是被编译器给隐藏了，因此是访问不到的 ，但是基类中的被派生类所继承

#include<iostream>
using namespace std;
//基类 
class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
//派生类
class Son:public Base
{
public:
	int m_D;
};
void test()
{
	//基类中所有非静态成员属性都会被子类继承下去
	//父类中私有成员属性是被编译器给隐藏了，因此是访问不到的 ，但是被继承了
	 cout<<"size of Son="<<sizeof(Son)<<endl; 
}
int main()
{
	test();
	return 0;
} 

继承中的同名成员处理

---

继承中同名属性处理

#include<iostream>
using namespace std;

//同名属性处理
class Base
{
public:
	Base()
	{
		m_A=100;
	}
public:
	int m_A;
};
//子类
class Son:public Base
{
public:
	int m_A=200;
};
void test()
{
	Son s;
	cout<<"s.m_A= "<<s.m_A<<endl;//通过子类直接访问的是子类中的
	//可以通过在是s.Base::m_A访问父类中的
	cout<<"s.Base::m_A= "<<s.Base::m_A<<endl; 
}
int main()
{
	test(); 
	system("pause");
	return 0;
} 

继承中同名函数处理

#include<iostream>
using namespace std;

//同名函数处理
class Base
{
public:
	void func()
	{
		cout<<"Base函数调用"<<endl;
	}
	//func函数重载
	void func(int a)
	{
		cout<<"Base函数(int a)调用"<<endl;
	} 
};
//子类
class Son:public Base
{
public:
	void func()
	{
	   cout<<"Son函数调用"<<endl;		
	} 
};
void test()
{
	Son s;
	s.func(); //直接访问访问的是子类的
	s.Base::func();//访问父类 
	s.Base::func(100);
}
int main()
{
	test(); 
	system("pause");
	return 0;
} 

总结：

1.子类对象可以直接访问到子类中同名成员

2.子类对象加作用域可以访问到父类同名成员

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

同名静态成员处理

---

继承同名成员静态成员属性处理

静态成员属性：类外初始化，可以通过对象和类名来访问

#include<iostream>
using namespace std;
//继承同名成员静态成员属性处理 
class Base
{
public:
	static int m_A; 
};
//类外初始化 
int Base::m_A=100;
class Son:public Base 
{
public:
	static int m_A; 
};
//类外初始化 
int Son::m_A=300;
 
void test()
{
	//1.通过对象访问 
	cout<<"通过对象进行访问"<<endl;
	Son s;
	cout<<"Son 下 m_A= "<<s.m_A<<endl;
	cout<<"Base 下 m_A= "<<s.Base::m_A<<endl;
	//2.通过类名访问
	cout<<"通过类名访问"<<endl;
	cout<<"Son 下 m_A= "<<Son::m_A<<endl;
	cout<<"Base 下 m_A= "<<Son::Base::m_A<<endl;
}
int main()
{
	test(); 
	system("pause");
	return 0;
} 

继承同名静态成员函数处理

与同名静态成员属性一样，有两中访问方式，对象和类名

#include<iostream>
using namespace std;
//继承同名成员静态成员属性处理 
class Base
{
public:
	static void func()
	{
		cout<<"Base static void func"<<endl; 
	} 
};
class Son:public Base 
{
public:
	static void func()
	{
		cout<<"Son static void func"<<endl; 
	}
};

void test()
{
	//1.通过对象访问 
	cout<<"通过对象进行访问"<<endl;
	Son s;
	s.func();
	s.Base::func();
	//2.通过类名访问
	cout<<"通过类名访问"<<endl;
	Son::func();
	Son::Base::func(); 

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

多继承语法

class 类名：public 类名，public 类名(或者其他类型的继承)

{}

---

#include<iostream>
using namespace std;
//多继承语法 
class Base1
{
public:
	Base1()
	{
		m_A=100;
	}
public:
	int m_A;
};

class Base2
{
public:
	Base2()
	{
		m_B=200;
	}
public:
	int m_B;
};

class Son:public Base1,public Base2
{
public:
	Son()
	{
		m_C=123;
		m_D=124;
	}
public:
	int m_C;
	int m_D;
};
//测试函数样例 
void test()
{
	Son s;
	cout<<"sizeof(s)= "<<sizeof(s)<<endl;
	cout<<"m_A= "<<s.m_A<<endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

菱形继承

---

#include<iostream>
using namespace std;
//菱形继承 
class Anmial
{
public:
	int m_Age;
};
class Sheep:virtual public Anmial{};//将其变为虚继承,这样最后得到的数据就会只有一份
class Tuo:virtual public Anmial{};
class SheepTuo:public Sheep,public Tuo
{
}; 
void test()
{
	SheepTuo st;
	st.Sheep::m_Age=18;
	st.Tuo::m_Age=28;
	cout<<"st.Sheep::m_Age= "<<st.Sheep::m_Age<<endl;
	cout<<"st.Tuo::m_Age= "<<st.Tuo::m_Age<<endl;
	cout<<"st.m_Age= "<<st.m_Age<<endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

赏

谢谢你请我吃糖果

支付宝

微信