C++03:封装->继承->多态
一.简介
1.可维护
2.可复用
3.可扩展
4.灵活性好
面向对象的设计思想就是通过封装 继承 多态把程序的耦合性降低,使得程序更加的灵活,容易修改,并且易于复用
面向对象的五大基本原则
1.单一职责原则(SRP)
2.开放封闭原则(OCP)
3.里氏替换原则(LSP)
4.依赖倒置原则(DIP)
5.接口隔离原则(ISP)
函数编程
泛型编程
元编程
封装：封装是指将对象的属性和方法绑定在一起，形成一个独立 封闭的单元，外部只能通过对象提供的公共接口来访问或操作对象的内部状态，而无法直接访问或修改对象的数据
这样可以保证对象的内部状态不受外部干扰，从而提高了程序的安全性和可靠性
继承：通过继承中一个类可以从另一个类中继承某些属性和方法，并在此基础上添加新的属性和方法，从而避免了重复编写代码的冗余，提高了代码的可重用性和可维护性
多态：多态是指同一个消息可以被不同的对象解释执行，即不同的对象对同一个消息作出不同的响应。具体来说，多态可以通过虚函数和模板等机制实现。通过多态可以使代码更加灵活、可拓展，同时也能够使程序更易读懂和维护
二.封装
class A{ public: A(int a){ } }
1.重载（Overload）
成员被重载的特征：（1）相同的范围，在同一个类中
（2）函数名字相同
（3）参数不同
2.抽象类和纯虚函数
纯虚函数是在基类声明的虚函数(加上 =0),它在基类中没有定义,但是要求派生类都要实现自己的实现方法
包含纯虚函数的类称为抽象类
(1) 抽象类只能用作其他类的基类,不能定义抽象类的对象
(2) 抽象类不能用于参数类型 函数返回值 或 显示转换的类型
(3) 抽象类可以定义抽象类的指针和引用,此指针可以指向它的派生类,进而实现多态性
三.继承
class B: public A{ public: B(int a,int b):A(a){ } }; class C:public A{ public: C(int a,int c):A(a){ } }; //C++允许多继承 class D:public B,public C{ public: D(int a,int b,int c):B(a,b),C(a,c),A(a){ } };
1.继承的调用顺序
#pragma once #include <iostream> using namespace std; class F{ public: F(){ k5 = 10; cout << "F:F()" << endl; } ~F(){ cout << "F:~F()" << endl; } //virtual ~F(){} void FuncA(){ cout << "F:FuncA()" << endl; } virtual void FuncB() { cout << "F::FuncB()" << endl; } int k5; protected: int k4; }; class Z : public F{ public: Z(){ k5 = 5; cout << "Z:Z()" << endl; } ~Z(){ cout << "Z:~Z()" << endl; } void FuncA(){ cout << "Z::FuncA()" << endl; } void FuncB() { cout << "Z::FuncB()" << endl; } int k5; protected: int k4; };
#include "Jicheng.h" int main() { F* a = new F(); //F() cout << endl; F* a1 = new Z(); //F() Z() cout << endl; Z* a2 = new Z(); //F() Z() cout << endl; //Z* a3 = new F(); 错误 a->FuncA(); //F:FunA() a1->FuncA(); //F:FunA() a2->FuncA(); //Z:FunA() 如果子类没有相应的函数，那么会调用父类的函数 a->FuncB(); //F:FunB() a1->FuncB(); //Z:FunB() a2->FuncB(); //Z:FunB() int k5 = a->k5; //10 int k4 = a1->k5; //10 int k3 = a2->k5; //5 //int k55 = a->k4; k4是保护成员，无法访问 delete a; //~F() cout << endl; delete a1; //如果父类析构函数加virtual 那么会多一个子类的析构函数 ~Z() ~F() cout << endl; delete a2; //~Z() ~F() cout << endl; system("pause"); return 0; }
2.继承的访问权限
(1)类继承访问权限
父类的private成员无法被继承
（1）public继承：父类的public/protected成员继承到子类的访问权限不变
（2）private继承：父类的public/protected成员继承到子类变为private
（3）protected继承：父类的public/protected成员继承到子类变为protected
(2)成员访问权限
（1）private:①能被基类函数 ②能被友元函数 访问，无法被基类对象访问
（2）protected:①能被基类函数 ②能被友元函数 ③能被子类函数 访问，无法被基类对象访问
（3）public:①能被基类函数 ②能被友元函数 ③能被子类函数 ④能被基类对象
3.继承的隐藏规则
隐藏是指派生类的函数屏蔽了与其同名的基类函数。注意只要同名函数，不管参数列表是否相同，基类函数都会被隐藏
四.多态
1.虚函数（覆盖，Override）
覆盖是指派生类函数覆盖基类函数，特征：（1）不同范围，分别位于派生类和基类
（2）函数名字相同
（3）参数相同
（4）基类函数必须有virtual关键字
主要是实现了多态的机制,简而言之就是用父类(基类)的指针指向子类(派生类)的对象,然后通过父类(基类)的指针调用不同子类(派生类)的对象的不同函数,这就是一种泛型.
一个公有派生类对象可以赋值给基类的对象,但是基类的对象不能赋值给派生类的对象
虚函数一般用于基类成员函数来绑定派生类成员函数一起调用
默认情况下成员函数不能动态绑定，但是添加virtual函数（虚函数）可以让函数有晚绑定的灵活性
2.虚函数的使用
//1.在基类用virtual声明成员函数为虚函数, class Base{ virtual void A(); }; //在类外定义虚函数无需加virtual void Base::A(){ } //2.在派生类重新定义虚函数,要求函数名/函数类型/函数参数的类型和个数保持一致 class Derive : pubic Base{ //虚函数在派生类重新声明时,无需加virtual void A(); }; //3.定义一个指向基类对象的指针变量,并使用基类对象的指针变量指向不同的派生类对象的函数 void main(){ Base* p=new Derive(); p->A(); }
class Base { public: Base() {echo();} virtual void echo() {printf(“Base”);} }; class Derived:public Base { public: Derived() {echo();} virtual void echo() {printf(“Derived”);} }; int main() { Base* base = new Derived(); base->echo(); //输出Base Derived Derived return 0; }
3.动态绑定技术
#include <iostream> using namespace std; class A { public: virtual void func(int val = 1) { std::cout " << val << std::endl; } virtual void test() { func(); } }; class B : public A { public: void func(int val = 0) { std::cout " << val << std::endl; } }; int main(int argc, char* argv[]) { A*p1 = new A; A*p2 = new B; //B*p3 = new A; //error B*p3 = reinterpret_cast<B*> (new A); B*p4 = new B; //测试test() p1->test(); //A->1 p2->test(); //B->1 p3->test(); //A->1 p4->test(); //B->1 //测试func() p1->func(); //A->1 p2->func(); //B->1 p3->func(); //A->0 p4->func(); //B->0 return 0; }
#include <iostream> using namespace std; class A { public: void func(int val = 1) { std::cout " << val << std::endl; } //这个test()的virtual可有可无 virtual void test() { func(); } }; class B : public A { public: void func(int val = 0) { std::cout " << val << std::endl; } }; int main(int argc, char* argv[]) { A*p1 = new A; A*p2 = new B; //B*p3 = new A; //error B*p3 = reinterpret_cast<B*> (new A); B*p4 = new B; //test() p1->test(); //A->1 p2->test(); //A->1 p3->test(); //A->1 p4->test(); //A->1 //func() p1->func(); //A->1 p2->func(); //A->1 p3->func(); //B->0 p4->func(); //B->0 return 0; }
4.虚析构函数
虚析构函数的作用是delete动态对象时释放资源
//test.h class A{ public: char* strA; A(char* a){ strA=new char[12]; strncpy(strA,a,strlen(a)); } virtual ~A(){ //不加virtual会报错 delete strA; } }; class B:public A{ public: char* strB; B(char* a):A(a){ strB=new char[12]; strncpy(strB,a,strlen(a)); } ~B(){ delete strB; } }; //test.cpp int main(){ char input[]="Hello"; A* a=new B(input); delete[] a; system("pause"); return 0; }
