面向对象程序设计基础（OOP）

1. 绪论、基础编程知识

1.1 命令提示符（命令行）

1. 目录结构

   【Win】C:\example\
   【Linux】/home/username/example/
      /home/catherine 进入Linux桌面
      / 进入Linux入口
      /mnt/c 进入C盘（可逐步访问至desktop）
      /mnt/c/Users/Catherine/desktop
   

2. 显示当前目录

   xxxxxxxxxx
   【Win】cd
   【Linux】pwd
   

3. 在当前目录下新建目录 【Win/Linux】mkdir

4. 在当前目录下新建文件

   xxxxxxxxxx
   【Win】type nul>example.cpp
   【Linux】touch example.cpp
   

5. 查看当前目录下的文件

   xxxxxxxxxx
   【Win】dir
   【Linux】ls
   

6. 进入上一层目录 【Win/Linux】cd ..

7. 进入某目录 【Win/Linux】cd example

8. 删除文件

   xxxxxxxxxx
   【Win】del example.cpp
   【Linux】rm example.cpp
   

9. 删除目录及目录下的所有文件

   xxxxxxxxxx
   【Win】rmdir /s example
   【Linux】rm -r example
   

10. 将文件移动到目录

    xxxxxxxxxx
    【Win】move example.cpp example_folder\
    【Linux】mv example.cpp example_folder/
    

11. 将文件拷贝到目录

    xxxxxxxxxx
    【Win】copy example.cpp example_folder\
    【Linux】cy example.cpp example_folder/
    

12. 将目录下的所有文件拷贝到另一目录

    xxxxxxxxxx
    【Win】xcopy /e folder1 folder2
    【Linux】cp -r folder1 folder2
    

13. 打开文件

    xxxxxxxxxx
    【Win】type example
    【Linux】vi example 或 vim example`
    

14. 其他 sudo： 使用管理这身份发出命令 ls -a： 显示隐藏目录 sudo apt-get install：下载软件包 cat example.cpp: 显示文件内容

1.2 Windows Subsystem for Linux (WSL)

一个为在Windows 10上能够原生运行Linux二进制可执行文件的兼容层 [打开WSL的三种方式]

1. 点开Ubuntu
2. cmd输入wsl
3. cmd输入bash

1.3 主流编译器

【Windows】MinGW, MSVC(Visual Studio), TDM-GCC, Clang 【Linux/WSL】g++(配合gdb进行调试)

g++和gcc其实是“集成编译器”，会根据语言选择不同的编译器 GNU是一个组织 GCC = GNU Compiler Collection（可以粗糙地理解为C的编译器） G++ = GNU C++ Compiler（可以粗糙地理解为C++的编译器） GCC和G++的转换：g++ = gcc -xc++ -lstdc++ -shared-libgcc

环境变量

我们希望在命令行使用g++指令编译程序，当前文件夹下没有g++程序。这时，系统除了在当前目录下面寻找程序外，还会到Path环境变量中的目录去找 【Windows】配置环境变量：此电脑-高级系统设置-高级-环境变量-用户环境变量Path-添加g++.exe所在路径(C:\MinGW\bin) 【Linux】配置环境变量 编辑ubuntu软件更新的源服务器的地址: /etc/apt/sources.list 配置环境变量：terminal中用bash打开Linux，nano ~/.bashrc查看 查看当前环境变量：echo $PATH

1.4 主流IDE

【IDE】DEV C++, Clion, Xcode, Visual Studio Code VScode: Ctrl+ ~ 打开终端 【Editor】Sublime Text, Vim

1.5 SSH

SSH(Secure Shell)是建立在应用层基础上的安全协议，可以用其远程登录服务器/其他电脑 登录: ssh remote_username@remote_address 可行的远程登录访问: ssh root@47.102.217.32 结束远程控制: exit 从本地复制到服务器端 (local_file前加-r可以复制文件夹): scp local_file remote_username@remote_address:remote_folder 从服务器复制到本地rsa可以实现免密码登录: scp remote_username@remote_address:remote_file local_folder

1.6 源程序的结构、编译、链接

源程序 ==> 编译器(compiler) ==> 链接器(linker) 编译器: 生成目标模块（.o或.obj文件） g++ -c example.cpp (Linux) 只编译不链接 链接器: 链接为可执行文件 g++ -o example.out（也可以是.exe） example.o (Linux) 链接程序 //-o后紧跟生成文件 ./example.out (Linux) 可执行文件

1.7 多文件编译和链接过程

【Linux】 直接编译：g++ a.cpp b.cpp -o test （g++省略了一些步骤；甚至不需include头文件） 分步编译：（实际运行步骤）

xxxxxxxxxx
 g++ -c a.cpp -o a.o （只编译不链接）
 g++ -c b.cpp -o b.o
 g++ a.o b.o -o test

外部函数的声明只是令程序顺利通过编译，此时并不需要搜索到外部函数的实现/定义；在链接过程中，外部函数的实现/定义才会被寻找和添加进程序，一旦没有找到函数实现，就无法成功链接。

其他语句：

xxxxxxxxxx
g++ -E main.cpp -o main.ii //预编译命令
g++ -S main.cpp -o main.s //转换成汇编语言文本文件
    //查看汇编代码：(web)Compiler Explorer https://gcc.godbolt.org/
    //可以在 ‘Compiler Options’中输入-g等语句 (优化：-O0 -O1 -O2 -O3 数字越大越“激进”)
g++ -c main.cpp -o main.o //编译为二进制文件
g++ main.cpp -o main //链接
    //链接的过程其实还会链接其他的东西
    //extern "C" int printf(const char *__restrict __fmt, ...)
//其他编译选项：
g++ test.cpp --std=c++11 -fno-elide-constructors -o test
    //禁止编译器进行返回值优化
g++ test.cpp -g -o test -fsanitize=undefined,address
    //查看非法访问、溢出、内存外泄的强大命令

使用头文件

头文件里只能进行函数声明而不应进行函数定义，因为如果有多个cpp文件包含此头文件，在链接时会因为重复定义而发生错误。

声明与定义

同一个函数可以有多次声明，但只能有一次实现 变量也可以有声明和定义（int x;是定义） 变量的声明：extern关键字 extern int x; //声明变量 //也可以用于函数声明，但不是必须的 定义：定义是在变量声明后，给它分配上内存（即：定义 = 声明 + 内存分配） (但事实上，变量定义时是否分配内存与编译器的优化行为有关。)

1.8 宏定义

#define是C++语言中的一个预编译指令，它用来将一个标识符定义为一个字符串，该标识符被称为宏名，被定义的字符串称为替换文本

宏替换

宏替换：#define <宏名> <字符串> 一般使用：const double PI = 3.1415926 cpp example.cpp（Linux）可以查看宏替换后的代码——预编译指令

宏定义

带参数的宏定义：#define <宏名>(<参数表>)<字符串> (example: #define sqrt(x) ((x) * (x))) 一般使用内联函数：inline double sqrt(double x) {return x * x}; (inline是避免重复定义的好方法) 也可以使用inline修饰变量：inline int const VAR = 123 (对比static int const VAR = 123，会导致两个文件里调用的全局变量地址不一样)

宏定义的使用

1. 防止头文件被重复包含（原因：#include的本质是拷贝） 方法一：header guards

   xxxxxxxxxx
   #ifndef __BODYDEF_H__
   #define __BODYDEF_H__
    //头文件内容
   #else
    //如果__BODYDEF_H__已经被定义则执行此处语句块
   #endif
   

   方法二： #pragma once

   xxxxxxxxxx
   #pragma once
   //头文件内容
   //用户自定义类型的情况必须使用pragma once或者header guards，即使成功避免在头文件中定义变量和函数也没用
   

   头文件中即使正确使用header guards或pragma once，包含函数或变量的定义，也有可能会出现重复定义的问题

2. 用于Debug输出等

   xxxxxxxxxx
   #ifdef 标识符
      程序段1
   #else
      程序段2
   #endif
   

3. 注意事项 "#"开头的语句（包括宏定义#define)不会被名空间限制住。（例如： namespace a{#define PI 3.14};则在其他名空间也可以调用PI）

    

1.9 编写Make工具的脚本程序

Makefile编写规则

格式：: [tab] Makefile（建立在同一路径目录下）文件内容：

xxxxxxxxxx
all: main test
main: main.cpp student.cpp
    g++ -o main main.o student.o
    //其他可能的语句：g++ -c src/main.cpp -I include -o main.o
    //其中"include"是一个文件夹，里面含有.h文件
main.o: src/main.cpp include/print.hpp
    g++ -c src/main.cpp -I include -o main.o
student.o: student.cpp
    g++ -c student.cpp -o student.o
debug:
    g++ main.cpp product.cpp sum.cpp -o main -DDEBUG
    //或：make -e DEBUG=-DDBUG 
    //-D 表示命令后写入定义
    //这里定义了DEBUG对应宏定义中的Debug输出
    //sum.cpp
    //#ifdef DEBUG {}
    //#endif
clean:
    rm main test
rebuild: clean main
    
(Linux)
//make：相当于make all
//make 任务名：(Example) make clean, make test 
//make -f makefile的文件名
//make -f makefile的文件名 任务名
(Windows)
//把make改成mingw32-make就可以了（在VScodeTerminal或者cmd下，不需要包含路径因为已经在环境变量里了）
//把clean中的rm改成del

其他高级语法：

若在IDE中需要在task.json中配置环境:增加make程序，名称为build

xxxxxxxxxx
//tasks.json
{
      "label": "build",
      "command": "C:\\mingw64\\bin\\mingw32-make.exe",
      "args": [],
      "type": "shell",
},
{
      "label": "clean",
      "command": "C:\\mingw64\\bin\\mingw32-make.exe",
      "args": ["clean"],
      "type": "shell",
},
//launch.json
      "preLaunchTask": "build" (或改成clean)
//改配置可以实现按F5一键makefile+执行main.exe文件

cmake是用来生成makefile的方式

1.10 使用程序主函数的命令行参数

xxxxxxxxxx
#include <iostream>
#include <cstdio> // atoi()
int main(int argc, char** argv)
{
    int a, b;
    a = atoi(argv[1]);
    b = atoi(argv[2]);
    std::cout << a + b << std::endl;
    return 0;
}

IDE中输入命令行参数（VScode）：View -> Command Palette -> Open "launch.json" -> 修改args "args": ["arg1","arg2"]

1.11 GDB调试工具(Linux)

g++ example.cpp -o example.out -g -g在可执行程序中包含标准调试信息

xxxxxxxxxx
gdb example.out                  //调试example.out
r un                             //运行程序
b reak + 行号/函数名               //设置断点
    b reak 10 if (k == 2)        //可以根据具体运行条件设置断点
    d elete break 1              //删除1号断点
info b reak                      //查看已设断点
wa tch x                         //当x的值发生变化时暂停 [!重要! VScode中没有此功能]
awatch x                         //当读取或写入x的时候暂停
set x = 1 or print x = 1         //赋值语句/赋值+输出语句
c ontinue                        //跳至下一个断点
s tep                            //单步执行（进入）
n ext                            //单步执行（不进入）
p rint x                         //输出变量/表达式x
disp lay x                       //持续检测变量/表达式x
l ist                            //列出程序源代码
q uit                            //退出
回车                              //重复上一条指令
//当程序使用-O2 -O3优化后，程序运行结果不同或者报错，不能使用gdb调试。

2. 对象的基础知识

OOP核心思想——数据抽象：类的接口与实现分离。

2.1 函数重载与缺省值

函数重载： 同一名称的函数，有两个以上不同的函数实现，被称为“函数重载”。（多个同名的函数实现之间，必须保证至少有一个函数参数的类型有区别） 内置类型转换： 如果函数调用语句的实参与函数定义中的形参数据类型不同，且两种数据类型在C++中可以进行自动类型转换，则实参会被转换为形参的类型（float转int：向0取整） 函数参数的缺省值：调用函数时，若不提供相应的实参，则编译自动将相应形参设置成缺省值。 1. 缺省值必须是最后一个参数 2. 缺省值冲突可能导致二义性

2.2 基础知识

auto关键字（C++11语法） 1. 编译器根据上下文自动确定变量的类型。 auto i = 3; //int auto f = 0.4f; //float auto a('c'); //char auto b = a; //char auto *x = new auto(3); //int* auto x = new auto(3); //int* 2. 追踪返回类型的函数 可以将函数返回类型的声明信息放到函数参数列表的后面进行声明 auto func(char* ptr, int val) -> int; 3. auto变量必须在编译期确定其类型 4. auto变量必须在定义时初始化 5. 函数的参数不能声明为auto 6. 不能使用sizeof或者typeid操作符 decltype （与auto连用）declare type 1. 对变量或表达式结果的类型进行推导 2. 重用匿名类型

xxxxxxxxxx
 struct {int d; double b;} anon_s;
 int main() {
     decltype(anon_s) as;
     cin >> as.d;
 }

3. 结合auto和decltype，自动追踪返回类型（C++11）

xxxxxxxxxx
auto func(int x, int y) -> decltype(x + y)
{
    return x + y;
}

4. 用于代替冗长复杂、变量使用范围专一的变量声明 ​ 5. 在定义模板函数时，用于声明依赖模板参数的变量类型

xxxxxxxxxx
template<typename _Tx, typename _Ty>
void Multiply(_Tx x, _Ty y)
{
    auto v = x * y;
    std::cout << v;
}
//or：
/* auto multiply(_Tx x, _Ty y) -> decltype(x * y) {
    return x * y;
}*/
Multiply(2, 3);
Multiply(2, 3.3);
//decltype(Multiply(3, 6.7)) result = Multiply(3, 6.7);
//std::cout << result;

内存申请与释放 指针变量所指内存可以通过new/delete运算符在程序运行时动态生成和删除

xxxxxxxxxx
    int * ptr = new int (10); //单个变量
    int * array = new int[10]; //10元素数组
    delete ptr; //删除指针变量所指单个内存单元
    delete[] array; //删除多个单元组成的内存块

零指针

1. NULL或者0都可以表示空指针（NULL可以用来表示空指针，也是整数0）
2. nullptr(C++11)表示严格意义上的空指针——所以用nullptr而不是NULL

For循环

1. 基于范围的for循环

xxxxxxxxxx
 int arr[3] = {1, 3, 9};
 for (int e : arr) //auto e : arr也可以
    cout << e << endl;
 return 0;

2.3 类与对象

对象是由一组属性数据和对这些数据进行特定操作的一组服务所构成的“结合体” 封装 = {结构属性/数据， 服务/函数}

用户定义类型——类class

类class = 成员函数 + 成员变量 成员函数必须在类内声明，但定义（实现）可以在类内或类外 一般在头文件中声明类class，在实现文件中定义成员函数（类外需要类名限定）

​x
//matrix.h
#ifndef MATRIX_H
#define MATRIX_H

class Matrix {
    int data[6][6];
public:
    void fill(char dir); //也可以在类内定义成员函数
};

#endif

//matrix.cpp
#include "matrix.h"

void Matrix::fill(char dir) {...}

2.4 成员变量与成员函数（理解public和private）

类的成员（数据、函数）可以根据需要分成组，不同组设置不同的访问权限

1. public: 被public修饰的成员可以在类外访问
2. private: 默认权限；被private修饰的成员不允许在类外访问（但可以在类内访问操作）
3. protected

对象：用类来定义的变量通常被称为“对象”，可以使用对象名.成员名的形式访问或调用对象的成员函数，用对象指针->成员名访问数据成员或成员函数

2.5 this指针

所有成员函数的参数中，隐含着一个指向当前对象的指针变量，其名称为this

xxxxxxxxxx
void Matrix::fill(char dir) {
    this -> data[0][0] = 1;
}

2.6 内联函数

函数调用要进行一系列的准备和后处理工作（压栈、跳转、退栈、返回等），所以函数调用是一个比较慢的过程，如果大量调用可能会拖慢程序。 使用内联函数，编译器自动产生等价的表达式

内联函数和宏定义的区别

1. 内联函数可以执行类型检查，进行编译器错误检查
2. 内联函数可调试，而宏定义的函数不可调试
3. 宏定义的函数无法操作私有数据成员
4. 宏使用的最常见场景：字符串定义、字符串拼接、标志粘贴

内联函数的注意事项

1. 避免对大段代码使用内联修饰符
2. 避免对包含循环或者复杂控制结构的函数使用内联定义
3. 避免将内联函数的声明和定义分开（一般都写在头文件中）
4. 定义在类声明中的函数默认为内联函数
5. 一般构造函数、析构函数都被定义为内联函数

3. 对象的创建与销毁

3.1 构造函数

构造函数没有返回值类型，函数名与类名相同 类的构造函数可以重载，即可以使用不同的函数参数进行对象初始化 构造函数可以使用初始化列表初始化成员数据 $$$\quad$ 初始化列表的成员是按照声明的顺序初始化的，而不是按照列表中出现的顺序 假如不给成员变量初始化——全局变量和函数静态变量(static)会自动置0；局部变量一般不会自动初始化，其值为未定义，运行结果和系统、编译器有关

xxxxxxxxxx
class A {
private:
    int a;
    int b;
public:
    A(int i) : a(i) {/*函数体*/} //使用初始化列表初始化成员函数
    //example： A(int i) : b(i), a(b) {} 
    //先初始化a，再初始化b，因此a的值不可预测
}

委派构造函数： 在构造函数的初始化列表中，还可以调用其他构造函数，称为委派构造函数

xxxxxxxxxx
class info{
public:
    info() {Init();}
    info(int i) : info() {id = i;}
    info(char c) : info() {gender = c;}
private:
    void Init() {...} //其他初始化
    int id;
    char gender;
};

就地初始化： C++11之前，类中的一般成员变量不能在类定义时进行初始化，只能通过构造函数进行；C++11新增支持就地初始化 默认构造函数： 不带任何参数的构造函数，或每个形参提供默认实参的构造函数，也被称为“缺省构造函数”

xxxxxxxxxx
class A {
private:
    int a = 1; //声明+初始化
    double b {2.0}; //声明+初始化
public:
    A() {} //定义默认构造函数
    A(int i, double j) : a(i), b(j) {}
};
A a; //调用默认构造函数
A b = A(); //同样调用默认构造函数
//就地初始化只是一种简便的表达方式，实际操作仍然在对象构造的时候执行

先调用成员变量的构造，再执行自己的构造函数

xxxxxxxxxx
class Test{
public:
    Member m;
    Test() {cout << "Test()" << endl;}
};
Test t; //先调用Member的构造函数，再执行Test的构造函数

没有手动定义默认构造函数时，编译器会帮我们隐式地合成一个默认构造函数 ​ 显式声明默认构造函数： A() = default;（编译器会定义隐式默认构造函数，即使有其他构造函数存在） ​ 显示删除构造函数：A(char cls) = delete;（用delete显示删除构造函数，避免产生未逾期行为的可能性，当定义A a('cls')；时，编译错误） 对象数组的初始化： ​ 无参定义对象数组，必须要有默认构造函数 ​ 构造函数有参数的数组初始化示例：

xxxxxxxxxx
   A a[3] = {1, 3, 5}; //构造函数只有一个参数
   A a[3] = {A(1,2), A(3, 5), A(0,7)}; //构造函数有两个整型参数

3.2 析构函数

对象的清除和释放资源是由编译器在对象作用域结束处自动生成调用析构函数代码来完成的。 一个类只有一个析构函数，名称是“~类名”，没有函数返回值，没有函数参数

xxxxxxxxxx
class ClassRoom {
    int num;
    int * ID_list; 
public:
    ClassRoom() : num(0), ID_list(nullptr) {}
    ...///ID_list = new int[10];
    ~ClassRoom() { //析构函数
         if (ID_list) delete[] ID_list; //释放内存
    }
}

先执行自己的析构函数，再调用成员变量的析构 隐式定义的析构函数： 注意！隐式定义的析构函数不会delete指针成员，因此有可能造成内存泄露

3.3 对象的构造与析构时机（局部对象和全局对象）

局部对象的构造与析构

1. 局部对象：执行到相应代码时被初始化；所在作用域结束后被析构
2. 作用域：该变量能够引用的区域，例如{}将会形成一个作用域

全局对象的构造与析构

1. 全局对象：在main()函数调用之前进行初始化

2. 在同一编译单元（同一源文件）中，按照定义顺序进行初始化

3. 不同编译单元中，对象初始化顺序不确定

4. 在main()函数执行完return之后，对象被析构

   ! 通常建议使用参数来替代全局变量

3.4 引用 reference

类型名 & 引用名 = 变量名 //Example: int & quote = VAR; 引用必须在定义时进行初始化，不能修改引用指向 1. 函数参数是引用类型 ​ 表示函数的形式参数与实际参数是同一个变量，改变形参将改变实参

xxxxxxxxxx
//传入指针
void swap(int *a, int * b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}
swap(&a, &b);
//传入引用
void swap(int &a, int &b) {
    int tmp = a;
    a = b;
    b = tmp;
}
swap(a, b); //注意不是swap(&a, &b)

2. 函数返回值是引用类型 ​ 但不得指向函数的临时变量（不存在空引用，必须连接到合法的内存）

3.5 运算符重载

可以重载的运算符（加粗运算符只能通过成员函数重载）

1. 双目算术运算符：+，-，*，/，%
2. 关系运算符：==，!=，<，>，<=，>=
3. 逻辑运算符：||，&&，!
4. 单目运算符：+ (正) ，- (负) ，* (指针) ，& (取地址)
5. 自增自减运算符：++，--
6. 位运算符：| (按位或)，& (按位与)，~ (按位取反)，^ (按位异或)，<< (左移)，>> (右移)
7. 赋值运算符：=，+=，-=，*=，/=，%=，&=，|=，^=， <<=，>>=
8. 空间申请与释放：new，delete，new[]，delete[]
9. 其他运算符：( ) (函数调用)，-> (成员访问)，，(逗号)，[] (下标)

对同一运算符，只能采用一种实现（全局函数或成员函数重载） 全局函数的运算符重载: ClassName operator+(ClassName a, ClassName b) {...} 成员函数的运算符重载: Class ClassName{int data; public: ClassName& operator+(ClassName& b) {...};}

1. 运算符++的重载：通过函数体中没有使用的哑元参数来区分前缀与后缀的同名重载

xxxxxxxxxx
//++a <==> operator++(a) 前缀没有哑元参数
const A& operator++(A& a) { //返回值const：不希望返回值被修改；&：节约开销；A也不错
    ++a.data;
    return a;
}
//a++ <==> operator++(a, int) 后缀有哑元参数
A operator++(A& a, int) { //返回值不能加引用
    A new_a(a.data);
    ++a.data;
    return new_a;
}
cout << (++a).data << endl; 
cout << (a++).data << endl;

//哑元可以没有变量名
int fun(int, int a) {return a;}

2. 运算符()的重载：在自定义类中也可以重载函数运算度()，它使对象看上去像是一个函数名

xxxxxxxxxx
//成员函数运算符()重载
public: //class Test里的成员函数
    int operator()(int a, int b) {
        cout << "operator() called " << a << ' ' << b << endl;
        return a + b;
    }
int main() {
    Test sum;
    int s = sum(3, 4); //sum对象看上去像一个函数，故也称为“函数对象”
    int t = sum.operator()(5,6);
    return 0;
}

3. 运算符[]的重载

如果返回类型是引用，则数组运算符调用可以出现在等号左边，接受赋值 ​ 如果返回类型不是引用，则只能出现在等号右边

xxxxxxxxxx
//class WeekTemperature中的public函数
int& operator[](const char* name) // 字符串作下标
    {
        for (int i = 0; i < 7; i++) {
            if (strcmp(week_name[i], name) == 0) 
                return temperature[i];
        }
        return error_temperature; //没有匹配到字符串
    }
int main() {
    WeekTemperature beijing;
    beijing["mon"] = -3; //可以是左值
    return 0;
}

4. =，[]，()，->只能通过成员函数来重载

编译错误：error:'cls& operator[](cls&, cls&)' must be a nonstatic member function ​ 当没有自定义operator=时，编译器会自动合成一个默认版本的复制操作，在类内定义operator=，编译器则不会自动合成；如果使用全局函数重载，可能会对是否自动合成产生干扰

5. 流运算符<<, >>的重载

xxxxxxxxxx
#include <iostream>
using namespace std;

class Test {
    int id;
public:
    Test(int i) : id(i) { cout << "obj_" << id << " created\n"; } 
    friend istream& operator>>(istream& in, Test& dst); 
    //friend表示调用该函数可以访问该对象private的东西
    friend ostream& operator<<(ostream& out, const Test& src); 
};  

istream& operator>>(istream& in, Test& dst) { 
    //返回值引用：考虑 cin >> a >> b; 运行完"cin >> a"返回cin才能继续输入
    //传入参数istream& in表示第一个变量：cin
    //传入参数Test& dst引用：输入到dst，dst被改变，必须引用
    in >> dst.id;
    return in;
}

ostream& operator<<(ostream& out, const Test& src) {
    //返回值引用：考虑cout << a << b; 运行完"cout << a"返回cout才能继续输出
    //传入参数ostream& out表示第一个变量：cout
    //传入参数const Test& src: 常量是因为输入量不会被改变，引用是为了“节省开销”
    out << src.id << endl;
    return out;
} 
//返回值引用：（测试代码）cout << obj1 << obj2 << obj3;

int main() {
    Test obj(1);    
    cout << obj;  // operator<<(cout,obj)
    cin >> obj;  // operator>>(cin,obj)     
    cout << obj;    
    return 0;
}   
//只能使用全局函数重载（在类内声明，在类外定义）：因为如果是成员函数，传入参数的第一个默认为对象（但事实上应该是cin/cout）

3.6 友元

被声明为友元的函数或类，具有对出现友元声明的类的private及protected成员的访问权限 友元的声明只能在类内进行（在public或private里都可以），定义类内类外都可以（友元类不能在类里定义；友元函数定义在类内：全局函数），但一定不是类的成员函数 一个普通函数可以是多个类的友元函数

xxxxxxxxxx
class X {};
class A {
    int data; //默认私有成员
public:
    friend void foo(A &a); //类内声明全局函数为友元
    friend void X::foo(Y); //类内声明X类的成员函数为友元
    friend X::X(Y), X::~X(); //类内声明X的构造函数、析构函数为友元；
    friend class Y; //友元类前置声明，但不能定义
    friend X; //友元类声明
};
class Y {}; //Y能访问A的所有成员
void foo(A &a) { //函数也可以在类内定义
    cout << a.data << endl; 
}

3.7 静态变量/函数

1. 普通静态变量/函数

xxxxxxxxxx
//a.cpp
static int i = 1;
static int func() {...}
//b.cpp
extern int i; //链接错误

1. 初次定义时必须要初始化（且只能初始化1次）
2. 静态局部变量存储在静态存储区，生命周期持续到整个程序结束
3. 静态全局变量/函数内部可链接（对比非静态全局变量：外部可链接），作用域仅限声明文件，可以避免同名冲突

2. 类的静态数据成员

xxxxxxxxxx
//a.h
class A {
public:
    static int data; //类内声明静态数据成员
};
//a.cpp
int A::data = 0; //类外定义静态数据成员（必须要初始化）//modified 2022.6.14
A::data++; //通过类名访问并修改
A a;
a.data++; //通过对象访问并修改

1. 静态数据成员/成员函数被该类的所有对象共享
2. 静态数据成员/成员函数可以通过对象访问，也可以通过类名访问
3. 静态数据成员/成员函数在程序开始前初始化，不依赖于对象实例化
4. 静态数据成员应该在.h文件中声明，在.cpp文件中定义，否则可能链接失败——一定是类内声明，类外定义（可以不初始化）

3. 类的静态成员函数

xxxxxxxxxx
class A {
public:
    static void func() {} //定义可以在类外
};
//可以用对象或者类名直接调用静态成员函数

静态成员函数不能访问非静态成员

4. 静态对象的构造与析构

函数内部定义的静态局部对象：

1. 程序执行到该静态局部对象的代码时被初始化
2. 离开作用域不析构
3. 第二次执行到该对象代码时，不再初始化，直接使用上一次的对象
4. 在main()函数结束后被析构

静态全局对象和类静态对象：main()函数前初始化，return后析构

xxxxxxxxxx
//类静态对象：类A的对象a是类B的静态变量
//与B是否实例化无关
class A {};
class B {
    static A a;
};

3.8 常量

常量关键字const常用于修饰变量、引用/指针、函数返回值等

1. 普通常量修饰

xxxxxxxxxx
    const int n = 1; //修饰变量必须就地初始化，变量值不能改变
    int a = 1; const int& b = a; //不能通过b改变a的值
    const int* func() {...} //函数返回值的内容不能被修改

2. 类的常量数据成员/成员函数

xxxxxxxxxx
class A {
    const int data = 1; //在对象的整个生命周期里不能更改
    void func() const {...} //实现语句不能修改类的数据成员
    //如果类的成员函数试图修改类的数据成员的值，不会报错，不会修改
    //原因：拷贝构造函数
    //改成this->data++;可以观察到报错
};
const A a; //则a只能调用以const修饰的成员函数

常量成员函数可以修改静态数据成员 非常量对象的常量成员函数不能访问非常量成员函数 常量数据成员的初始化: 构造函数初始化列表；就地初始化；不允许在函数体中初始化

3. 常量对象：只能调用常量函数，不能修改数据成员

4. 类的常量静态数据成员

不存在常量静态函数: ​ 静态函数隶属于类，可以不实例化而直接通过类名访问 ​ 常量/非常量函数的访问权限需要通过实例化后的对象是否为常量对象来决定。常量修饰函数必须绑定在对象上 ​ 因此，静态函数和常量函数互相冲突

xxxxxxxxxx
class A {
    static const char* cs; //不可以就地初始化
    static const int i = 2; //可以就地初始化
};

类内声明类外定义；例外：int和enum类型可以就地初始化

3.9 对象的构造与析构

1. 常量对象的构造与析构：与普通对象相同
2. 静态对象的构造与析构：静态全局对象与普通全局对象相同，静态局部对象（函数内作用域；类静态对象）不同
3. 参数对象的构造与析构

xxxxxxxxxx
//若传递的是形参
void fun(A b) {
    cout << "In fun: b.s = " << b.s << endl;
}
fun(a);
//在函数被调用时，b被构造，调用拷贝构造函数进行初始化。
//默认情况下，对象b的属性值和a一致。
//函数结束时，调用析构函数，b被析构

//若传递的是类对象的引用
void fun(A &b) {
    cout << "In fun: b.s = " << b.s << endl;
}
fun(a);
//在函数被调用时，b不需要初始化，因为b是a的引用。
//在函数结束时，也不需要调用析构函数，因为b只是一个引用，而不是A的对象。

4. 类的指针成员：有指针的类作为函数参数类型要设为引用

xxxxxxxxxx
class A {
public:
    int *data; // 注意这是一个指针
    A(int d) {data = new int(d);}
    ~A() {delete data;} // 注意这里，释放之前申请的内存
};
void fun(A a) { 
    cout << *(a.data) << endl;
}
int main() {
    A object_a(3);
    fun(object_a);
    return 0; // 在程序结束时会出错
}
//对象a和对象object_a的data成员一样（地址一样），所以delete的时候释放的是同一块内存地址。
//对象a析构时不会出错。但对象object_a析构时，因为试图释放一块已经释放过的内存，所以会出错。
//修改：传参void fun(A &a) {...}

5. 对象的new和delete

xxxxxxxxxx
A *pA = new A(3); //生成一个类对象并返回地址（构造函数被调用）
delete pA; //删除该类对象，释放内存资源（析构函数被调用）

A *pA = new A[3];
delete [] pA; //删除该对象数组及数组中的每个元素，释放内存资源
delete pA; //只调用一次析构函数，造成内存泄漏；造成段错误，导致程序崩溃（因为分配空间的起始地址是pA-4byte，而这样直接释放pA指向的内存空间）

4. 对象的引用与复制

4.1 常量引用

最小特权原则：给函数足够的权限去完成相应的任务，但不要给予他多余的权限。 常量引用：函数没有修改权限而只能读取参数值

xxxxxxxxxx
void add(const int& a, const int& b);

4.2 拷贝构造函数

拷贝构造函数：特殊的构造函数，它的参数是语言规定的，是同类对象的常量引用。

xxxxxxxxxx
class Person {
    int id;
public：
    Person(const Person& src) {id = src.id; ...} //注意参数类型固定
};

拷贝构造函数被调用的三种常见情况：

1. 用一个类对象定义另一个新的类对象：Person b(a)，Person c = a;
2. 函数调用时以类的对象为形参：Func(Person a)
3. 函数返回类对象：Person Func(void) 编译器会自动调用“拷贝构造函数”，在已有对象基础上生成新对象

隐式定义的拷贝构造函数：调用所有数据成员的拷贝构造函数或拷贝赋值运算符 对于基础类型 (int, double...)（不包括递归调用基类拷贝构造函数的情况）来说，默认的拷贝方式为位拷贝，即对整块内存进行复制。 位拷贝在遇到指针类型成员时可能会出错，导致多个指针类型的变量指向同一个地址。因此，为了避免指针被重复删除，不应使用隐式定义的拷贝构造函数。

拷贝构造函数的执行顺序

xxxxxxxxxx
Myclass func(Myclass c)  { //拷贝构造函数(c) 
    Myclass tmp; //默认构造函数(tmp)
    return tmp; //拷贝构造函数（返回类对象tmp）
}  //tmp的析构函数；c的析构函数

拷贝构造函数的调用时机

xxxxxxxxxx
#include <iostream>
using namespace std;

class Test {
public:
    Test() { //构造函数
        cout << "Test()" << endl;
    }
    Test(const Test& src) { //拷贝构造
        cout << "Test(const Test&)" << endl;
    }
    ~Test() { //析构函数
        cout << "~Test()" << endl;
    }
};

Test copyObj(Test obj) {
    cout << "func()..." << endl;
    return Test();
}

int main() {
    cout << "main()..." << endl;
    Test t;
    Test a = copyObj(t);//修改代码
    return 0;
}
//运行结果如下：
//g++ test.cpp --std=c++11 -fno-elide-constructors -o test
main()...
Test() //调用构造函数构造t
Test(const Test&) //调用拷贝构造函数拷贝obj = t
func()... 
Test() //调用构造函数构造无名对象unnamed
Test(const Test&) //调用拷贝构造函数拷贝返回值unnamed到某无名对象unnamed2
~Test() //析构临时变量unnamed
Test(const Test&) //调用拷贝构造函数拷贝unnamed到对象a
~Test() //析构unnamed2 
~Test() //析构obj
~Test() //析构a
~Test() //析构t

使用拷贝构造函数

频繁的拷贝构造函数会造成程序效率的显著下降。 解决方法：

1. 使用引用/常量引用传参数或返回对象

xxxxxxxxxx
func(MyClass a) -> func(const MyClass& a) //引用或常量引用传递参数
MyClass func(...) -> MyClass& func(...) //返回值为引用

2. 将拷贝构造函数声明为private

xxxxxxxxxx
class MyClass {
    MyClass(const MyClass&) {}
public:
    MyClass() = default;
};

3. 用delete关键字让编译器不生成拷贝构造函数的隐式定义版本

xxxxxxxxxx
class MyClass {
public: 
    MyClass() = default;
    MyClass(const MyClass&) = delete; //拷贝构造函数显示删除
};

4.3 右值引用

左值：可以取地址、有名字的值——可以被&引用 右值：不能取地址、没有名字的值；常见于常值、函数返回值、表达式 右值引用: 右值可以被&&引用 int &&e = a + b;，&&不能引用左值 常量左值引用能绑定右值： const int &e = 3; 所有的引用（包括右值引用）本身都是左值

xxxxxxxxxx
void ref(int &x) {
    cout << "left " << x << endl;
}
void ref(int &&x) {
    cout << "right " << x << endl;
    ref(x); //调用函数left
}
int main() {
    ref(1); //1是一个常量，调用函数right
    return 0;
}

4.4 移动构造函数

右值引用可以延续即将销毁变量的生命周期，用于构造函数可以提升处理效率，在此过程中尽可能少地进行拷贝。使用右值引用作为参数的构造函数叫做移动构造函数

xxxxxxxxxx
ClassName(const ClassName& VairableName); //拷贝构造函数
ClassName(ClassName&& VariableName); //移动构造函数

移动构造函数示例

xxxxxxxxxx
class Test {
public:
    int * buf; //// only for demo.
    Test() {
        buf = new int[10]; //申请一块内存
        cout << "Test(): this->buf @ " << hex << buf << endl;
    }
    ~Test() {
        cout << "~Test(): this->buf @ " << hex << buf << endl;
        if (buf) delete[] buf;
    }
    Test(const Test& t) : buf(new int[10]) {
        for(int i=0; i<10; i++)
            buf[i] = t.buf[i]; //拷贝数据
        cout << "Test(const Test&) called. this->buf @ "
            << hex << buf << endl;
    }
    Test(Test&& t) : buf(t.buf) { //直接复制地址，避免拷贝
        cout << "Test(Test&&) called. this->buf @ "
            << hex << buf << endl;
        t.buf = nullptr; //将t.buf改为nullptr，使其不再指向原来内存区域
    }
};

Test GetTemp() {
    Test tmp;
    cout << "GetTemp(): tmp.buf @ "
        << hex << tmp.buf << endl;
    return tmp;
}

void fun(Test t) {
    cout << "fun(Test t): t.buf @ "
        << hex << t.buf << endl;
}

int main() {
    Test a = GetTemp();
    cout << "main() : a.buf @ " << hex << a.buf << endl;
    fun(a);
    return 0;
}
//以下为程序运行结果：
Test(): this->buf @ 0x801920
GetTemp(): tmp.buf @ 0x801920
Test(Test&&) called. this->buf @ 0x801920
~Test(): this->buf @ 0
Test(Test&&) called. this->buf @ 0x801920
~Test(): this->buf @ 0
main() : a.buf @ 0x801920
Test(const Test&) called. this->buf @ 0x801d50
fun(Test t): t.buf @ 0x801d50
~Test(): this->buf @ 0x801d50
~Test(): this->buf @ 0x801920

1. 右值引用：移动语义

对左值调用移动构造函数加快左值初始化的构造速度——std::move函数 输入：左值（包括变量等，该左值一般不再使用） 返回值：该左值对应的右值 【注意】：如果参数为常量引用，编译器将采用拷贝构造，move函数失效

xxxxxxxxxx
Test a;
Test b = std::move(a); //可以调用移动构造函数对b进行初始化

示例：右值引用结合std::move可以显著提高swap函数的性能

xxxxxxxxxx
template <class T>
swap(T& a, T& b) {
    T tmp(std::move(a));
    a = std::move(b);
    b = std::move(tmp);
}

2. 拷贝/构造函数的调用时机

1. 判断依据：引用的绑定规则 ​ 拷贝构造函数的形参类型：常量左值引用，可以绑定常量左值、左值和右值 ​ 移动构造函数的形参类型：右值引用，可以绑定右值【优先】
2. 拷贝构造函数的常见调用时机 ​ 用一个类对象/引用/常量引用初始化另一个新的类对象 ​ 以类的对象为函数形参，传入实参为类的对象/引用/常量引用 ​ 函数返回类对象（类中未显示定义移动构造函数，不进行返回值优化）
3. 移动构造函数的常见调用时机 ​ 用一个类对象的右值初始化另一个新的类对象：Test b = std::move(a);, Test b = func(a); ​ 以类的对象为函数形参，传入实参为类对象的右值：func(Test());, func(std::move(a)); ​ 函数返回类对象（显示定义移动构造函数）：return Test();

4.5 拷贝赋值运算符与移动赋值运算符

赋值重载函数必须要是类的非静态成员函数(non-static member function)，不能是友元函数

1. 拷贝赋值运算符 ​可以绑定常量左值、左值和右值

xxxxxxxxxx
Test& operator= (const Test& right) {
    if (this == &right)
        cout << "same obj!\n";
    else {
        for(int i=0; i<10; i++)
            buf[i] = right.buf[i]; //拷贝数据
            cout << "operator=(const Test&) called.\n";
        }
    return *this;
}

2. 移动赋值运算符【优先】 ​可以绑定右值（常量、表达式、函数返回）

xxxxxxxxxx
Test& operator= (Test&& right) {
    if (this == &right) 
        cout << "same obj!\n";
    else {
        this->buf = right.buf; //直接赋值地址
        right.buf = nullptr;
        cout << "operator=(Test&&) called.\n";
    }
    return *this;
}

3. 编译器自动合成的函数/运算符 类中特殊的成员函数/运算符，即便用户不显示定义，编译器也会根据自身需要自动合成: 默认构造函数 拷贝构造函数 移动构造函数（C++11起） 拷贝赋值运算符 移动赋值运算符（C++11起） 析构函数

4. 小结：利用返回值优化提高运行效率

   xxxxxxxxxx
   #include <iostream>
   using namespace std;
   
   class Test{
   public:
       int data = 0;
       Test(){}
       Test(const Test& t){}
       Test(Test&& t){}
   };
   
   Test fn1(){
       Test tmp; return tmp; 
   }
   Test&& fn2(){
       Test tmp; return move(tmp); //运行错误，d会指向被析构的tmp
   }
   Test fn3(){
       Test tmp; return move(tmp); //运行错误，移动构造临时变量
   }
   
   int main(){ //接收返回值的三种办法
       const Test& a = fn1(); //常量左值引用
       Test&& b = fn1(); //右值引用
       Test c = fn1(); //构造新对象
       Test&& d = fn2(); //运行错误，d会指向被析构的tmp
       return 0;
   }
   

    

4.6 类型转换：Srt->Dst

自动类型转换：可以通过定义特定的转换运算符和构造函数来完成 强制类型转换

1. 自动类型转换

方法一：在源类中定义“目标类型转换运算符”

成员函数 + 不能有返回类型 + 参数列表为空 + 返回类型相同

xxxxxxxxxx
class Dst { //目标类
public:
    Dst() {cout << "Dst::Dst()" << endl;}
};

class Src { //源类
public:
    Src() {cout << "Src::Src()" << endl;}
    operator Dst() const { //不需要指定返回类型，因为operator后Dst()已经指明
        cout << "Src::operator Dst() called" << endl;
        return Dst();
    }
};

方法二：在目标类中定义“源类对象作参数的构造函数”

xxxxxxxxxx
class Src; //前置类型声明，因为在Src中要用到Src类
class Dst { //目标类
public:
    Dst() {cout << "Dst::Dst()" << endl;}
    Dst(const Src& s) { //常量引用
        cout << "Dst::Dst(const Src&)" << endl;
    }
};

class Src { //源类
public:
    Src() {cout << "Src::Src()" << endl;}
};

int main() {
    Src s;
    Dst d1(s);
    Dst d2 = s;
    return 0;
}

2. 禁止自动类型转换 explicit

如果用explicit修饰类型转换运算符或类型转换构造函数，则相应的类型转换必须显示地进行

xxxxxxxxxx
explicit operator Dst() const;
explicit Dst(const Src& s);

Dst d1(s); //可以执行，被认为是显示初始化
Dst d2 = s; //错误，隐式转换
//可以改写为：
Dst d2 = static_cast<Dst>(s);

3. 强制类型转换

• const_cast 去除类型的const或volatile属性
• static_cast 类似于C风格的强制转换，无条件转换，静态类型转换
• dynamic_cast 动态类型转换，如派生类和基类之间的多态类型转换
• reinterpret_cast 仅仅重新解释类型，但没有进行二进制的转换

5. 对象的组合与继承

OOP核心思想——继承：建立相关类型的层次关系（基类与派生类）。

5.1 组合

如果对象a是对象b的一个组成部分，则称b为a的整体对象，a为b的部分对象。并把b和a之间的关系称为“整体－部分”关系（也可称为“组合”或“has-a”关系）

访问对象组合的两种方式：① 公有数据成员； ② 私有数据成员 + 公有访问接口

xxxxxxxxxx
class Car {
private:
    Wheel w; ///wheel类中有公有接口void set(int n) {_num = n;}
    //可以就地初始化，但是语法是wheel w = wheel(2)，而不是wheel w(2)
public:
    Engine e; /// 公有成员，直接访问其接口
    void setWheel(int n) {w.set(n);} /// 提供私有成员的访问接口
};

1. 子对象构造时若需要参数，则应在当前类的构造函数的初始化列表中进行。若使用默认构造函数来构造子对象，则不用做任何处理。

2. 对象构造与析构函数的次序 ​ 先完成子对象构造，再完成当前对象构造 ​ 子对象的构造次序仅由类中声明的次序所决定 ​ 析构函数的次序与构造函数相反

3. 对象组合的拷贝与赋值

   xxxxxxxxxx
   class C1{
   public:
       int i;
       C1(int n) : i(n) {}
       C1(const C1 &other) /// 显式定义拷贝构造函数
           {i = other.i; cout << "C1(const C1 &other)" << endl;}
   };
   class C2{
   public:
       int j;
       C2(int n) : j(n) {}
       C2& operator= (const C2& right){ /// 显式定义赋值运算符
           if (this != &right) {
               j = right.j;
               cout << "operator=(const C2&)" << endl;
           }
           return *this;
       }
   };
   class C3{
   public:
       C1 c1;
       C2 c2;
       C3() : c1(0), c2(0) {}
       C3(int i, int j) : c1(i), c2(j) {}
       void print() {cout << "c1.i = " << c1.i << " c2.j = " << c2.j << endl;}
   };
   int main(){
       C3 a(1, 2);
       C3 b(a);  //C1执行显式定义的拷贝构造，C2执行隐式定义的拷贝构造
       cout << "b: "; b.print(); cout << endl;
       C3 c;
       cout << "c: "; c.print(); 
       c = a;  //C1执行隐式定义的拷贝赋值，C2执行显式定义的拷贝赋值
       cout << "c: "; c.print();
       return 0;
   }
   

    

5.2 继承

如果类A具有类B全部的属性和服务，而且具有自己特有的某些属性或服务，则称A为B的特殊类，B为A的一般类。 如果类A的全部对象都是类B的对象，而且类B中存在不属于类A的对象，则A是B的特殊类，B是A的一般类。 （这是一种“一般-特殊”结构，也称分类结构，或”is-a“结构）

1. 基本概念

基类（base class）：被继承的已有类，也称”父类“ 派生类（derived class）：继承的到的新类，也称”子类“、”扩展类“

2. 常见的继承方式

public, private:

xxxxxxxxxx
class Derived : [private] Base {..}; //缺省继承方式为private继承
class Derived : public Base {...};

protected: 继承很少被使用

xxxxxxxxxx
class Derived : protected Base {...};

3. 不能被继承的函数：

• 构造函数 and 析构函数 创建派生类对象时，必须调用派生类的构造函数，派生类构造函数调用基类的构造函数，以创建派生对象的基类部分。C++11新增了继承构造函数的机制（使用using），但默认不继承 释放对象时，先调用派生类析构函数，再调用基类析构函数
• 赋值运算符 编译器不会继承基类的赋值运算符（参数为基类） 但会自动合成隐式定义的赋值运算符（参数为派生类），其功能为调用基类的赋值运算符。
• 友元函数（不是类成员）

4. 派生类对象的构造与析构过程

构造过程：若想要显式调用，则只能在派生类构造函数的初始化列表中进行派生类对象构造。可以调用含参或不含参的基类默认构造函数；若没有显式调用，则编译器自动调用基类的默认构造函数。【先执行基类构造函数来初始化继承的数据，再执行派生类构造函数】

析构过程: 先执行派生类析构函数，再执行有编译器自动调用的基类析构函数

xxxxxxxxxx
class Base {
    int data;
public:
    Base() : data(0) { cout << "Base::Base(" << data << ")\n"; }
    Base(int i) : data(i) { cout << "Base::Base(" << data << ")\n"; }
};
class Derive : public Base {
public:
    Derive() { cout << "Derive::Derive()" << endl; } //没有显式调用，自动调用基类的默认构造函数
    Derive(int i) : Base(i) {cout << "Derive::Derive()" << endl;} 
        //显式调用基类构造函数
    using Base::Base; 
        //继承基类构造函数 相当于Derive(int i) : Base(i) {}; Derive() : Base(i) {}
};
int main() {
    Derive obj;  //先后调用Base()和Derive()
    return 0;
} 

using语句（继承基类构造函数）：如果基类的某个构造函数被声明为私有成员函数，则不能在派生类中声明继承该构造函数（但是保护成员函数依然可以继承，且可以被派生类对象直接调用）；如果派生类使用了继承构造函数，编译器就不会再为派生类生成隐式定义的默认构造函数

5. 继承方式的选择

1） public继承 基类中公有成员仍能在派生类中保持公有；原接口可沿用；最常用 is-a：基类对象能使用的地方，派生类对象也能使用 2） private继承 is-implementing-in-terms-of（照此实现）：用基类接口实现派生类功能 移除了is-a关系 通常不使用，用组合替代 可用于隐藏/公开基类的部分接口，公开方法：using关键字 成员访问权限: 基类中的私有成员，不允许在派生类成员函数或对象中访问 基类中的公有成员： 允许在派生类成员函数中被访问 public继承方式：成为派生类的公有成员，派生类对象可以访问 private/protected继承方式：成为派生类私有/保护成员，不能被派生类的对象访问（除非用using声明） 基类中的保护成员：允许在派生类成员函数中被访问

xxxxxxxxxx
//私有继承，打开基类公有成员的访问权限
class Base {
public: 
    void baseFunc() { cout << "in Base::baseFunc()..." << endl; }
};
class Derive: private Base { // Base的私有继承
public:  
    using Base::baseFunc; /// 私有继承时，在派生类public部分声明基类成员名字
};
int main() {
  Derive obj;
  cout << "calling obj.baseFunc()..." << endl;
  obj.baseFunc(); //基类接口在派生类public部分声明，则派生类对象可调用
  return 0;
}

xxxxxxxxxx
//私有继承中，基类中的私有、保护成员访问
class Base{
private:
    int a{0};
protected:
    int b{0};
};
class Derive : private Base{
public:
    void getA() {cout << a << endl;}  ///编译错误，不可访问基类中私有成员
    void getB() {cout << b << endl;}  ///可以访问基类中保护成员
};
int main() 
{
    Derive d;
    d.getB();
    //cout << d.b; ///编译错误，派生类对象不可访问基类中保护成员
    return 0;
}

xxxxxxxxxx
//私有继承中，打开基类公有成员的访问权限；不允许私有继承的向上转换
class Base {
private:
    int data{0};
public:
    int getData(){ return data;}
    void setData(int i){ data = i;}
};
class Derive : private Base {
public:
    using Base::getData;
};
int main() {
    Derive d1;
    cout << d1.getData();    
    //d1.setData(10);   ///隐藏了基类的setData函数，不可访问
    //Base& b = d1;     ///不允许私有继承的向上转换
    //b.setData(10);    ///否则可以绕过D1，调用基类的setData函数
    return 0；
}

public继承： 基类的公有成员，保护成员，私有成员作为派生类的成员时，都保持原有的状态。 private继承：基类的公有成员，保护成员，私有成员作为派生类的成员时，都作为私有成员。 protected继承：基类的公有成员，保护成员作为派生类的成员时，都成为保护成员，基类的私有成员仍然是私有的。

5.3 重写隐藏与重载

重载（overload） 目的：提供同名函数的不同实现，属于静态多态 函数名必须相同，函数参数必须不同，作用域相同 重写隐藏（redefining） 目的：在派生类中重新定义基类函数，实现派生类的特殊功能 屏蔽了基类的所有其它同名函数 函数名必须相同，函数参数可以不同 重写隐藏发生时，基类中该成员函数的其他重载函数都将被屏蔽掉 可以在派生类中通过using 类名::成员函数名；在派生类中“恢复”指定的基类成员函数（即去掉屏蔽），使之重新可用

xxxxxxxxxx
class Base {
public:
    void f() { cout << "Base::f()\n"; }
    void f(int i) { cout << "Base::f(" << i << ")\n"; }
};
class Derive : public Base {
public:
    using Base::f; //derive的对象可以调用f()
    void f(int i) { cout << "Derive::f(" << i << ")\n"; }
};

using关键字

1）继承基类构造函数 using Base::basefunc(); 2）恢复被屏蔽的基类成员函数 using Base::f; 3）指示命名空间 using namespace std; 4）将另一个命名空间的成员引入当前命名空间 using std::cout, std::endl; cout << endl; 5）定义类型别名 using a = int;

5.4 多重继承

派生类同时继承多个基类

xxxxxxxxxx
class File{}; 
class InputFile: public File{}; 
class OutputFile: public File{}; 
class IOFile: public InputFile, public OutputFile{};

1. 数据存储：如果派生类D继承自的两个基类A，B是同一基类Base的不同继承，则A，B中继承自Base的数据成员会在D中有两个独立的副本，可能带来数据冗余。
2. 如果派生类D继承的两个基类A，B有同名成员a，则访问D中a时，编译器无法判断访问哪个基类成员而报错，可以用以下方式显示表示： cout << derive.MiddleB::a << endl;

6. 虚函数与多态

OOP核心思想——动态绑定：统一使用基类指针，实现多态行为。

6.1 向上类型转换与对象切片

1. 向上类型转换

派生类对象/引用/指针 转换成 基类对象/引用指针，只对public继承有效。Base *p = & d ​ 可以由编译器自动完成，是一种隐式类型转换（对任何接受基类对象/引用/指针的地方） 对象的向上类型转换：

xxxxxxxxxx
class Base {
public:
    void print() { cout << "Base::print()" << endl; }
};
class Derive : public Base {
public:
    void print() { cout << "Derive::print()" << endl; }
};
void fun(Base obj) { obj.print(); }

int main() {
    Derive d;
    d.print();  
    fun(d); ///输出：Base::print()，而不是Derive::print()!!!
    return 0;
}

2. 对象切片

当派生类的对象（不是指针或引用）被转换为基类的对象时（如：传参/赋值时），派生类的对象被切片为对应基类的子对象——意味着派生类的独有定义内容被丢失（又称派生类新数据/新方法丢失）。

3. 指针（引用）的向上转换

当派生类的指针/引用被转换为基类指针/引用时，不会创建新的对象，但只保留基类的接口（即只能访问基类接口，但是派生类接口/数据仍然存在）

xxxxxxxxxx
class Instrument {
public:
    void play() { cout << "Instrument::play" << endl; }
};
class Wind : public Instrument {
public:
    // Redefine interface function:
    void play() { cout << "Wind::play" << endl; }
};
void tune(Instrument& i) {
    i.play(); ///编译器将tune中的函数调用i.play()与Instrument::play()绑定
    ///区别：对象切片
}

int main() {
    Wind flute;
    tune(flute); /// 引用的向上类型转换(传参)，编译器早绑定，无对象切片产生       
    Instrument &inst = flute;  /// 引用的向上类型转换(赋值)
    inst.play();
    return 0;
}
//两次均输出：Instrument::play

总结：（对于基类中有虚函数的情况）

1. 转换为基类指针或引用，则对应虚函数表仍为派生类的虚函数表（晚绑定）。 如果基类中没有虚函数：早绑定
2. 转换为基类对象，产生对象切片，调用基类函数（早绑定）。

6.2 函数调用捆绑与虚函数

捆绑：把函数体与函数调用相联系

将函数体的具体实现代码，与调用的函数名绑定。执行到调用代码时直接进入捆绑好的函数体内部。

早捆绑：捆绑在程序运行之前（由编译器和连接器）完成 晚捆绑/动态捆绑/运行时捆绑：捆绑根据对象的实际类型，发生在程序运行时 ​ 要求在运行时能确定对象的实际类型，并绑定正确的函数。 ​ 晚捆绑只对类中的虚函数起作用，使用virtual关键字声明虚函数。

虚函数

xxxxxxxxxx
class Base {
public:
    virtual ReturnType FuncName(argument) {}; //虚函数
    ///虚函数必须定义函数体
};

对于被派生类重新定义的成员函数，若它在基类中被声明为虚函数，则通过基类指针或引用调用该成员函数时，编译器将根据所指（或引用）对象的实际类型决定是调用基类中的函数，还是调用派生类重写的函数。 ​ 若某成员函数在基类中声明为虚函数，当派生类重写覆盖（同名，同参数函数）它时，无论是否声明为虚函数，该成员函数都仍然是虚函数。 ​ 虚函数要定义函数体！

xxxxxxxxxx
class Instrument {
public:
    virtual void play() { cout << "Instrument::play" << endl; }
};
class Wind : public Instrument {
public:
    void play() { cout << "Wind::play" << endl; }
     /// 重写覆盖（稍后：重写隐藏和重写覆盖的区别）
};

void tune(Instrument& ins) { ///如果传参是对象Instrument ins,无效！ 
    ins.play(); 
    /// 由于Instrument::play是虚函数，编译时不直接绑定，运行时根据ins实际类型调用。
}

int main() {
    Wind flute;
    tune(flute); ///向上类型转换，输出：Wind::play
    return 0;
}

虚函数表：每个包含虚函数的类用于存储虚函数地址的表

对象自身要包含自己实际类型的信息：用虚函数表(VTABLE)表示；运行时通过虚函数表确定对象的实际类型。虚函数表有唯一性，即没有重写虚函数。

虚函数指针(vpointer/VPTR): 每个包含虚函数的类对象中，编译器秘密地放一个指针，指向这个类的VTABLE。当通过基类指针做虚函数调用时，编译器静态地插入能取得这个VPTR并在VTABLE表中查找函数地址的代码，这样就能调用正确的函数并引起晚捆绑的发生。 编译期间：建立虚函数表VTABLE，记录每个类或该类的基类中所有已声明的虚函数入口地址。 运行期间：建立虚函数指针VPTR，在构造函数中发生，指向相应的VTABLE。

xxxxxxxxxx
#include <iostream>
using namespace std;

class B{
    int i;
    float j;
public:
    virtual void fun1() { 
        cout << "B::fun1()" << endl; }
    virtual void fun2() { 
        cout << "B::fun2()" << endl; }
};
class D: public B{
public:
    double k;
    virtual void fun1() { 
        cout << "D::fun1()" << endl; } ///对fun1重写覆盖，对fun2没有，则fun2使用基类的虚函数地址
};

int main() {
    B b; D d;
    B *pB = &d;
    pB->fun1(); //输出：D::fun1()
    return 0;
}

xxxxxxxxxx
//存放类型信息
#include <iostream>
using namespace std;
#pragma pack(4) //按照4字节进行内存对齐

class NoVirtual{ //没有虚函数
    int a;
public:
    void f1() const {}
    int f2() const {return 1;}
};
class OneVirtual{ //一个虚函数
    int a;
public:
    virtual void f1() const {}
    int f2() const {return 1;}
};
class TwoVirtual{//两个虚函数
    int a;
public:
    virtual void f1() const {}
    virtual int f2() const {return 1;}
};

int main(){
    cout << "int: " << sizeof(int) << endl; //4
    cout << "NoVirtual: " << sizeof(NoVirtual) << endl; //4
    cout << "void* : " << sizeof(void*) << endl; //8
    cout << "OneVirtual: " << sizeof(OneVirtual) << endl; //12      
    cout << "TwoVirtual: " << sizeof(TwoVirtual) << endl; //12
    ///对带有单个虚函数的类OneVirtual，对象的大小是单个int的大小加上一个void指针(实际上是VPTR)的大小。
    ///带有多个虚函数的类TwoVirtual与OneVirtual大小相同，因为VPTR指向一个存放所有虚函数地址的表。
    return 0;
}