C++ 核心编程 继承
#include<iostream> using namespace std; //普通实现页面 //Java 页面 class Java { public: void header() { cout << "首页、公开课、登录、注册>>>>（公共头部）" << endl; } void footer() { cout << "帮助中心、合作（公共底部）" << endl; } void lest() { cout << "Java python c++ (公共列表分类)" << endl; } void content() { cout << "Java 学科视频" << endl; } }; //Python 页面 class Python { public: void header() { cout << "首页、公开课、登录、注册>>>>（公共头部）" << endl; } void footer() { cout << "帮助中心、合作（公共底部）" << endl; } void lest() { cout << "Java python c++ (公共列表分类)" << endl; } void content() { cout << "Python 学科视频" << endl; } }; //C++ 页面 class CPlus { public: void header() { cout << "首页、公开课、登录、注册>>>>（公共头部）" << endl; } void footer() { cout << "帮助中心、合作（公共底部）" << endl; } void lest() { cout << "Java python c++ (公共列表分类)" << endl; } void content() { cout << "C++ 学科视频" << endl; } }; void test01() { cout << "Java下载视频页面如下" << endl; Java ja; ja.header(); ja.footer(); ja.lest(); ja.content(); cout << "________________________" << endl; cout << "python下载视频页面如下" << endl; Python py; py.header(); py.footer(); py.lest(); py.content(); cout << "________________________" << endl; cout << "c++下载视频页面如下" << endl; CPlus c; c.header(); c.footer(); c.lest(); c.content(); } int main() { test01(); system("pause"); return 0; }
继承的写法
#include<iostream> using namespace std; //普通实现页面 //继承实现页面 class BasePage { public: void header() { cout << "首页、公开课、登录、注册>>>>（公共头部）" << endl; } void footer() { cout << "帮助中心、合作（公共底部）" << endl; } void lest() { cout << "Java python c++ (公共列表分类)" << endl; } }; //继承好处 ：减少重复代码 //语法 ：class 子类 ： 继承方式 父类 //子类也称为派生类 //父类也称为 基类 //Java 页面 class Java :public BasePage { public: void content() { cout << "Java 学科视频" << endl; } }; //Python 页面 class Python :public BasePage { public: void content() { cout << "Python 学科视频" << endl; } }; //CPlus 页面 class CPlus :public BasePage { public: void content() { cout << "CPlus 学科视频" << endl; } }; void test01() { cout << "Java下载视频页面如下" << endl; Java ja; ja.header(); ja.footer(); ja.lest(); ja.content(); cout << "________________________" << endl; cout << "python下载视频页面如下" << endl; Python py; py.header(); py.footer(); py.lest(); py.content(); cout << "________________________" << endl; cout << "c++下载视频页面如下" << endl; CPlus c; c.header(); c.footer(); c.lest(); c.content(); } int main() { test01(); system("pause"); return 0; }
#include<iostream> using namespace std; //继承方式 //公共继承 class Base1 { public: int m_A; protected: int m_B; private: int m_C; }; //公有继承 class BaseA :public Base1 { public: void func() { m_A = 10;//父类中的公共权限成员 到子类中依然是公共权限 m_B = 10;//父类中保护权限成员 到子类中依然是保护权限 可以访问 //m_C = 10;//父类中的私有权限成员 到子类中不可以访问 } }; void test01() { BaseA s1; s1.m_A = 100; //s1.m_B = 100;//成员函数在类内可以访问，在类外访问不到 } class Base2 { public: int m_A; protected: int m_B; private: int m_C; }; //保护继承 class BaseB : protected Base2 { public: void func() { m_A = 100;//父类中的公共成员 到子类中变为保护权限 m_B = 100;//父类中保护权限成员 到子类中依然是保护权限 可以访问 //m_C = 100;//m_C = 10;//父类中的私有成员子类中不可以访问 } }; void test02() { BaseB s1; //s1.m_A = 1000;//在BaseB中 m_A变为了保护权限 因此类外不可以访问 //s1.m_B = 1000;//在BaseB中 m_B保护权限 类外不可以访问 } class Base3 { public: int m_A; protected: int m_B; private: int m_C; }; //私有继承 class BaseC : private Base3{ public: void func() { m_A = 100;//父类中的公共成员 到子类中变为私有成员 m_B = 100;//父类中保护权限成员 到子类中依然是私有成员 //m_C = 100//m_C = 10;//父类中的私有成员子类中不可以访问 } }; class GrandSon3 :public Base3 { public: void func() { //m_A = 100;//到了 Base3中 m_A变为私有 即使是儿子 也是访问不到 //m_B = 100;// } }; void test03() { BaseC s1; //s1.m_A = 1000;//在此类中 变为私有成员 访问不到 //s1.m_B = 1000;// } int main() { 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; }; //利用开发人员命令提示工具查看对象模型 //跳转盘符 F： //跳转文件路径 cd 具体路径下 //查看命名 //cl /d1 reportSingleClassLayout 类名 文件名 void test01() { //16 //父类中所有非静态成员属性都会被子类继承下去 //父类中私有成员属性 是被编译器给隐藏了 因此是访问不到 但是确实被继承下去了 cout << "size of son =" << sizeof(son) << endl; } int main() { test01(); system("pause"); return 0; }
结论：父类中的私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到
#include<iostream> using namespace std; class Person { public: Person() { m_A = 200; } void func() { cout << "Base-func()下函数调用" << endl; } void func(int a) { cout << "son-func(int a)下函数调用" << endl; } int m_A; }; class son :public Person { public: son() { m_A = 100; } void func() { cout << "son-func()下函数调用" << endl; } int m_A; }; //同名成员属性 void test01() { son s; cout << " son 里的m_A" <<s.m_A<< endl; //通过子类对象，访问到父类同名成员，需要加作用域 cout << "Person 里的m_A" << s.Person::m_A << endl; } //同名成员函数 void test02() { son s; s.func(); //如何调用到父类中的同名成员函数 s.Person::func(); //如果子类中出现了和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数 //如果想访问父类中被隐藏的同名成员函数，需要加作用域 //s.func(100); //c错误模式 s.Person::func(100);//成功 } int main() { test02(); system("pause"); return 0; }
#include<iostream> using namespace std; //继承中的同名静态成员处理方式 class Base { public: static int m_A;//类内声明 类外初始化 void func() { cout << "Base --静态函数关键字" << endl; } }; int Base::m_A=100; class Son :public Base { public: static int m_A;//类内声明 类外初始化 void func() { cout << "Son --静态函数关键字" << endl; } }; 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; //2 通过类名方式访问 cout << "通过类名的方式访问" << endl; cout << "Son 下m_A" << Son::m_A << endl; cout << "Base 下m_A" << Base::m_A << endl; //子类对象访问父类中的m_A数据，并且通过类名的方式访问 //第一个::代表通过类名的方式访问， 第二个::代表访问父类作用域下 cout << "Son：：Base 下m_A" << Son::Base::m_A << endl; } //同名静态成员函数 void test01() { // //通过对象访问 // cout << "通过对象访问" << endl; // Son s; // s.func(); // s.Base::func(); // //通过类名访问 // cout << "通过类名的方式访问:" << endl; // //Son::func(); //// Son::Base::func(); } void test02() { //通过对象访问 cout << "通过对象访问" << endl; Son s; s.func(); s.Base::func(); //通过类名访问 cout << "通过类名的方式访问:" << endl; //子类出现和父类同名静态成员函数 也会隐藏父类中所有同名成员函数 //如果想访问父类中被隐藏同名成员 需要加作用域 // Son::func(); // Son::Base::func(); } int main() { //test01(); test02(); system("pause"); return 0; }
