)AAEP`D]OPY90M7E@FODD0Y.png
对于c语言有常用的数据类型（int，string等）以及自定义数据类型，自定义数据类型只能用结构体定义，而且结构体只能存放常用的数据类型，想实现具体的方法必须在结构体外提供接口
对于c++，自定义数据类型除了用结构体定义，还可以用类定义，class里封装了函数给用户提供接口

侯捷2—C 面向对象编程 - 图2
封装实现的是保护内部，接口就是为了与外部进行交互

类和类之间产生关系：OOP/OOD

  1. Composition （复合）
  2. Delegation （委托）
  3. Inheritance （继承）

1. 复合（Composition）

我有一个你，比如容器 queue 里拥有 deque
image.png
构造由内而外
Container的构造函数首先调用Component的默认构造函数，然後才执行自己。
析构由外而内
Container的析构函数首先执行自己，然后才调用Component的析构函数。

2. 委托（Composition by reference）

我有一个你，但没有完全有 (/狗头)
比如在一个类A中定义一个指针，指针B是另外实现的一个类，所以只有在创建对象时，A才真正拥有B，A与B不同步

3. 继承

是一种的关系，比如人是一种哺乳动物，子类可以继承父类所有的公有资产，copy一份父类data，但成员函数的继承可以理解为子类可以调用父类的函数。

//父类中所有非静态成员属性都会被子类继承下去
//父类中私有成员属性是被编译器给隐藏了，因此是访问不到，但是确实被继承下去了
一般对于父类的属性用protected属性，这样子类在public继承后还是protected属性
对于父类用protected继承后，共有和保护属性全变保护了，这样子类必须重新提供接口才能访问到属性
对于父类用private继承后，后面就啥也访问不到了（丁克）
image.png
构造由内而外
Derived 的构造函数首先调用 Base 的默认构造函数，然後才执行自己。
析构由外而内
Derived 的析构函数首先执行自己，然后才调用 Base 的析构函数。

4. 虚函数 (动态多态)

类中的成员函数大致可以分为三种:

  1. non-virtual 函数 : derived class不能重新定义(override,覆写)
  2. virtual 函数︰derived class 可以重新定义(override,覆写)它 , 且你对它已有默认定义
  3. pure virtual 函数 ∶ derived class 必须(override)覆写它, 而且你对它没有默认定义。

如果一个类中包含纯虚函数，那这个类就叫抽象类，抽象类的父类不能实例化对象，可以理解成行业标准
构造函数不需要定义为虚函数，析构函数必须定义为虚函数。

静态多态, 函数地址早绑定,编译阶段就确定了函数地址

  1. class Animal
  2. {
  3. public:
  4.     void speak() { cout << "动物在说话" << endl; }
  5. };
  7. class Cat :public Animal
  8. {
  9. public:
  10.     void speak() { cout << "小猫在说话" << endl; }
  11. };
  13. class Dog :public Animal
  14. {
  15. public:
  16.     void speak(){ cout << "小狗在说话" << endl; }
  17. };
  20. void DoSpeak(Animal & animal)
  21. {
  22.     animal.speak();
  23. }
  25. int main() {
  26.     Cat cat;
  27.     DoSpeak(cat);             //输出是动物在说话
  29.     Dog dog;
  30.     DoSpeak(dog);            //输出是动物在说话
  32.     system("pause");
  33.     return 0;
  34. }

动态多态 virtual
虚函数只能通过父类引用或者指针来指向子类对象，对于纯虚函数的基类不能实例化对象

  1. //Animal animal
  1. class Animal
  2. {
  3. public:
  4.     //Speak()就是虚函数
  5.     virtual void speak() { cout << "动物在说话" << endl; }
  6. };
  8. class Cat :public Animal
  9. {
  10. public:
  11.     void speak() { cout << "小猫在说话" << endl; }
  12. };
  14. class Dog :public Animal
  15. {
  16. public:
  17.     void speak(){ cout << "小狗在说话" << endl; }
  18. };
  20. void DoSpeak(Animal & animal)
  21. {
  22.     animal.speak();
  23. }
  25. //多态满足条件： 
  26. //1、有继承关系
  27. //2、子类重写父类中的虚函数
  28. //多态使用：父类指针或引用指向子类对象
  30. int main() {
  31.     Cat cat;
  32.     DoSpeak(cat);            //输出小猫在说话
  34.     Dog dog;
  35.     DoSpeak(dog);              //输出小狗在说话
  37.     system("pause");
  38.     return 0;
  39. }

——————设计模式——————

5. 虚函数与继承

$TF3]TN$WYPL4Q@3N14GS@J.png

  1. //继承与虚函数
  2. #include <iostream>
  3. using namespace std;
  5. class CDocument
  6. {
  7. public:
  8.     void onFileOpen ()
  9.     {
  10.         cout << "dialog..." << endl;
  11.         cout << "check file status..." << endl;
  12.         cout << "open file..." << endl;
  14.         serialize () ;
  16.         cout <<"close file..." <<endl;
  17.         cout <<"update all views. .." <<endl;
  18.     }
  20.     virtual void serialize () { };
  21. };
  23. class CMyDoc : public CDocument{
  24. public:
  25.     virtual void serialize (){
  26.         //只有应用程序本身才知道如何读取自己的文件(格式)
  27.          cout << "CMyDoc::Serialize() " << endl;
  28.     }
  29. };
  31. int main ()
  32. {
  33.     CMyDoc myDoc;             //假设对应[File / Open]
  34.     myDoc.OnFileOpen();
  35. }

6. 继承与复合

6.1 复合是在子类中

![ZWLSLVPSOX`}D8WU7XEQVT.png

  1. #include<iostream>
  2. using namespace std;
  4. class B
  5. {
  6. public:
  7.     B() { cout << "B的构造函数" << endl; }
  8.     ~B() { cout << "B的析构函数" << endl; }
  9. };
  11. class A
  12. {
  13. public:
  14.     A() { cout << "A的构造函数" << endl; }
  15.     ~A() { cout << "A的析构函数" << endl; }
  16. };
  18. class C : public A
  19. {
  20. public:
  21.     C() { cout << "C的构造函数" << endl; }
  22.     ~C() { cout << "C的析构函数" << endl; }
  24. public:
  25.     B b;
  26. };
  28. void test01()
  29. {
  30.     C c;
  31. }
  33. int main()
  34. {
  35.     test01();
  37.     system("pause");
  38.     return 0;
  39. }

TUQ53`}QODE7YCGX%FKZF8C.png
不知道这个为啥是B->A->C，但在vs里运行的就是这个结果。感觉应该是A->B->C

6.2 复合是在父类中

R(353VZ7@4V6HCM5LFJ1TEK.png

  1. #include<iostream>
  2. using namespace std;
  4. class B
  5. {
  6. public:
  7.     B() { cout << "B的构造函数" << endl; }
  8.     ~B() { cout << "B的析构函数" << endl; }
  9. };
  11. class A
  12. {
  13. public:
  14.     A() { cout << "A的构造函数" << endl; }
  15.     ~A() { cout << "A的析构函数" << endl; }
  17. public:
  18.     B b;
  19. };
  21. class C : public A
  22. {
  23. public:
  24.     C() { cout << "C的构造函数" << endl; }
  25.     ~C() { cout << "C的析构函数" << endl; }
  26. };
  28. void test02()
  29. {
  30.     C c;
  31. }
  33. int main()
  34. {
  35.     test02();
  37.     system("pause");
  38.     return 0;
  39. }

TUQ53`}QODE7YCGX%FKZF8C.png

7. 继承与委托（功能最强大）

1.

LS@26)0[MRO6(MO[5]7MBFF.jpg

2.文件系统

image.png

3.

image.png
源码实现
image.png
image.png

8. pointer like classes

智能指针
迭代器

9. function like classes

class中含有重载的 操作符（）