C++笔记(继承,多态,虚函数,模板函数,异常捕获)
C++面向对象:
在这里推荐大家一个C++的网站:http://www.cplusplus.com/reference/
1.继承
//继承--子类继承父类(儿子继承爸爸),儿子有了爸爸的特性和财产,提高了代码的重用性.
class A
{
public:
void Func1(void);
void Func2(void);
};
class B : public A
{
public:
void Func3(void);
void Func4(void);
};
// Example
int main()
{
B b; // B的一个对象
b.Func1(); // B 从A 继承了函数Func1
b.Func2(); // B 从A 继承了函数Func2
b.Func3();
b.Func4();
return 0;
} 2.继承对象的实例化
//继承 解决代码的重用性
class Human{
//一般函数在前面
public :
//继承中 构造函数 需要和
Human(char* name, int age){
this->age = age;
this->name = name;
}
void say(){
cout << "say" << endl;
}
private:
char* name;
int age;
};
//继承的写法,修饰符:按照最小的范围限制子类
//继承的二义性(即指向不明确): 使用virtual 来区别
class Man :public Human{
public:
Man(char* brother, char* name, int age) :Human(name, age){
this->brother = brother;
}
//
void chasing(){
cout << "泡妞" << endl;
}
private:
char* brother;
};
void work(Human& h){
h.say();
}
//构造函数:先父类,再子类
//析构函数: 先子类,再父类
void main(){
Man m1("ss","sssss",22);
m1.say();
//调用可用指针 和引用 直接赋值
//Human h1 = m1;
//h1.say();
system("pause");
}3.多继承
//学生，既是人，又是公民
class Student : public Person, public Citizen{
};
*/4.继承的访问限制关系
一句话:谁最低听谁的
| 基类中 | 继承方式 => | 子类中 |
|---|---|---|
| public | public | public |
| public | protected | protected |
| public | private | private |
| protected | public | protected |
| protected | protected | protected |
| protected | private | private |
| private | public | private |
| private | protected | private |
| private | private | private |
5.virtual
5.1虚继承
//虚继承，不同路径继承来的同名成员只有一份拷贝，解决不明确的问题
/* 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 = "jason"; //b.A2::name = "jason"; system("pause"); }5.2虚函数
虚函数
多态（程序的扩展性）
动态多态：程序运行过程中，觉得哪一个函数被调用（重写）
静态多态：重载
//发生动态的条件：
1.继承
2.父类的引用或者指针指向子类的对象
3.函数的重写
#include "plane.h"
#include "p1.h"
#include "p2.h"
//业务函数
void bizPlay(plane& p){
p.fly();
p.land();
}
void main(){
Plane p1;
bizPlay(p1);
//直升飞机
p2 p22;
bizPlay(p22);
p1 p11;
bizPlay(p11);
system("pause");
}5.3纯虚函数(抽象类)
类似于java
//1.当一个类具有一个纯虚函数，这个类就是抽象类
//2.抽象类不能实例化对象
//3.子类继承抽象类，必须要实现纯虚函数，如果没有，子类也是抽象类
//抽象类的作用：为了继承约束，根本不知道未来的实现
6.接口（逻辑上的划分，语法上跟抽象类的写法相同）
class Drawble{
virtual void draw();
};
7.模板template(泛型)
7.1模板函数
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;
system("pause");
}7.2模板类
template<class T>
class A{
public :
A(T a){
this->a = a;
}
protected:
T a;
};
class B :public A < int > {
public :
B(int a,int b) :A(a){
}
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(){
//实例化
C<int> c(6,3);
system("pause");
}8.异常捕获
//类似于java ,throw是抛出,catch是捕捉,
并且分为自定义异常类,继承异常类,实用常用异常类等.
在C++中有 类似于java中的异常类,详细的点这里,常用的如下
logic_error--Logic error exception (class )
domain_errorDomain --error exception (class )
invalid_argumentInvalid-- argument exception (class )
length_errorLength --error exception (class )
void main(){
try{
int age = 300;
if (age > 200){
//throw myException(); //throw抛出 (最好不要抛出指针产生对象)
//throw length_error("超出范围");
throw NullPointException("为空");
}
}
catch(NullPointException p){
cout << p.what<<endl;
}
//catch (char * error){
// cout << error << endl;
//}
//catch (myException e){
//
//}
//catch (...){//未知异常
//
//};
//;
system("pause");
}