C++ 复习笔记

C++ 对于C的提升目的 :为了解决更为复杂的编程任务.不为不使用特性牺牲任何代价

 

 代码 请参考本

    https://github.com/IncorYahoo/CPP

////////////////////////////////////////数据专题/////////////////////////////////////////////////

1. 赋值 C++ 11 标准 允许 int  m  { } ;
2. 初始化2种方式 
1. = 执行的是copy,数值来源于 已经存在的右值
2.  () 执行的是一个初始化,分配一块空间 进行赋值运算
3.  cout.put()  历史存留问题 ,在 release 2.0版本时候,储存的是int 类型 ,  char 不能正常输出,所以保留这个成员函数
4. endl 和 '\n' 区别 
1. endl 会有一个fflush 操作 刷新缓冲区
5. C++ 11 新增类型 char16_t char32_t
1. 为什么会有这个玩意 ,因为Unicode 用多了以后发现wchar_t有点不能满足需求,多以出现的
2. 通常使用u'' U''
6. 基本数据类型 short int long char float double C 语言
7. 浮点数表示 X.XXEn E/e  E 10^n e 10^(-n)
8. 比较相等 相减 看差值 float 6 double 16 
9. char 一些坑坑 
1. {} 用它初始化 会进行类型检查,安全 
2.  ={} 会产生一个narrowing 的缩窄 warning 但是 不会errno 
3. 缩窄 是直接截取对应二进位大小
10. 类型转换 
1. 位数多的优先级> 位数小的
2. 无符号的 > 有符号的
11. auto 自动类型 全新改变C11 标准
1. auto 属于运行时 多态
2. 去&  const volatile 
3. auto & 就不会自动去除上面的
4. 数组 退化为指针 auto & 为 int [3]

//////////////////////////////////new delete array ///////////////////////////////////////////////////////////////////////////////////////

1. 静态联编 动态联编
1. 是否在编译时期就能确定大小
2. new 和 delete
1. delete [] 和delete 
1. 简单对象 int int *  都是一样的 不会产生内存泄露  因为有一个__CrtMemBlockHeader 结构体记录
2. 但是对于类对象 这种有只会调用第一个的析构函数
2. new malloc分配问题
1. 首先 new 是关键字可以被 重载 ,malloc 是函数
2. new 不可以自定义大小 ,是动态推导 失败返回 bac_alloc malloc 失败返回NULL
3. 内存区域 new 叫做自由存储区 ,malloc 是堆,操作系统上的概念
3. 运用 举个例子: stl 中的 vector 使用的是什么? 
1. malloc 为什么? 采用的是allocator 这个空间适配器,优点 为了完成一个OOP 思想高内聚低耦合, 免得调用构造函数
2. allocator  malloc有一个更好的地方,失败后会从其他地方oom_alloc 挤内存
3. array 数组 存在于栈区 和一般数组 区别 就是 我可以动态 但是 我是固定的,我懒得用 delete 
4. 怕不是刷新了人生观世界观价值观的一条
1. c/c++ if(a =b) 返回的都是 a 的值
5. 逗号表达式  
1. a,b 返回 右值 
2. t = a,b         =优先级> , 
3. int t = a,b; 你猜猜 什么错误 int 不能初始化 一个常量

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

1. 输出流 cout 默认将 bool 抓化 int
1. cout.setf(ios::boolalpha)  转回bool   
2. isalnum 是不是字母或数字
3. isalpha 是不是字母
4. isdigit 是不是数字
5. isupper islower /toupper tolower
2. 函数返回值 不是具体结构 就是 地址 或者 void 
1. 习惯与 用 auto 去接,减少 bug 
3. const 
1. const int *   常量
2. int * const  常指针
4. 函数指针 
1. *p[3] 一个数组 都是指针
2. (*p)[3] 一个指针 指向的是数组
5. inline 
1. 内联函数 执行的是有检查的宏替换 ,关键点 节省函数压栈时间,但是耗费内存
6. 引用
1. 起别名 加速程序,减少copy时间 ,经常和const 一起使用
2. 返回值为引用的 返回的是非函数栈作用域 的变量
7.  ostream
1. 格式化流  ios_base :: fmtflags //流格式枚举
2. setf() 设置格式 showpoint 
3. width() 设置宽度
8. 重造流运算,ostream<< 和istream>>

///////////////////////////编译过程这个章节/////////////////////////////////////////////////////////////////////////////////////////////////////////////

1. 预处理 gcc -E  a.cpp -o a.i 
2. 编译 gcc -S a.i -o a.s     生成汇编文件
3.  汇编生成目标文件    gcc -c a.s -o a.o 
4. 链接生成执行文件   gcc a.o -o app

预处理阶段: 文本替换( #include #if #define 特殊符号 删除注释 )

编译阶段: 词法分析,语法分析,生成目标代码 汇编

汇编 将汇编代码翻译成机码指令 打包成可重定位的目标文件

链接 将库文件链接成打包可执行程序

        内联函数执行在编译阶段

        模板 在运行时才会知道是什么类型

 

 ///////////////////////////模板/////////////////////////////////////////////////////////////////////////////////////////////////////////////

1.     模板 显示具体化 会有优先排序 T T* 
2.    模板 a+b 产生类型不确定 
1. decltype(x+y)
2. typedef decltype(x+y) xytype;
3. 位于 返回值 时候 auto (T1 a ,T2 b) ->decltype(a+b)         // 怕不是假的C++ 
4. auto  add(T1 x,T2 y) ->decltype(forward<T1>(x)+forward<T2>(y))   //将 左值转化为 右值

 

存储连续性作用域来链接性

1. 自动存储 : 栈类型,自动回收
2. 静态存储 :程序生命周期
3. 线程存储; c11 thread_local
4. 自由存储区: new delete 

 

变量: 自动变量存储:

1. 函数栈使用/{}使用   :维护两个指针 从栈顶向栈底找:第一个名字相同变量:
2. 寄存器变量 ,register 寄存器 变量 ,c11 以后 怕是为了不修改 以前代码 而保留的
3. 静态变量 存储与静态全局区

extern 很恶心,其他的文件中找变量 ,那么就会出现一个问题,跨文件问题,所以用static 限定他找不到

 

说明符号 : auto register static extern thread_local mutable 

限定符号: const volatile ,取消编译器优化,每次都从内存中取数据,临界资源时候使用

mutable ,BUG , 当一个const 结构体 中有一个这个修饰的变量 ,将可以被修改

new BUG ,可以使用重新定位 分配地址

 

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

命名空间:  声明区 潜在作用域 ,作用域

1.  声明区  : 声明 的到 下个 {}
2. 潜在作用域 : 可用地方整体
3. 作用域  潜在作用于  减去 { 内声明了 一样的变量 }
4. 命名空间: 使用命名空间 替代 外部全局变量,和 静态全局变量  

      

类

1.  存在意义: 
1. 为了解决逻辑关系 更为复杂问题,
2. 为了让给外界用户只能使用公共ADT         
2. ADT 抽象数据类型 ,即用 一组数据便是一个概念
1. 但是传统ADT ,只能做到 封装和 抽象
3. 友元

1. 友元 函数
2. 友元类
3. 有元成员函数
1. 重载类 一定要
1. copy 构造函数一定要传递 const & ,防止二次拷贝
2. 参数传递 如果 不传递 引用 ,会产生 构造,就很浪费资源
3. 不修改函数内部元素的变量 内部函数const 
2. 继承
1.  public  is-a 关系 ,注意访问访问 父类中的protected 成员 正是因为继承才存在的
2. private /[rotected    根据什么实现的
3. 子类一定能访问父类的 protected 
3.  限定符号    继承概念 
1. public 公共的 such 业务 
2. private 自己和朋友的
3. protected 房子  自己 朋友 儿子
4. public 延续传统
5. protected publiuc 变成 protected 
6. pricate public proteced   变成 自己的
4. 静态联编 动态 联编
1. 静态是在编译阶段就知道怎么处理
2. 动态必须在运行时后才知道
3. 为什么 还需要 静 ,因为效率问题 
4. 虚函数表 ,编译器创建虚函数地址表,
1. 当调用时候查看虚函数表
2. 每个类实例化时候会有虚函数指针
3. 当虚函数被重载时,产生的不是虚函数
4. 当虚函数被重写时,使用的是新函数地址
5. 创建时候会知道是那个虚函数表,按照实际类型得知
6. 一定被重写 override 否则报错
5. ABC abstract base class 抽象基类
1. 至少有一个纯虚函数,继承中一定要实现的
2. 全部是纯虚的叫做接口
6. 继承的动态内存分配技巧
1. 派生类中不适用new 
1. 析构函数,copy构造,重载 = 都不需要
2. 派生类使用new 
1. 显示定义构造析构,cop构造函数,赋值运算
2. 基类的赋值运算 在子类中手动i调用 
3. 流程: 父构造 子构造 /////////父copy 子 copy  别乱理解
7. C++ 默认会生成 默认构造函数 ,析构函数,copy 构造 但是是 浅copy 
1. 注意一点 such as  = const char * // 转换为 A(const char * ) 然后调用 operator = 
2. 需要声明关键字 explicit  主能显示类型转换 ,不能隐式类型转换
8. 私有继承 会把 public 函数 变成 private 如果想要使用 这个函数 ,需使用 using 关键字
9. 虚继承:多继承 A ->B  A->C D-> B+C
1. A virtual B,A virtua C 
10. 继承大小问题 
1. 空类 1 
2. 有东西 东西大小
3. 继承 相加
4. 有虚函数
5. 内部变量大小 + 虚函数指针 ,
6. 虚继承 蜕变偏移量
7. 虚继承之后的多继承 但指针蜕变成偏移量
11. 模板问题 别名问题 
1. 使用  using aa  = int ;
2. 模板中友元不建议使用模板类型
1. 前置声明 属于约束模板 前置声明 友元函数 ,类内部 使用 了该类对象的话就
1. friend void report<>(A<T>& );
2. 非约束 模板 就是 模板套模板 
12. throw 错误处理 try catch 
1. viud func () throw ()
2. void func() trhow (bad_thing)
3. noexcept  没有异常抛出 C11 标准
13. 四个cast dynamic_cast 动态类型转换
1. const_cast 去除const
2. static_cast 有关系之间转换
3. reinterprete_cast 指针转换
14. lamdba 匿名函数
1. such as count_if (a.begin(),a.end(),[](int x){return x%3==0});
2. [&] 使用 外部变量
3. [=] 使用新变量
15. 元模板template<typename... Arg>