Plane.h
#pragma once //普通飞机 class Plane { public: virtual void fly(); virtual void land(); };
Copter.h
#pragma once #include "Plane.h" class Copter :public Plane { virtual void fly(); virtual void land(); };
Jet.h
#pragma once #include "Plane.h" class Jet :public Plane{ virtual void fly(); virtual void land(); };
Copter 和 Jet 都是Plane的子类 看看一一对应的C++文件实现 Plane.cpp #include "Plane.h" #include <iostream> using namespace std; void Plane::fly() { cout << "起飞" << endl; } void Plane::land() { cout << "着陆" << endl; }
Copter.cpp
#include"Copter.h" #include<iostream> using namespace std; void Copter::fly() { cout <<"喷气式飞机在跑道上起飞..."<< endl; } void Copter::land() { cout <<"喷气式飞机在跑道上降落"<< endl; }
Jet.cpp
#include"Jet.h" #include<iostream> using namespace std; void Jet::fly() { cout <<"直升飞机在原地起飞"<< endl; } void Jet::land() { cout <<"直升飞机降落在女神的屋顶..."<< endl; }
//继承 //代码的重用性 例子 //人类
#include<iostream> using namespace std; class Hunman { public : void say() { cout <<"说话"<< endl; } protected: char *name; int age; }; class Man :public Hunman { public: //泡妞 void chasing() { cout <<"泡妞"<< endl; } private : //兄弟 char* brother; }; void work(Hunman &h) { h.say(); } void main() { Man m1; //子类对象 m1.say(); //1.父类类型的引用或指针 Hunman* h_p = &m1; //用父类指针指向子类地址 h_p->say(); Hunman &h1 = m1; //给子类取个别名 h1.say(); //子类对象初始化父类类型的对象 Hunman h2 = m1; getchar(); } //向父类构造方法传参 //人类
#include<iostream> using namespace std; class Human { public: Human(char *name,int age,bool which){ this->name= name; this->age = age; this->which = which; if (which) { cout << "创建父类构造函数1" << endl; } else { cout << "创建父类构造函数2" << endl; } } void say() { cout << "人说话" << endl; } protected: char* name; int age; bool which; }; //男人 class Man :public Human { public: //给父类构造函数传参，同时给属性对象赋值 Man(char* brother,char *s_name,int s_age,char *h_name,int h_age): Human (s_name,s_age,0),h(h_name,h_age,1) { this->brother = brother; cout <<"创建子类构造函数"<< endl; } //泡妞 void chasing() { cout << "男人泡妞" << endl; } private: //兄弟 char *brother; Human h; }; void main() { Man m1("danny","jack",18,"jason",18); m1.chasing(); m1.say(); getchar(); } //构造函数与析构函数调用的顺序 先构造函数再析构函数 #include<iostream> using namespace std; class Human { public : Human(char *name,int age) { this->name = name; this->age = age; cout << "Human构造函数" << endl; } ~Human() { cout << "Human析构函数" << endl; } void say() { cout << "说话" << endl; } protected: char *name; int age; }; //男人 class Man : public Human { public : //给父类构造函数传参，同时给属性对象赋值 Man(char *brother,char *s_name,int s_age):Human(s_name,s_age){ cout << "Man的构造函数" << endl; } ~Man() { cout << "Man的析构函数" << endl; } //泡妞 void chasing() { cout << "泡妞" << endl; } private: //兄弟 char* brother; }; void func() { //父类构造函数先调用 //子类的析构函数先调用 Man m1("danny","jack",18); } void main() { func(); getchar(); } //子类对象调用父类的成员 #include<iostream> using namespace std; class Human { public: Human(char* name,int age) { this->name = name; this->age = age; cout << "Human 构造函数" << endl; } ~Human() { cout << "Human析构函数" << endl; } void say() { cout << "说话" << endl; } public: char *name; int age; }; //男人 class Man : public Human { public : Man(char* brother,char* s_name,int s_age):Human(s_name,s_age){ this->brother = brother; cout << "Man 的构造函数" << endl; } ~Man() { cout << "Man 的析构函数" << endl; } void chasing() { cout << "泡妞" << endl; } void say() { cout << "男人就喜欢装逼" << endl; } private: //兄弟 char* brother; }; void main() { //是覆盖，并非动态 Man m1("alan","jack",22); m1.say(); m1.Human::say(); m1.Human::age = 10; getchar(); } //多继承 //人
class Person { }; //公民 class Citizen { }; //学生，既是人，又是公民 class Student :public Person, public Citizen { }; //继承的访问修饰 //基类中 继承方式 子类中 //public ＆ public继承 = > public //public ＆ protected继承 = > protected //public ＆ private继承 = > private // //protected ＆ public继承 = > protected //protected ＆ protected继承 = > protected //protected ＆ private继承 = > private // //private ＆ public继承 = > 子类无权访问 //private ＆ protected继承 = > 子类无权访问 //private ＆ private继承 = > 子类无权访问 //人类 class Human { public : void say() { cout << "说话" << endl; } private: char *name; int age; }; //男人 class Man : protected Human { public: //泡妞 void chasing() { cout << "泡妞" << endl; } private: //兄弟 char* brother; }; //继承的二义性 //虚继承，不同路径继承来的同名成员只有一份拷贝，解决不明确的问题 class A { public: char *name; }; class A1 :virtual public A { }; class A2 :virtual public A { }; class B : public A1,public A2 { }; void main() { B b; b.name = "jason"; //指定父类显示调用 b.A1::name = "tiya"; b.A2::name = "jack"; getchar(); } //虚函数 //多态（程序的拓展性） //动态多态：程序在运行过程中，觉得哪一个函数被调用 //静态多态：重载 //发生动态的条件： //1.继承 //2.父类的引用或者指针指向子类的对象 //3.函数的重写 #include"Plane.h" #include"Jet.h" #include"Copter.h" //业务函数 void bizPlay(Plane &p) { p.fly(); p.land(); } void main() { Plane p1; bizPlay(p1); //直升飞机 Jet p2; bizPlay(p2); Copter p3; bizPlay(p3); getchar(); } //纯虚函数(抽象类) //1.当一个类具有一个纯虚函数，这个类就是抽象类 //2.抽象类不能实例化对象 //3.子类继承抽象类，必须要实现纯虚函数，如果没有，子类也是抽象类 //抽象类的作用:为了继承约束，根本不知道未来的实现 //形状 class Shape { public: //纯虚函数 virtual void sayArea() = 0; void print() { cout << "Hi" << endl; } }; //圆 class Circle : public Shape { public : Circle(int r) { this->r = r; } void sayArea() { cout <<"圆的面积："<< (3.14 * r * r)<< endl; } private : int r; }; void main() { //Shape a; Circle c(10); c.sayArea(); Circle(10).sayArea(); getchar(); } //接口(只是逻辑上的划分，语法上跟抽象类的写法没有区别) //可以当作一个接口 class Drawable{ virtual void draw(); }; //模板函数（泛型） 普通写法 void myswap(int &a,int &b) { int tmp = 0; tmp = a; a = b; b = tmp; } void myswap(char &a, char &b) { char tmp = 0; tmp = a; a = b; b = tmp; } 发现：这两个函数业务逻辑一样，数据类型不一样 template <typename T> void myswap(T &a,T &b) { T tmp = 0; tmp = a; a = b; b = tmp; } //根据实际类型，自动推导 void main(){ int a = 10, b = 20; myswap<int>(a,b); cout << a << "," << b<< endl; char x = 'v',y='w'; myswap(x,y); cout << x << "," << y << endl; getchar(); } //模板类 template<class T> class A { public: A(T a) { this->a = a; cout << a << endl; } protected: T a; }; //普通类继承模板 class B :public A<int> { public : B(int a ,int b):A<int>(a){ this->b = b; } private : int b; }; //模板类继承模板类 template <class T> class C :public A<T> { public: C(T c,T a):A<T>(a){ this->c = c; } protected: T c; }; void main() { //实例化模板类对象 //List<String> list; A<int> a(6); getchar(); } c++异常处理，根据抛出的异常数据类型，进入到相应的catch块中 void main() { try { int age = 300; if (age>200) { throw 9.8; } } catch (int a) { cout <<"int异常"<< endl; } catch (char* b) { cout << b << endl; } catch(...){ cout << "未知异常" << endl; } getchar(); } throw 抛出函数外 void mydiv(int a ,int b) { if (b==0) { throw "除数为0"; } } void func() { try { mydiv(8,0); } catch(char* a){ throw a; } } void main() { try { func(); } catch (char* a) { cout << a << endl; } getchar(); } //抛出对象 //异常类 class MyException { }; void mydiv(int a ,int b) { if (b==0) { throw MyException(); } //throw new MyException; 不要抛出异常指针 }; void main() { try { mydiv(8,0); } catch (MyException& e1) { cout << "MyException引用" << endl; } //会产生对象副本 //catch (MyException e2) { // cout << "MyException" << endl; //} catch (MyException* e3) { cout << "MyException指针" << endl; delete e3; } getchar(); } throw 声明函数会抛出的异常类型 void mydiv(int a ,int b)throw(char* ,int) { if (b==0) { throw"除数为零"; } } 标准异常（类似于JavaNullPonterException） #include<stdexcept> class NullPointerException : public exception { public : NullPointerException(char* msg) :exception(msg) { } }; void mydiv(int a,int b) { if (b>10) { throw out_of_range("超出范围"); } else if (b==NULL) { throw NullPointerException("为空"); } else if (b==0) { throw invalid_argument("参数不合法"); } } void main() { try { mydiv(8,NULL); } catch (out_of_range e1) { cout << e1.what() << endl; } catch (NullPointerException& e2) { cout << e2.what() << endl; } catch (...) { } getchar(); } 外部类异常 class Err { public : class MyException { public:MyException() { cout << "MyException" << endl; } }; }; void mydiv(int a,int b) { if (b>10) { throw Err::MyException(); } } void main() { try { mydiv(8, 20); } catch (...) { } getchar(); } //向父类构造方法传参 //人类
