C++复习之路

1. using namespace std //打开一个命名空间 std；
2. endl //本质上 是一个函数----换行、刷新缓冲区
3. scanf 参数需要取地址
4. ：： 作用域运算符 ：：前面不加任何符号表示全局作用域
5. system（“pause”） //程序到此暂停 方便调试、观察程序
6. 空类中有那些默认的：默认无参构造
7. 默认析构
8. 默认浅拷贝构造
9. 默认operator=（const CTest& tst）重载操作符

10. C与C++的区别（面向过程与面向对象）
        C语言是面向过程的，把一个大的模块，分成若干个小的模块，更注重实现的逻辑 但不利于扩展和复用。
    C++ 是面向对象的设计语言，更注重程序整体的设计。方便优化、管理 本质是在设计思想上
    C++兼容C的特性 同时具有新的特性 继承、封装、多态。

    
    面向对象的三大特性
        封装：将零散的数据和函数放在一个集合里方便管理和使用；
        继承
        多态

    优点
        封装：将零散的数据和函数放在一个集合里方便管理和使用；
        复用性：公共的功能，过程的抽象 体现为重复使用的类和方法 要求我们针对某一类功能设计，而不是某一个功能设计
        扩展性：增加新的功能不会影响到已经设计好的功能；

    输入输出
        cin/cout： 类对象
        printf（）/scanf（）：函数 PS：scanf需要传地址例如：&a

    命名空间：区分相同作用域下的相同名称的变量
        定义：namespace+名称
        使用：1.using namespace+名称    注意是否有变量冲突                        
      2.名称+：：（：： 为作用域运算符 前面不加符号表示全局）

    动态申请空间
         new：直接加空间类型 ；                                                                    
     delete 回收数组空间需要在变量前加 []
        malloc（4）//参数：空间大小 返回值void*                                                            
      初始化： memset（空间，0，空间大小）        释放：free（）
        
    malloc与new的区别：
    1.new-delete 需要编译器支持；malloc-free需要头文件支持
    2.malloc 申请空间大小。返回值是void* 需要强转；new  指定类型 返回指定类型的地址
    3.new 可以指定初始化
    4.new 申请对象空间 自动调用构造函数 delete 自动调用析构函数 malloc-free不会
     
        new 的使用： int* *p1= new int*;//指针
          int* *p2=new int*[5];//指针数组
          int(*(*p3))[5]=new (int(*)[5]);//数组指针
          int(*p4)[2]=new int[3][2];//二维数组
          AA *p5=new AA; //结构体

    bool：（关键字）
        BOOL与bool的区别：1.BOOL //typedef int；bool是关键字；2.BOOL大小为4个字节；bool大小为一个字节

    增强的for循环
        for（变量：要遍历的数组/容器）{}

    string
        需要头文件<string>初始化字符串：string str=“123”；str=（“123”）；
        string拼接：直接相加即可；
        可通过下标直接访问字符串
        截取：strsub（index，length） 长度超限返回有效的字串；下标超限不允许；
        str.size();//返回长度；
        str.c_str();//返回char*
        可以用增强的for遍历

    函数重载
        函数参数允许指定默认值 在函数声明时指出；指定默认值时 从右到左依次指定不能间断；
        函数重载：描述的是多个函数之间的关系；定义：在同一个作用域下，函数名相同，参数列表不同（参数的类型、数量）；调用时自动匹配；注意避免二义性。

    nullptr
        关键字：空指针
        通过强转指定空指针类型
        NULL与nullptr的区别：NULL是宏替换；nullptr是关键字。

    引用：int &b=int a;
        引用定义即初始化
        一旦引用一块空间，就不能改变
        指针和引用的区别：1.引用定义就要初始化，指针可以不用初始化；2.引用一旦引用一块空间就不能引用其他空间，指针可以指向任何符合类型的空间；3.定义引用不需要开辟额外的空间，指针需要额外的空间存储。

    函数传参
        值传递 不需要修改值
        地址传递 需要修改但需要额外的空间
        引用 可以修改且不需要额外的空间

    类：数据和算法的集合
        对象：类的一个实例，真正存在于地址空间
        类与结构体的区别：1.类的属性方法默认是私有的，结构体是公有的；2.类的默认继承方式是私有的，结构体是公有的；
        访问修饰符：修饰类中成员的访问控制；一个类成员的访问范围；默认的访问修饰符是private
            public：成员在类内类外都可以使用
            protected：在类内和子类中可以使用
            private：只能在类内使用
        setter/getter：设置和获取私有的属性值；
        构造函数：初始化类成员属性，空类中默认有一个无参的构造函数。名为类名，无返回值。
    只要重写了构造函数，就不提供默认的无参构造了 构造函数可以有多个，是重载的关系；
            调用一个带参数的构造函数 CClass class(参数)；
        析构函数： 回收类中申请的额外空间 ~类名（）
        对象的种类：
            定义在函数内的栈区对象；局部对象在调用结束后结束，
            new 出的堆对象。new遇到delete删除
            全局对象：程序运行开始，直到结束空间才被吸收；
                区别：作用域：全局对象是整个程序；静态全局对象：整个文件。
            静态全局对象：程序运行开始，直到结束空间才被吸收；
            静态局部对象：函数第一次执行开始，程序结束时结束。
            临时对象（匿名）：生命周期是当前行。
        类的进一步探究：
            空类的大小是1，用于占位证明对象真实存在
            类成员属性：属于对象，在定义对象时真实存在于内存中。定义多个对象，在内存中存在多份；类成员函数：属于类，在编译期存在，多个对象共用一个函数。
            this指针：类中的非静态函数默认隐藏的参数 类*const this
                作用：连接成员函数与对象
            静态成员属性：不属于对象的，属于类，只用一份。
                只能在类外初始化 类型 类名：： 变量名=初始化； 
            静态成员函数：属于类，在编译期存在，多个对象共用一个函数。可以通过类名：：调用，也可以通过对象调用
                不能使用普通的成员属性
                与普通成员函数的区别：没有this指针
            编译期：将源代码程序交给编译器处理，生成可执行程序。
                访问修饰符是编译期的限制
                规定类成员的使用范围
            运行期：将程序交给系统执行
            常量：
                初始化参数列表：构造函数后，：初始化变量（value）
                    初始化参数列表中，初始化成员的顺序与类中定义有关，与初始化参数列表顺序无关。
                const 修饰的空间不能修改
                常函数：定义在参数列表后，可读不可写成员属性；不能调用非常函数；原因：const 修饰this指针不能通过this修改；
                常量对象：只能调用常量函数

    类之间的内联关系
        内联函数在编译期被替换
        函数体代码量少，逻辑简单 inline 以空间换时间
        类内定义并声明的函数默认为内联函数

    类之间的横向关系
        复合：整体与部分，包含被包含，生命周期有关系
        依赖： 多为使用关系，生命周期无关联，弱关系
        关联：弱关系需要定义指针
        聚合：需要定义容器，聚合有
        继承：子类类名后 ：访问修饰符  父类 子类可以使用父类的成员。
            父类成员在父类初始化，子类成员在子类初始化。
            父类与子类有相同的成员，定义子类对象，CSon：：son. 需要指定父类，CFather：：fa
            定义子类对象，包含父类成员属性，内存空间首地址是父类成员，空间中有子类成员
            定义子类对象：在子类中的构造的初始化参数列表：CFather（）调用父类构造。构造执行顺序先父类，后子类，析构的执行顺序相反。
            继承的好处：
                将一些类的公共部分，提取出来成为一个类，这些类继承抽离出来的类（父类），提高代码的复用性、扩展性。
            继承方式：
                public：public、protected 不变，private 为不可访问。
                protected： public protected变为protected，private 不可访问
                private：  public protected变为private，private 不可访问
            隐藏：
                在继承关系下，父类与子类同名的成员关系为隐藏。
            父类指针指向子类对象：
                统一多种子类对象，提高代码的复用性。

    类成员的函数指针
        函数指针
            函数调用的两种方式
                直接调用
                通过函数指针间接调用
            函数指针的好处：
                将实现同一功能的函数标识起来，使系统结构更加清晰，方便后期代码维护，便于分层设计，利于系统抽象，降低代码耦合度，使得接口与实现分开。
        ：：*  整体的运算符，定义类成员指针。
            C++提供的整体的运算符，.*  ->* 调用函数指针。

    多态
        父类指针指向子类，父类有子类的行为，多种子类有多种行为，由父类指针统一管理。
        多态的条件：1.有继承关系（父类~子类）；2.父类指针指向子类对象；3.父类存在虚函数，子类重写虚函数。
        重写：子类重写父类存在的虚函数（virtual）。
        虚函数：_vfptr 类型：void** 虚函数指针，属于对象，指向了vftable，虚函数列表。在定义对象之前存在vfptr，在执行构造的初始化参数列表指向虚函数列表。
        虚函数列表：每个元素都是void* ，实际上是虚函数地址，按照定义顺序包含了所有的虚函数地址。属于类的，只有一份，编译期存在。
        虚函数调用流程：定义对象包含vfptr->vftab找到对应的虚函数地址，调用。
        原理：在继承下，在定义对象之前存在vfptr，在子类的构造函数的初始化列表指向了虚函数列表。
            虚函数列表：继承了父类的成员和虚函数列表，如果重写了，指向子类的虚函数，否则指向父类。如果子类有虚函数顺次指向子类的虚函数。
        缺点：占用空间（vfptr vfptab）；效率底，安全性：类中的私有函数不能定义为虚函数。 
        抽象类：包含纯虚函数的类
            具体类：一定要重写纯虚函数。

    头文件
        类型的声明，函数的声明，类定义
        不参与编译
        extern 声明一个变量
        重复包含：
            加#pragma once 只包含一次 效率高
            通过宏判断，#ifndef #define  代码段#endif

    源文件
        类型的定义，函数的定义 类成员定义 初始化
        多个源文件：自上而下独立编译 
        静态成员属性在对应的源文件中初始化
        静态成员函数在对应的源文件中定义，需要去掉静态关键字
        常函数在对应的源文件中定义，不需要去掉关键字
        虚函数在对应的源文件中定义，需要去掉关键字
        纯虚函数不需要定义实现

    宏
        替换
        替换多行：注意：\后面不能有东西，一般最后一行不加\
        宏可以带参数
        作用只是替换，不会求解
        优点：替换程序中的常量，函数。方便维护。替换函数，省去调用的开销提高效率
        # ：将参数转成字符串
        #@： 将参数转成字符
        ##： 表示拼接

    重载操作符
        operator +：本质上是函数，特殊的重载函数
        分类：
            类内：参数有默认的this，可以按照操作符的写法调用，也可以按照对象调用。
            类外：在类外定义重载操作符需要有一个自定义类型，与类内进行区分。
        重载操作符匹配：与参数类型，数量，顺序有关
        为了区分后++ 需要一个int类型的参数。

    封装迭代器
        遍历
            list<>::iterator ite(list.begin());while(!ite.end()){ *ite ++ite;}
        insert :是前插入
        end：返回有效节点的下一个
        map：映射表     map<>//类型::iterator ite=list.begin();while(!ite.end()){ *ite ++ite;}
            key值不可以修改

    拷贝构造函数：参数是类对象
        explicit：禁止隐式类型转换（对象=值）
        可以利用{ }初始化类中的变量
        类中默认拥有
        参数中对象的成员依次给this中的成员，一一初始化
        默认提供的拷贝构造是浅拷贝
            问题
                1.多个对象的指针指向同一块空间
                避免浅拷贝：函数参数尽量用指针，引用
            解决
                重构拷贝构造函数，并给指针成员单独new一块空间，并初始化对应的值
        空类中默认有operator=（const CTest & tst）//浅拷贝 具有浅拷贝的问题，在当前对象给另一个对象赋值时使用。
            解决：深拷贝