默认形参 内联函数 引用 取别名 指针与引用的相同点和不同点 强制类型转换 面向对象与面向过程 类和对象 访问控制限定符 构造函数 析构函数 初始化列表

一、默认形参

1、什么是默认形参
    在C++中可以给函数的参数设置默认值，当函数被调用时调用者提供了实参则使用实参，如果没有提供则使用默认值
2、默认形参要靠右
    如果函数有多个参数，设置了默认形参，默认形参必须要从右到左连续排列
3、只在声明时设置默认形参
    如果函数的声明和定义分开实现，只在函数声明时设置默认形参即可，否则会出现语法错误
4、默认形参可能会影响重载的效果
    如果对函数进行了重载，又设置了默认形参，调用时可能会造成冲突；因此为重载过的函数设置默认形参时一定要慎重

二、内联函数

1、普通函数
    普通函数会被翻译成二进制指令存储在代码段中，调用语句会生成一条跳转指令；当程序运行到调用语句时，会跳转到函数所在的代码位置执行，执行结束后再返回
2、什么是内联函数
    内联函数也会被翻译成二进制指令，调用语句不会生成跳转语句；而是直接把函数的二进制指令替换调用语句，这样就没有跳转也没有返回，而是直接执行被调用函数；我们把这种函数叫做内联函数 
3、隐式内联和显式内联
    显式内联：在函数的返回值前面添加 inline ，该函数就会以内联机制调用，不是所有的编译器都支持，我们现在使用的g++和gcc不支持
    隐式内联：结构、联合、类的成员函数会自动被当做内联函数处理
4、内联适用的条件
    内联的优点：
        结余了函数传参、跳转、返回等时间，提高代码运行速度
    内联的缺点：
        当内联函数在多个位置被调用，那么该二进制指令被拷贝了多份，这样就产生了冗余，因此代码增加导致可执行文件增大
    1、内容简单且会频繁调用的函数(一次调用会被执行多次)；内容多且极少被调用到的函数不适合内联，因为它节约的时间弥补不了牺牲的内存
    2、带有递归特性的函数无法内联，编译器会自动忽略 inline 关键字
5、incline函数(内联函数)与#include(宏函数)的相同点和不同
    相同点：
        都是采用空间换取时间的策略来提高程序的运行速度
    不同点：
        1、宏函数不是真正的函数，而是语句替换，不会对参数进行类型检查，没有返回值，安全性低
        2、内联函数是真正的函数，会严格检查函数，有返回值，比宏函数的安全性高

三、引用

什么是引用：引用是一种取别名的机制
为什么使用指针：
    1、跨函数共享变量(输出型参数)，引用可替代
    2、提高传参效率，引用可替代
    3、配合字符串(使用字符串时必须与char*指针配合)，string可替代
    4、配合堆内存，继续使用指针
什么情况下使用引用：
    1、跨函数共享变量，比指针安全(不存在空引用，也极少出现野引用)，比指针方便(不需要取地址、解引用)
    2、能够提高传参效率，引用的传参效率比指针要高；因为指针需要4/8字节用于存储地址编号，而引用一个字节都不需要；但引用和指针一样，都有被修改的风险，为了保护目标要增加const
使用引用要注意的问题：
    1、引号必须初始化，所以不存在空的引用
    2、可以引用右值(常量)，但必须使用const修改
    3、引用不可以更换目标，不要返回局部变量的引用(局部变量位于栈内存结束后内存被释放；悬空引用)
指针与引用的相同点和不同点：
    相同点：
        都可以跨函数共享内存，都可以提高函数的传参效率，也都需要const保护。
            
    不同点：
        1、引用是一种取别名机制，而指针是一种数据类型。
        2、引用不需要额外的存储空间，而指针需要4/8字节用于存储内存地址。
        3、指针可以不初始化，引用必须初始化。
        4、有空指针，但没有空引用。
        5、指针可以更换指向目标，而引用不可以。
        6、指针可以配合堆内存使用，而引用不可以。
        7、可以定义指针数组，但不能定义引用数组（可以定义数组指针，也可以定义数组引用，可以定义函数指针，也只可以函数引用）。

四、强制类型转换

由于C语言中的强制类型转换还能继续使用，所以C++中的强制类型转换就是很鸡肋。
为什么C++重新设计强制类型转换？
因为C语言中的强制类型转换太危险

为什么C++的强制类型转换设计的很复杂，使用很麻烦？
因为C++之父认为只有在程序设计的不合理的情况下，才需要强制类型转换；之所以设计的这么复杂，是不想程序员使用，从而去反思、重新设计自己的代码

1、静态类型转换
    static_cast<目标类型>(原类型)
    目标类型和原类型之间必须有一个方向可以自动类型转换，否则就会出现错误
2、动态类型转换
    dynamic_cast<目标类型>(原类型)
    原类型和目标类型之间必须
3、去常类型转换
    const_cast<目标类型>(原类型)
    原类型和目标类型必须是指针或引用，且除了const属性外，其它都相同，否则就会出现错误
4、reinterpret_cast
    reinterpret_cast<目标类型>(原类型)
    只能把整数转换成指针或把指针转换成整数，否则就会出现错误

五、面向对象与面向过程

面向过程：
    关注的是如何解决问题，以及解决问题的步骤
面向对象：
    抽象：
        先找出(想出)能解决的“对象”，分析该对象解决所需要的属性(成员变量)和行为(成员函数)，以达到解决问题的目的
    封装：
        把抽象的结构封装成一个类(结构)，并给类的成员函数、成员变量设置相应的访问权限(public、protected、private)
    继承：
        1、在封装类先考虑现在的有类是否能解决一部分问题，如果有则把现在的继承过程，在此基础上进行扩展，来缩短解决问题的时间
        2、把一个复杂的问题拆分成若干个小问题，每个问题设计一个类去解决，最后把这些类通过继承合并成一个能解决复杂问题的类
    多态：
        发出一个指令，系统会根据实际情况执行相应操作，这种特性就叫多态(同一个命令有多种形态)。
        比如重载过的函数，当调用函数，编译器会根据参数的类型，调用相应的重载版，这就是一种多态。
        具体调用那个版本的函数是编译器在编译时就能确定，因此调用重载函数也叫编译时多态。

    注意：但是行为的细节依然是面向过程，面向对象是以更高的维度去思考问题，而不是寻找解决问题的捷径

六、类和对象

什么是类和对象
    类是由程序员设计的一种数据类型，它里面包含成员变量、成员函数
    对象是类的实例化，可以认为是使用类创建的变量

类的设计和实例化
    class  类名
    {
        成员变量;    //类中的默认属性是private
    public:
        成员函数;
    };

    方法1：类名 类对象;
    方法2：类名* p = new 类名;

类型声明、实现和使用
在头文件中声明：
    cladd 类名
    {
        成员变量;
    public:
        返回值 函数名(参数列表);
    };
在源文件中实现：
    返回值 类名::函数名(参数列表)
    {
        //在成员函数中可以直接使用成员变量、调用其它成员函数，不需要 . ->
    }
注意：如果类的内存不多，也可以考虑在头文件中全部实现

七、访问控制限定符

private
    私有的，被它修饰的成员只能在类内访问，这也是类的默认访问属性
    设置为私有是为了对类进行保护，一般只有成员变量设置为私有的

public
    公开的，被它修饰的成员可以在任何位置访问，一般把类的成员函数都设置为公开的

pretected
    保护的，被它修饰的成员可以在类内和子类中访问，但不能在类外访问

八、构造函数

构造函数是类的同名成员函数，当创建类时它会自动执行，一般负责对类进行初始化、分配资源
格式：
    class 类名
    {
        int* p;
    public:
        类名(参数)  //可重载
        {
            p = new int;
        }
    };

1、构造函数必须是  public 否则无法创建对象
2、构造函数可以重载，可以有多个版本
3、带参数的构造函数的调用
    Test t(实参);
    Test* p = new Test(实参);
4、默认情况下编译器会自动生成一个没有参数，什么都不做的构造函数，一旦显式实现带参的构造，无参构造就不会再生成。
    Test t;    //调用无参构造，如果没有无参构造，该语句会出错
5、也可以通过设置默认形参达到无参构造的效果
6、构造函数没有返回值
7、不要使用malloc为类对象分配内存，因为不会调用析构函数

九、析构函数

析构函数负责对类对象进行收尾，如：释放类中的资源，保存数据等，当类对象销毁时会自动执行
class 类名
{
    int* p;
public:
    类名()
    {
        int* p = new int;
    }
    ~类名()
    {
        delete p;
    }
};

1、析构函数也必须是public
2、析构函数没有参数，没有返回值，不能重载。
3、当类对象的生命周期到期时，可使用delete销毁对象时会自动调用析构函数。
4、构造函数肯定会执行，但析构函数不一定会执行。
5、不要使用free销毁类对象，它不会调用析构函数。
6、如果没有显式实现析构函数，编译器会自动生成一个什么都不做的析构函数

十、初始化列表

初始化列表是构造函数的一种特殊语法，只能在构造函数中使用
格式：
    class 类名
    {
    public:
        类名():成员1(初始化数据),成员2(初始化数据), ... ...
        {

        }
    };
1、类的成员变量不可以设置初始值，而在构造函数执行时类成员变量已经定义完毕，因为 const 成员变量无法在构造函数中初始化
2、初始化列表先于构造函数执行，初始化列表执行时类对象还没有构造完成，因此它是唯一一种给 const 成员赋值的方法
3、当参数名与成员名相同时，它可以自动分辨成员和参数
4、如果有成员是类类型(或者继承了其他类)，那些成员的有参构造也可以在初始化列表中调用