C++核心编程—笔记

柔情只为你懂 2023-07-07 11:13 7阅读 0赞

###  C++笔记 ###

1.  C++概述
    
     *  C++两大编程思想
        
         *  面向对象：三大特性
            
             *  封装
             *  继承
             *  多态
         *  泛型编程
2.  双冒号作用域运算符
    
     *  ::如果前面没有任何作用域，代表使用全局作用域
3.  命名空间
    
     *  用途：解决命名冲突
     *  可以存放变量、函数、结构体、类 …
     *  必须声明在全局作用域下
     *  可以嵌套命名空间
     *  是开放的，可以随时向命名空间下添加新的成员，同名命名空间会合并
     *  可以匿名
        
            namespace{
                int a = 100; //相当于在变量前加了一个关键字 static
            }
     *  可以起别名
        
            namespace veryLongName{
                int a = 100;
            }
            void test(){
                namespace veryShortName = NameveryLongName;
                cout << veryShortName::a << endl;
            }
4.  using
    
     *  using声明：当就近原则和using声明同时出现时，需要避免二义性
     *  using编译指令：如果有就近原则，那么优先使用就近原则；存在多个并且有同名出现，需要加作用域区分
5.  C++对C语言增强
    
     *  全局变量检测增强
     *  函数检测增强
        
         *  声明函数返回值
         *  形参类型 检测
         *  返回值检测增强
         *  调用时参数传参个数检测增强
     *  类型检测增强 malloc 返回void\* C++必须强转
     *  struct增强
        
         *  C++可以放入函数
         *  使用时C++可以省略关键字struct
     *  三目运算符
        
         *  C语言返回值
         *  C++返回变量
     *  const增强
        
         *  全局const修饰变量 受到常量区保护，即使语法通过，运行也会报错（C和C++效果一样）
         *  局部const修饰的变量可以间接修改成功（C可修改，C++不可修改）
            
                {
                	const int b = 100;
                	int *p = &b;
                	*p = 200;
                }
         *  C++中const修饰变量可以用来初始化数组 int arr\[b\];
         *  连接属性
            
             *  C默认外部链接属性
             *  C++默认内部链接属性
     *  const分配内存
        
         *  对const修饰变量取地址时会分配内存
         *  const前加external关键字后也会分配内存
         *  使用变量来初始化const修饰变量
         *  对于自定义数据类型，也会分配内存
6.  引用
    
     *  给一个内存空间起别名
     *  一旦初始化后不可修改指向了
        
         *  本质是指针常量，所以必须初始化，并且初始化后不可修改
     *  先定义数组类型，在定义引用
        
            int arr[10];
            int (&Arr)[10] = arr;
7.  参数传递方式
    
     *  值传递
     *  地址传递
     *  引用传递
8.  引用注意事项
    
     *  不要返回局部变量的引用
     *  如果函数返回值是引用，那么这个函数可以作为左值进行运算
9.  指针的引用
    
     *  通过引用技术 可以简化指针
10. 常量的引用
    
     *  类型前加const
        
            int & ref = 10; //错误
            const & ref = 10; //编译会优化,类似于: int temp = 10; const int & int ref = temp;
     *  使用场景：修饰函数中形参，防止误操作
11. 类
    
     *  class + 名 \{ 成员 \}
     *  类构成：成员函数和成员属性
     *  作用域：public、protected、private
        
         *  public： 类内可以访问 类外也可以访问
         *  protected：类内可以访问 类外不可以访问（子类可以访问）
         *  private： 类内可以访问 类外不可以访问（子类不可以访问）
12. 内联函数
    
     *  内联函数引出–宏函数
        
         *  必须保证运算完整性，加括号
         *  即使加括号，有些情况依然和预期结果不符合
     *  函数的声明和实现必须同时加inline
     *  内部成员函数 默认前面加了inline关键字
     *  内联限制（编译器决定是否为内联）
        
         *  不能存在任何形式的循环语句
         *  不能存在过多的条件判断语句
         *  函数体不能过大
         *  不能对函数进行取地址操作
13. 函数默认参数
    
     *  在形参后面=默认值
     *  所有默认参数在参数列表最右边
     *  函数的声明和实现只能有一个有默认参数
14. 占位参数
    
     *  函数参数列表中只写类型，调用时必须要传入参数
     *  占位参数也可以有默认参数
15. 函数重载
    
     *  满足函数重载条件
        
         *  作用域必须相同
         *  函数名称相同
         *  函数的参数类型、个数或顺序不同
         *  返回值不可以作为重载的条件
     *  引用的重载函数
        
         *  加const和不加const也可以作为重载条件
     *  函数重载碰到函数参数默认值时，避免二义性
16. extern “C”
    
     *  函数重载原理，编译器在底层会将函数名字做两次修饰，方便内部访问函数
     *  在C++下运行C语言文件
        
            #ifdef __cplusplus
            extern "C" {
            #endif
            
                ...
                
            #ifdef __cplusplus
            }
            #endif
17. 类的封装
    
     *  C语言的封装
        
         *  缺点：C语言下没有做类型转换的检测；将属性和行为分离
     *  C++封装
        
         *  将属性和行为作为一个整体，来表现生活中的事和物
         *  将成员加权限控制
     *  struct和class区别在于默认权限
        
         *  struct：public
         *  class：private
18. 构造和析构
    
     *  构造
        
         *  没有返回值，也不写void，函数名与类型相同
         *  可以有参数，可以发生重载
         *  由编译器自动调用，不需要手动调用，而且编译器只会调用一次
     *  析构
        
         *  没有返回值，也不写void，函数名与类型相同 在函数名前加~
         *  不可以有参数，不可以发生重载
         *  由编译器自动调用，不需要手动调用，而且编译器只会调用一次
     *  构造函数分类
        
         *  按照参数进行分类
            
             *  有参构造：Person(int age)\{ \}
             *  无参构造（默认构造）：Person( )\{ \}
         *  按照类型分类
            
             *  普通构造
             *  拷贝构造：Person(const Person &p)\{ \}
     *  构造函数调用规则
        
         *  系统默认提供三个函数：默认构造函数、析构函数、拷贝构造函数
         *  如果提供了有参构造函数，那么系统就不会提供默认构造函数，但依然提供拷贝构造函数
         *  如果提供了拷贝构造函数，那么系统就不会提供其他的普通构造函数了
19. 深拷贝和浅拷贝
    
     *  系统提供拷贝构造函数只会做简单的值拷贝
     *  如果类中有属性开辟到堆区，那么在释放的时候，由于浅拷贝问题导致堆区内容会重复释放，程序崩溃
20. 初始化列表
    
     *  构造函数名( ) : 属性 ( 值 ) , 属性 ( 值 ) …
21. 类对象作为类成员
    
     *  当其他类作为本来成员，先构造其他类对象，再构造自身，释放顺序与构造相反
22. explicit关键字
    
     *  防止隐式类型转换方式来初始化化对象
23. new和delete运算符
    
     *  malloc和new、free和delete区别
        
         *  new、delete是运算符，malloc、free是库函数
         *  malloc返回void \*， new返回的是new出来的对象指针
         *  malloc需要判断是否开辟成功，而new内部做了操作（内部会malloc数据在堆区，判断内存是否分配成功，调用构造函数）
         *  malloc不会调用构造函数， 而new调用构造函数
         *  malloc对应释放是free，new对应释放是delete
     *  注意
        
         *  不要用void \*去接受new出来的对象，原因是不能够释放
         *  用new在堆区创建数组，类中必须要存在默认构造函数，否则无法创建
         *  如果是数组释放的时候要在delete后加 \[ \]
24. 静态成员
    
     *  静态变量
        
         *  数据共享
         *  在编译阶段分配内存
         *  在类内声明、类外进行初始化
         *  访问方式：对象访问、类名访问
         *  也有访问权限
     *  静态函数
        
         *  访问方式：对象访问、类名访问
         *  静态成员函数不可以访问非静态成员变量
         *  静态成员函数可以访问静态成员变量，因为都是共享数据
         *  非静态成员函数可以访问静态成员变量和非静态成员变量
         *  也有访问权限
25. 单利模式
    
     *  主席类：一个类中只有唯一的一个实例对象
     *  数据共享，而且只许拿到一个主席的对象的指针即可
26. 成员变量和成员函数存储
    
     *  成员属性算在类大小中
     *  成员函数、静态成员变量、静态成员函数并不算在类大小中
27. this指针
    
     *  this指针指向的是被调用的成员函数所属的对象
     *  \*this对象本体
     *  this解决名称冲突
28. 空指针访问成员函数
    
     *  如果是一个空指针
     *  可以访问没有this的一些成员函数
29. 常函数和常对象
    
     *  this指针本质
        
         *  指针常量 type \* const this;
         *  指针的指向不可以修改，指针指向的值可以修改
     *  常函数：
        
         *  成员函数后面加const，不可以修改成员属性
     *  常对象：
        
         *  不可以修改内部属性
         *  常对象只能调用常函数，不能调用普通成员函数
     *  如果特殊要修改常函数或常对象：在属性前加mutable修饰
30. 友元
    
     *  全局函数作为友元函数
        
         *  全局函数作为本类友元函数，可以访问私有内容  
            在类内部写入：friend + 函数声明
     *  类作为友元类
        
         *  告诉编译器一个类是本类的好朋友，那么他就可以访问到里面私有内容
         *  在类内部写入：friend class 类名
     *  成员函数作为友元函数
        
         *  告诉编译器一个类中的成员函数是本类的好朋友，那么他就可以访问到里面私有内容
31. 加号运算符重载
    
     *  对于内置数据类型，编译器知道该如何进行运算
     *  但是对于自定义数据类型，编译器并不知道该如何运算
     *  利用运算符重载可以解决问题
     *  实现两个类数据类型相加
        
         *  分别利用成员函数和全局函数来实现
         *  成员函数本质 p1.operator+(p2)
         *  全局函数本质operator+(p1,p2)
         *  简化p1+p2
32. 左移运算符重载
    
     *  对于内置数据类型，编译器知道如何cout进行<<运算输出
     *  对于自定义数据类型，无法输出
     *  重载左移
        
         *  利用成员函数：失败，原因不能让cout在左侧
         *  利用全局函数：ostream& operator<<(ostream& cout, class\_name &p)
33. 递增运算符重载
    
     *  前置++
        
         *  返回引用，class\_name & operator++( )
     *  后置++
        
         *  返回值，class\_name operator++(int )
     *  前置++的效率略高于后置++，原因是前置不会调用拷贝构造函数
34. 智能指针（指针运算符重载）
    
     *  智能指针：用来托管堆区创建的对象的释放
     *  如果想让sp对象创建当做一个指针去对待，需要重载-> \*
35. 赋值运算符重载
    
     *  系统会默认给一个类添加4个函数：默认构造、拷贝构造、析构、operator=
     *  由于系统提供的operator会进行简单的值拷贝，导致如果属性中有堆区的数据，会进行重复释放
     *  解决方案：需要重载operator=
     *  返回值 class\_name & operator=(const class\_name & p)
36. \[ \]重载
    
     *  案例
        
            int& class_name::operator[](int index){
                return this->pAddress[index];
            }
37. 关系运算符重载
    
     *  重载 == 和 !=
     *  实现两个自定义数据类型对比操作
38. 不要重载 && 和 ||
    
     *  原因：无法实现短路规则
     *  总结 ( )、\[ \]、->、= 只能卸载成员函数中进行重载
     *  << 和 >> 通常写在全局函数配合友元进行重载
39. 继承
    
     *  基本语法
        
         *  语法：class 子类：继承方式 父类
         *  父类：基类
         *  子类：派生类
     *  继承好处：可以减少重复代码出现
     *  继承方式
        
         *  公共继承
            
             *  父类中public到子类中public
             *  父类中protected到子类中protected
             *  父类中private到子类中private
         *  保护继承
            
             *  父类中public到子类中protected
             *  父类中protected到子类中protected
             *  父类中private到子类中 访问不到
         *  私有继承
            
             *  父类中public到子类中private
             *  父类中protected到子类中private
             *  父类中private到子类中 访问不到
     *  构造和析构
        
         *  先调用父类构造，在调用子类构造，析构顺序和构造相反
         *  可以利用初始化列表方法显示制定出调用父类的哪个构造函数
     *  同名成员处理
        
         *  如果子类和父类拥有同名成员，优先调用子类成员，可以通过作用域调用父类的成员
         *  同名成员函数，子类会隐藏掉父类中的所有版本，如果想调用父类中的其他版本，加上作用域即可
     *  同名静态成员处理
        
         *  如果子类和父类拥有同名成员，优先调用子类成员，可以通过作用域调用父类的成员
         *  同名成员函数，子类会隐藏掉父类中的所有版本，如果想调用父类中的其他版本，加上作用域即可
         *  访问方式有两种
            
             *  通过对象进行访问
             *  通过类名进行访问
     *  多继承
        
         *  class 子类：继承方式 父类1， 继承方式 父类2
         *  当两个父类中有同名的成员被子类继承后，调用时候需要加上作用域区分
     *  菱形继承（Animal父类，Sheep和Tuo同时继承Animal，SheepTuo进行多继承，父类 Sheep和Tuo）
        
         *  问题1：访问父类中的数据，需要加作用域区分具体数据
         *  问题2：由于菱形继承导致继承的数据有一份浪费
         *  解决方案：利用虚继承 virtual Animal类属于虚基类
         *  在Sheep和Tuo类中继承的内容为vbptr 虚基类
            
             *  v：virtual
             *  b：base
             *  ptr：pointer
         *  vbptr指针 指向虚基类表 vbtable
         *  vbtable中有偏移量，通过偏移量可以找到唯一的一份数据
40. 多态
    
     *  静态多态 – 函数重载、运算符重载
     *  动态多态 – 父子之间继承 + 虚函数
     *  动态多态满足条件
        
         *  父类中有虚函数
         *  子类重写父类的虚函数
         *  父类的指针或引用指向子类的对象
     *  重写：子类重写新实现父类中的虚函数，必须返回值、函数名、参数一致才成为重写
     *  子类在做重写的时候，可以不加关键字virtual
     *  多态原理
        
         *  当父类中存在虚函数后，内部发生结构变化
         *  多了指针 vfptr 虚函数表指针 – 指向 虚函数表 vftable
         *  虚函数表内部记录着虚函数的地址
         *  当子类发生重写后，会修改子类中的虚函数表中的函数地址，但是并不会影响父类中的虚函数表
     *  多态好处
        
         *  对扩展提高
         *  组织性强
         *  可读性强
     *  如果父类中有虚函数，子类并没有重写父类的虚函数，那么这样的代码毫无意义（没有用到多态带来的好处，反而内部结构变的复杂了）
41. 抽象类和纯虚函数
    
     *  纯虚函数 语法：virtual void func( ) = 0;
     *  如果一个类中有纯虚函数，那么这个类就无法实例化对象
     *  有纯虚函数的类，也称为 抽象类
     *  如果子类继承了抽象类，那么子类必须重写父类的纯虚函数，否则子类也属于抽象类
42. 虚析构和纯虚析构
    
     *  如果子类中有属性创建在堆区，那么多态情况下，不会调用子类的析构代码，导致内存泄漏
     *  解决方案：利用虚析构或者纯虚析构
     *  虚析构：在析构前加 virtual
     *  纯虚析构 virtual ~函数名() = 0
     *  纯虚析构类内声明、类外必须要实现
     *  如果一个类中有了纯虚析构函数，那么这个类也属于抽象类
43. 向上和向下类型转换
    
     *  父类转子类 向下类型转换 不安全
     *  子类转父类 向上转换安全
     *  如果发生多态，总是安全的
44. 重载 重写 重定义
    
     *  重载 函数重载
        
         *  同一个作用域 函数名相同
         *  参数 个数 类型 顺序不同满足条件
         *  返回值不可以作为重载条件
     *  重写
        
         *  继承关系
         *  父类中有虚函数
         *  子类可以重写父类中的函数，返回值、函数名、参数类别都一致
     *  重定义
        
         *  继承关系
         *  非虚函数 子类重新定义 父类中同名的成员函数
45. 函数模板
    
     *  template 告诉编译器 T是万能数据类型，下面紧跟的函数或者类中出现 T类型，不要报错
     *  调用模板函数
        
         *  自动类型推到，必须让编译器推导出一致 T类型才可以使用模板
         *  显示指定类型，显示的告诉编译类型 T的类型
     *  模板使用的时候必须要告诉编译器 T是什么类型，否则无法使用
46. 普通函数和函数模板的区别和调用规则
    
     *  区别
        
         *  普通函数可以隐式类型转换
         *  函数模板如果是自动类型推到的使用，是不可以发生隐式类型转换
     *  调用规则
        
         *  如果函数模板和普通函数都可以实现调用，那么优先调用普通函数
         *  可以通过空参数列表语法来强制调用函数模板
         *  函数模板也可以发生函数重载
         *  如果函数模板可以产生更好的匹配，那么优先使用的是函数模板
47. 模板机制
    
     *  编译器并不是把函数模板处理成能够处理任何类型的函数
     *  函数模板通过具体类型产生不同的函数（产生了 模板函数）
     *  编译器会对函数模板进行两次编译，在声明的地方对模板代码本身进行编译，在调用的地方对参数替换后的代码进行编译
48. 模板局限性以及利用具体化技术解决
    
     *  模板并不是真正的通用代码，对于一些自定义的数据类型，模板有时不能实现效果
     *  可以通过具体化实现对自定义数据类型进行操作
     *  template<> bool myCompare(Person & a, Person & b)
49. 类模板
    
     *  template下面紧跟的是个类，那么这个类成为类模板
     *  类模板和函数模板区别
        
         *  类模板使用时不可以用自动类型推导，必须显示指定类型
         *  类模板中的类型可以有默认参数
     *  泛型编程 – 体现在模板技术 – 特点 将类型参数化
     *  类模板中的成员函数创建时机
        
         *  类模板中的成员，并不是一开始创建出来的，而是在运行阶段才创建出来
     *  类模板作为参数
        
         *  指定传入类型
         *  参数模板化
         *  整个类模板化
         *  查看T类型名称：typeid(T).name()
     *  类模板遇到继承问题及解决
        
         *  如果父类是一个类模板，子类在做继承时，必须指定出父类中T的类型，否则无法给父类中的T分配内存
     *  类模板的份文件编写问题以及解决
        
         *  类模板不建议分文件编写，因为成员函数创建时机运行阶段，使用时必须要包含.cpp才可以
         *  解决方法：将类中成员函数的声明和实现都写到一个文件汇总，并且将文件后缀名改为.hpp即可（约定俗成）
     *  类模板遇到友元函数
        
         *  全局函数做友元的类内实现
         *  全局函数做友元的类外实现
            
             *  模板函数声明 模板函数实现
50. 类型转换
    
     *  静态类型转换 static\_cast
        
         *  语法：static\_cast<目标类型>（原对象）
         *  对于内置数据类型可以转换
         *  对于自定义数据类型，必须是父子之前的指针或者引用可以转换
     *  动态类型转换 dynamic\_cast
        
         *  语法：dynamic\_cast<目标类型>（原对象）
         *  对于自定义数据类型
            
             *  父转子 不安全 转换失败
             *  子转父 安全 转换成功
             *  如果发生多态，那么总是安全的都可以转成功
     *  常量类型转换 const\_cast
        
         *  只能对 指针 或者引用之间使用
     *  重新解释类型转化 reinterpret\_cast
        
         *  不建议使用 不安全
51. 异常处理
    
     *  基本语法
        
         *  三个关键字：try throw catch
         *  try：试图执行一段可能会出现异常的代码
         *  throw：出现异常后抛出异常关键字 throw+类型
         *  catch：捕获异常 catch(类型)
         *  如果捕获到的异常不想处理，想继续向上抛出 throw
         *  异常必须要有人处理，如果没有处理，程序会自动调用terminate函数，使用程序中断
     *  可以抛出一个自定义类型的异常 myException
     *  栈解旋：从try代码开始，到throw抛出异常，所有栈上的对象都被释放掉，释放的顺序和构造顺序是相额反的，这个过程称为栈解旋
     *  异常的接口声明
        
         *  如果只允许函数体中抛出某种异常，可以使用异常的接口声明
         *  void func(类型)，如果throw(空)，代表不允许抛出异常
     *  异常变量声明周期
        
         *  MyException e会调用拷贝构造
         *  MyException &e引用方式 接受 建议使用这种方式 节省开销
         *  MyException \*e指针方式 接受 抛出&MyException()；匿名对象，对象被释放掉，不可以再操作了
         *  MyException \*e指针方式 接受 抛出 new MyException()；堆区创建的对象，记得手动释放 delete e；
         *  建议使用 引用的方式 去接受对象
     *  异常的多态使用
        
         *  提供基类异常类BaseException 纯虚函数 virtual void printError() = 0；
         *  提供两个子类 继承 异常基类 重写父类中的纯虚函数
         *  测试 利用父类引用去接受子类对象 实现多态
         *  抛出哪种异常就打印哪种异常printError函数
     *  使用系统标准异常
        
         *  标准异常头文件 \#include
         *  使用系统异常类 out\_of\_range(char \*)
         *  捕获 catch(exception &e) \{cout << e.what();\}
52. 标准输入和输出
    
     *  标准输入
        
         *  cin.get() 缓冲区中读取一个字符
         *  cin.get(两个参数) 不读取换行符
         *  cin.getline() 读取换行并且扔掉
         *  cin.ignore() 忽略 （N） N代表忽略字符数
         *  cin.peek() 偷窥 偷看1个字符然后放回去
         *  cin.putback() 返回 把字符放回缓冲区
         *  cin.fail() 缓冲区的标志位 0：正常 1：异常
         *  cin.clear() cin.sync() 重置标志位 并且刷新缓冲区
     *  标准输出
        
         *  out.put() out.write() 利用成员函数输出内容
         *  通过流成员函数
            
             *  int number = 99;
             *  cout.width(20); 预留20空间
             *  cout.fill("\*"); 填充
             *  cout.setf(ios::left); 左对齐
             *  cout.unsetf(ios::dec); 卸载十进制
             *  cout.setf(ios::hex); 安装十六进制
             *  cout.setf(ios::showbase); 设置显示进制 基数
             *  cout.unsetf(ios::hex); 卸载十六进制
             *  cout.setf(ios::oct); 安装八进制
             *  cout << number << endl;
         *  使用控制符 头文件\#include
            
             *  int number = 99;
             *  cout << setw(20); 设置宽度
             *   << setfill("~") 填充
             *   << setiosflag(ios::showbase) 显示进制基数
             *   << setiosflag(ios::left) 设置左对齐
             *   << hex 安装十六进制
             *   << number
             *   << endl;
53. 文件读写操作
    
     *  读写头文件 \#include
     *  写 ofstream ofs
        
         *  ofs.open 指定打开方式 ios::out | ios::trunk
         *  判断是否打开成功 ofs.is\_open
         *  ofs << “aaa”;
         *  关闭流对象 ofs.close();
     *  读
        
         *  ifstream ifs
         *  指定打开方式 ios::in
         *  判断是否打开成功 is\_open
         *  三种方式 可以读文件中的数据
         *  关闭流对象 ifs.close();