【学习笔记】C与C++复习笔记

柔光的暖阳◎ 2023-07-07 14:00 11阅读 0赞

# 程序语言回炉重造笔记 #

## C 与 C++ ##

### 2020/2/8 ###

*  `scanf(),printf()`格式化输入输出问题
    
     *  除了 `%c` 以外的格式说明符会自动跳过输入项之前的空白字符（**空白字符包括：回车，空格，制表符**），所以 `scanf("%d%d", &m, &n)` 和 `scanf("%d %d", &m, &n)` 的行为是相同的，而与 `scanf("%d, %d", &m, &n)` 和 `scanf("%d,%d", &m, &n)` 两者不同，后两者要求第一个整数后必须紧接一个逗号`","`, 从而与要求的输入格式相符合、
     *  对于 `%c` 而言，在其前添加一个空格，将会使得`scanf()`的输入跳到第一个非空白字符处，因此 `scanf(" %c", &c)`会读取缓冲区的第一个非空白字符，而`scanf("%c", &c)` 会读取缓冲区的第一个字符
     *  `scanf()` 使用空格（换行，制表符和空格）来决定怎样把输入分成几个字段。它依次把转换说明与字段相匹配，并跳过他们之间的空白符。
     *  其实关键就是把握：**格式说明符** 和 **空格** 这两个东西在输入格式中起到什么样的作用。
     *  格式化字符串里的空白符（制表符，换行符，回车符和换页符）起匹配字符串作用，进行匹配的时候，他会一直匹配到下一个非空字符的出现才停止
        
         *  例如，`scanf(“%d\n”,&a)`，在console输入12程序并不会往下执行，而是等待console继续输入`.\n`后面会一直等待下一个非空白字符串出现才会接着执行

### 2020/2/9 ###

*  `scanf`,`gets`,`getchar`的区别
    
     *  三者都是从标准输入流stdio (标准输入设备，一般指向键盘)中读取内容。
     *  1.`scanf`输入字符串的时候不会接收Space空格，回车Enter，Tab键，则认为输入结束。
     *  2.`gets`能接收空格键，回车键，Tab键，回车则认为输入结束
     *  3.`getchar`只能接受一个字符，遇到回车结束输入，可接受回车键。常用来吸收回车符。
 *  三者关于 字符串末端空白符 的问题
    
     *  1.`scanf()`函数使用`%c`，`%s`，空格键，Tab键，回车键结束一次输入，不会舍弃最后的回车符或空格或Tab（即还在缓冲区中），可使用`getchar`来吸收`scanf()`执行之后的换行符
     *  2.`getchar()`以回车键结束，也不会舍弃回车符（即存入缓冲区）
     *  3.`gets()`以换行符结束，但之后会舍弃换行符并以`'\0'`,代替(意思是`'\n'`不会被代入到字符数组中，也不会将换换行符存入到缓存区)也就是说：`gets()`函数读取到`\n`（我们输入的回车）于是停止读取，但是它不会把`\n`包含到字符串里面去。然而，和它配合使用的`puts`函数，却在输出字符串的时候自动换行
 *  文件的书写方法
    
     *  利用 **重定向**：
        
            freopen("data.in", "r", stdin);
            	freopen("data.out", "w", stdout);
     *  利用 **文件打开与关闭**：
        
            FILE *fin, *fout;
            	fin = fopen("data.in", "rb");
            	fout = fopen("data.out", "wb");
            	while( fscanf(fin, "%d", &x) == 1){ 
                    ...
                }
            	fprintf(fout, "%d", result);
            	fclose(fin);
            	fclose(fout);
            // 若想要把fopen版本的程序改写成读写标准输入输出
            // 只需要 fin = stdin; fout = stdout; 即可
 *  嵌套的两个代码块中有同名变量时，内部的变量会屏蔽外层变量。
 *  文件读写 与 标准io 的对应函数
    
    <table> 
     <thead> 
      <tr> 
       <th>文件读写</th> 
       <th>标准IO</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>fgetc(stdin)</td> 
       <td>getchar()</td> 
      </tr> 
      <tr> 
       <td>fgets(buf, maxn, fin)</td> 
       <td>gets()</td> 
      </tr> 
     </tbody> 
    </table>
 *  不同系统的 **回车** **换行** **符** 符号不同
    
     *  WINDOWS: `"\r\n"`
     *  LINUX: `"\n"`
     *  MacOS: `"\r"`
 *  少用`gets()`函数，其不禁止程序读写 非法内存，并且在 **C11** 标准中已经被删除
    
     *  `strcpy()`也有类似问题
 *  EOF 是一个 int 类型的数
 *  善用 **常量数组 + 查询** 算法
 *  在进行浮点数比较时，应考虑浮点误差
    
     *  常常采用 `floor( x + 0.5)` 四舍五入的写法从而减小误差的影响
 *  `ctype.h`文件中，
    
     *  有各种用于判断数据类型的函数 例如 `isalpha(), isprint(), isdigit()`
     *  `toupper(), tolower`等工具可以用来转换大小写
 *  一些经典 **实现思想**
    
     *  反复枚举之王：全范围枚举 + 查表
     *  边输入，边解题（如：统计）
     *  环形/循环数组 下标 **取模**
 *  时间观察：使用 `time.h` 和 `clock()/CLOCKS_PER_SEC` 来观察时间
 *  在算法竞赛中，有经验的选手往往会使用条件编译指令（例如下），并且将重要的测试语句注释掉，而并非删除
    
        #define LOCAL
        	int main{ 
                #ifdef LOCAL
                	freopen("data.in", "r", stdin);
                #endif
                ...
            }

### 2020/2/10 ###

*  C++的数据类型包括：**基本内置类型** \+ **抽象数据类型**
 *  命名空间的 `using`声明
    
     *  每个名字都需要独立的 `using`声明
     *  头文件不能包含 `using`声明
 *      using int_array = int[4];//新标准，声明类型别名
         	typedef int int_array[4];//等价的typedef声明 
         	//特别例子，仅在范围for中标注外层操作对象时使用
 *  标准库 有很多头文件，各个头文件的 变量命名 都在 `std`命名空间中
 *  `string`类型的初始化
    
     *  拷贝初始化 用`=`
     *  直接初始化 用`()`
 *  `cin >> s` 中 `string`对象会自动忽略输入开头的空白符，并从第一个真正的字符开始读取，直到遇见下一处空白符，并且会加上换行符（吗？）
 *  **【疑惑未确认】**：不清楚是在输出时自动换行，还是在输入时末尾增加一个换行符
 *  `while ( cin >> word )` 表示 如果没有遇到文件结束标记 或者 非法输入 ，执行循环内容
 *  `string`对象的 `size()` 方法返回的是一个 **无符号**整型数 ，其数据类型为 `string::size_type`
    
     *  字符串下标 可以用 `decltype(s.size()) index = 0;`
     *  总是定义 输入的下标数字 类型为 `string::size_type`可以首先保证该数 为正，然后只需要考虑该数 `< size()`
 *  \*\*注意：\*\*字符串字面值`"c++"`，字符字面值`'c'`，`string`类型，三者是不同的数据类型
    
     *  字符串字面值的类型 实际上是 常量字符组成的数组`array`，编译器会在每一个字符串的结尾处添加一个`\0`，因此长度会+1
     *  三者可以进行混合加法（拼接）运算，因为`c++`允许 字符串字面值 和 字符字面值 转换为 `string`类型，但是必须保证每个加号的运算对象至少有一个是`string`类型
 *  斜杠\\ 和 反斜杠/
    
     *  斜杠在键盘上远一点
 *  c 与 c++ 头文件
    
     *  c 使用 name.h , c++ 使用 cname
     *  头文件内容一致，但更符合规范，并且 cname 中名字已经被 std 中包含 而 name.h 中没有
 *  遍历（但无法改变）字符串
    
        for (auto c : s){ 
            if (ispunct(c)){
                num ++;
            }
        }
 *  遍历（且能改变）字符串：关键在使用了**引用**
    
        for (auto &c : s){ //注意用了auto
            if (isalpha(c)){
                c = std::toupper(c);
            }
        }
 *  `vector`表示对象的集合，其中所有的对象类型都相同

### 2020/2/11 ###

*  `vector`对象的大小的数据类型应加上填充的数据类型，例如 `vector<int>::size_type`
 *  `vector`初始化的方式
    
        vector<T> ivec; //默认初始化
        	vector<T> ivec2(ivec); //拷贝初始化
        	vector<T> ivec2 = ivec; //拷贝初始化
        	vector<T> ivec3(n, val); //直接初始化为 n个val
        	vector<T> ivec4(n); //包含了N个重复执行了值初始化的对象
        	vector<T> ivec5{a,b,c...}; //初始值的个数+各自初始值
        	vector<T> ivec5 = {a,b,c...} //同上
 *  注意事项
    
     *  范围`for`语句不用管改变其遍历序列的大小
     *  不能用下标形式添加元素，只能对确知已存在的运输执行下标操作
 *  建议把谓词（用来判断某事物是否具有某种特性的函数）命名成 “is\_xxx” 的形式
 *  调用栈 描述的是 函数之间的调用关系。它由多个 栈帧 组成，每个栈帧对应着一个未运行完的函数，其中保存了该函数的返回地址和局部变量。
 *  GNU工具链里面包括很多工具：![GNU开发工具及作用][GNU]
 *  `gcc`的使用命令格式 `gcc [选项 | 文件名]`
    
     *  非常好的博客：https://blog.csdn.net/asd451006071/article/details/40105731
 *  把数组作为参数传递给函数的时候，实际上只有数组的首地址作为指针传递给了函数
    
     *  `int a[]`等价于`int *a`
     *  正确的做法应该加一个参数，数组的元素个数

### 2020/2/22 ###

*  上课笔记：
    
     *  面向对象 与 面向过程 的区别
     *  面向对象技术三大特征：**封装 + 继承 + 多态**
        
         *  封装 指 将数据实体与行为封装起来
         *  继承 指 特殊类可以基于基类进行建立
         *  多态 指 继承后的特殊类可以有更多的数据实体与行为方法
     *  函数调用 会导致： 时间与空间上的开销 + 效率降低，可以通过使用 `inline`内联函数来进行解决
     *  默认形参值
        
         *  注意顺序，从左向右（与`python`相同）
         *  在不同作用域中，允许拥有不同的形参默认值
     *  函数重载
        
         *  不同函数使用相同函数名进行声明，从而方便记忆，称为**重载**
         *  通过 形参的 **类型** 或者 **数量** 进行辨别，因此重载函数的 **形参列表** 必须不同
         *  不要将不同功能的函数声明 作为 **重载函数**
     *  多利用系统函数

### 2020/2/23 ###

*  关于类
    
     *  成员函数的声明必须在类的内部，它的定义既可以在类的内部也可以在类的外部，但定义在类内部的成员函数是隐式的内联`inline`函数，在类外部定义的成员的名字必须包含它所属的类名
     *  成员函数通过一个名为`this`的额外的隐式参数来访问调用它的那个对象，当我们使用点运算符替某个对象调用其成员函数时（例如`bookNo.isbn()`），编译器会将 `bookNo`的地址传递给 `isbn()`的隐式形参`this`
     *  尽管没有必要，但我们可以将 `isbn()`定义成
        
            std::string isbn() const { return this->bookNo; }
        
        可以看出 `this` 是一个常量指针
     *  上面例子中，`const`作用是修改隐式指针的类型，因为 `this` 默认情况下是指向非常量的常量指针。通过将其修改为底层`const`，该成员函数可以读取调用它的对象的数据成员，但不能写入新值。
     *  不需要在意成员在类的定义中出现的次序
     *  非成员函数但是与类有关的辅助接口函数，一般与类 **声明** 于同一个头文件中
     *  无论何时只要类的对象被创造，就会执行**构造函数**，而构造函数不能被声明成 `const`，其名字与类名相同
        
         *  类通过一个特殊的构造函数——**默认构造函数** 来控制默认初始化过程，其不需要任何实参
         *  编译器创建的构造函数被称为 **合成的默认构造函数** ，它将执行：
            
             *  如果存在类内的初始化值，用它来初始化成员
             *  否则，默认初始化
         *  我们需要定义自己的默认构造函数
            
             *  只有当类没有生命任何构造函数时，编译器才会自动地生成默认构造函数
             *  块内进行默认初始化的内置类型或复合类型成员将不被初始化，也即，如果类包含有内置类型或者复合类型的成员，只有当他们全都被赋予了类内初始值后，这个类才适合用 合成的默认构造函数
             *  有时编译器不能为某些类 合成默认的构造函数
         *      Sales_data() = default;//1、要求编译器生成构造函数，default可以出现在类内或类外 	Sales_data(const std::string &s, unsigned n, double p): 		bookNo(s), units_sold(n), revenue(p*n) {} //2、使用构造函数初始值列表 	Sales_data(std::istream &);  	//类外 	Sales_data::Sales_data(std::istream &is)   {       read(is, *this); //3、使用构造函数的函数体的内容进行构造   }
         *  构造函数没有返回类型
         *  封装的优点
            
             *  确保用户代码不会无意间破坏封装对象的状态
             *  被封装的内的具体实现细节可以随时改变，而无需调整用户级别的代码
     *  令其他类或者函数成为 类的 **友元**，可以允许其访问它的非公有成员
        
         *      friend + 函数声明
         *  友元的声明仅仅指定了访问的权限，并非対函数的声明；因此仍然需要 一次类外的声明 + 函数的定义
 *  至今接触过的初始化方式
    
     *  拷贝初始化：使用赋值运算符
     *  直接初始化 / 值初始化：使用圆括号，可用于进行构造
     *  列表初始化：可用于多个初始元素值，也可以用于构造
     *  默认初始化：不赋值
 *  迭代器1
    
     *  可以通过 **下标运算符** 或 **迭代器** 来访问`string`对象的字符或`vector`对象的元素。所有标准库容器都可以使用迭代器，但其中只有少数几种同时支持下标运算符。
     *  所有标准库容器的迭代器都定义了 `==`和`!=` ，但是它们中的大多数都没有定义`>`运算符，因此尽量养成使用迭代器和`!=`的习惯
        
         *  拥有迭代器的标准库类型使用 `iterator`和`const_iterator` 来表示迭代器的类型，同时对于专门得到`const_iterator`类型的返回值，c++11有新函数：`cbegin()`和`cend()`
 *  QuesList
    
     *  P233
     *  程序最后都会自动输出一个`'\n'`（个人凭经验判断似乎是 缓存区刷新符号 `endl` 刷出来的）

### 2020/2/24 ###

*  乐学平台上的c++环境不支持
    
     *  类内初始值
     *  default关键字来要求系统合成默认构造函数
 *  迭代器2
    
     *  箭头运算符 将 **解引用 和 成员访问** 两个操作结合在一起
     *  注意某些対 `vector`对象的操作会使迭代器失效
        
         *  任意可能改变 `vector`对象容量的操作，都会使该 `vector`对象的迭代器失效
         *  不能在 范围`for`循环 中改变 `vector` 长度
     *  只要两个迭代器指向同一个容器中的元素或者尾元素的下一位置，就能将其相减，得到**距离**（右侧迭代器向前移动多少位置就能追上左侧的迭代器），其类型是 `difference_type`的带符号整型数
     *  关于 **迭代器与指针的区别** 的好博客
        
        [https://blog.csdn.net/m0\_37925202/article/details/82927656?ops\_request\_misc=%7B%22request%5Fid%22%3A%22158253045119724835827597%22%2C%22scm%22%3A%2220140713.130056874…%22%7D&request\_id=158253045119724835827597&biz\_id=0&utm\_source=distribute.pc\_search\_result.none-task][https_blog.csdn.net_m0_37925202_article_details_82927656_ops_request_misc_7B_22request_5Fid_22_3A_22158253045119724835827597_22_2C_22scm_22_3A_2220140713.130056874_22_7D_request_id_158253045119724835827597_biz_id_0_utm_source_distribute.pc_search_result.none-task]
 *  数组
    
     *  也是存放相同类型的对象的容器，但大小固定
     *  定义数组时，**维度** 必须是一个常量或常量表达式（且大于0），默认情况下数组的元素被默认初始化。
     *  显式初始化数组元素，注意 **不支持拷贝初始化**
        
            const unsigned sz = 3;	int ial[sz] = {0,1,2};	int a2[] = {0,1,2};	int a3[] = {0,1,2}; //其他元素默认初始化（块外则为0）	string a4[3] = {"hi", "bye"}; //{"hi", "bye"， ""}	char a1[] = {'C','+','+','\0'};	char a1[] = "C++";//注意空字符问题
     *  默认情况下，**类型修饰符从右往左依次绑定**，理解数组声明的含义：**从数组的名字开始，按照从内向外的顺序阅读**
        
            int (*Parray)[10] = &arr;//Parry指向一个含有10个整数的数组	int *ptrs[10];//数组成员是整型数据的指针	int (&arrRef)[10] = arr;//arrRef引用一个含有10个整数的数组	int &refs[10];//数组成员是整型数据的引用关键词：指针数组 和 数组指针 的区别    int* arr[8];//优先级问题：[]的优先级比*高	//说明arr是一个数组，而int*是数组里面的内容//这句话的意思就是：arr是一个含有8和int*的数组int (*arr)[8];	//由于[]的优先级比*高，因此在写数组指针的时候必须将*arr用括号括起来	//arr先和*结合，说明p是一个指针变量	//这句话的意思就是：指针arr指向一个大小为8个整型的数组。
     *  可以通过 `for`语句 或 下标运算符 来访问数组元素
     *  数组下标数据类型为 `size_t`
     *  c++11中，在头文件`iterator`中，提供了两个标准库函数`begin()` 和`end()`，用于返回指向数组首元素的指针和尾后元素的指针。
     *  **很多时候，使用数组的时候 编译器都会将他转化成 指针**

### 2020/2/25 ###

*  **上课笔记**
    
     *  C++中，让参数列表空着 等价于 `void`
     *  `const` 和 宏定义 来定义常量，选择前者
        
         *  `const`常量有数据类型 宏定义没有数据类型；编译器可以对前者进行类型安全检查，对后者只是进行类型替换而已，没有类型安全检查，并且在替换的时候可能会发生意想不到的错误
         *  有些集成化的调试工具可以对 `const` 常量进行调试，但是不能对宏定义进行调试，因为编译器对宏只是进行字符替换
     *  养成写函数原型的习惯
 *  利用好`const`
 *  指针
    
     *  c++11中，在头文件`iterator`中，提供了两个标准库函数`begin()` 和`end()`，用于返回指向数组首元素的指针和尾后元素的指针。
     *  注意，尾后指针 **不能执行解引用和递增操作**
     *  指针范围不能超过尾后元素
     *  两个指针相减的结果的类型是 一种名为`ptrdiff_t`的标准库类型，定义在`cstddef`头文件中与机器相关的类型 (同`size_t`)。因为差值可能为负值，因此其为有符号类型。
     *  如果两个指针指向不相关的对象，不能比较它们
     *  空指针允许彼此相减，结果为0，并且允许p加上或减去一个值为0的整型常量表达式
     *  标准库类型限定使用的下标必须是无符号类型，而内置的下标运算无此要求（可以是负数哦）
 *  C 风格字符串
    
     *  不是一种类型，而是C为了表达和使用字符串而形成的一种约定俗称的写法
     *  习惯于：将字符串存放在字符数组并以空字符`\0`结束，一般用指针进行操作
     *  `cstring`是 c语言头文件`string.h`的c++版本，包含一些対c风格字符串的操作函数如
        
         *  `strlen(p)`, `strcmp(p1,p2)`, `strcat(p1,p2)`, `strcpy(p1,p2)`
     *      string s1 = "hell";   string s2 = "hello"; 	int a = s1 < s2;//可以，比较字典序 	 	const char ca1[] = "hell"; 	const char ca2[] = "hello"; 	int b = ca1 < ca2;//不可以这样进行対两个无关的指针的比较
     *  対大多数应用来说，使用标准库`string`要比使用c风格字符串更安全高效
     *  c++提供了与c风格字符串的接口
        
         *  允许使用 **以空字符结束的字符数组** 来初始化`string`对象或为 `string` 对象赋值
         *  在`string`对象的加法运算中允许使用**以空字符结束的字符数**组作为其中一个运算对象，但不能两个都是。在 `string`对象的复合赋值运算中，允许使用 **以空字符结束的字符数组** 作为右侧的运算对象
         *  任何出现字符串字面值的地方都可以用 **以空字符结束的字符数组** 来替代
         *  反过来，
            
                char *str = s.c_str();
 *  不能用`vecotr`或数组初始化数组，但可以使用数组初始化 `vector` 对象
    
        int arr[] = {0,1,2};	vector<int> ivec(begin(arr), end(arr)); //其实不一定要begin和end,也可能仅仅是其中一部分	vector<int> ivec( arr + 1, arr + 2 );
 *  尽量使用 标准库类型 而非 数组
 *  类
    
     *  `inline`最好只在类外部定义的地方说明`inline`，可以使得类更加容易理解
     *  成员函数也可以重载
     *  **可变数据成员**：
        
         *  希望能在`const`成员函数类内修改类的某个数据成员
         *  永远不会是`const`,即使它是`const`对象的成员
         *  使用关键字`mutable`
     *  类内初始化必须使用 符号= 或者 花括号
        
            std::vector<Screen> screens{Screen(24,80,' ')}
     *  返回 \*this 的成员函数
        
            inline Screen &Screen::set(char ch);	//可以连续调用，不过要注意返回的得是引用Screen&，而不能是Screen，否则返回的是*this的副本而不是*this本身	//并且要注意 从const成员函数返回*this时，返回的是一个常量引用	myScreen.move(4,0).set('#');
        
        观察成员函数是否为const类型（即 this 是否为底层const），若为const，则返回的 \*this 是一个常量引用，否则则是一个普通的非常量引用，而在 this指针的传递过程中，其 是否为const的属性 可能被修改，例如 从非常量转化为常量 ???暂不清楚是否能从常量转化为非常量
     *  **很nb的建议：对于公共代码使用私有功能函数**
        
         *  避免在多出使用相同的代码
         *  内联函数不存在额外开销
         *  方便同时修改多处，例如函数内容以及调试信息输出输入
     *  类的声明
        
         *  可以声明 暂不定义，称为 **前向声明**，如此声明后 **不完全类型**，仅仅可以 定义其指针或引用，或者作为函数的返回或者形参类型
         *  直到类被定义后，数据成员才能被声明为这种类型
     *  友元
        
         *  可以声明类之间的友元关系 `friend class A`，但类之间的友元关系不具有传递性
         *  重载函数 需要逐个声明为友元
         *  即使可以在类的内部定义友元函数，但是必须理解 **友元的作用：是影响访问权限，并非普通意义上的声明**， 因此在类的外部，还需要做一次正常的声明来使得对应函数可见
     *  作用域
        
         *  在类的作用域之外，普通的数据和函数成员只能由对象、引用或者指针使用成员访问运算符来访问
         *  一个类就是一个作用域
         *  在类的外部，成员的名字被隐藏起来了，所以无法访问
         *  一旦遇到了类名，定义的剩余部分就在类的作用域之类了。因此可以直接使用类的其他成员而无需再次授权
            
             *  **编译器处理完类中的全部声明之后，才会处理成员函数的定义**，因此可以在其中使用类中定义的任何名字
             *  类先编译成员的声明，直到类全部可见之后，才编译函数体
             *  但对于声明，就必须保证现在有的所有声明都是在使用前确保可见的
         *  内层不能重新定义外层已有的类型名
         *  一般来说，不推荐使用其他成员的名字作为某个成员函数的参数
         *  成员函数中的普通作用域的名字查找
            
             *  先在函数所在的作用域中查找——只有在函数使用之前出现的声明才被考虑
             *  然后到类内查找 成员
             *  然后到更外层的作用域中查找 相当于 `::parameter`
     *  构造函数进阶
        
         *  利用初始值列表
         *  初始化的顺序 与 它们类定义中的出现顺序 一致，因此 最好令构造函数初始值的孙秀与成员声明的顺序保持一致
         *  如果一个构造函数为所有参数都提供了默认参数，则它实际上也定义了默认构造函数
         *  **委托构造函数**
            
             *  使用它所属类的其他构造函数执行它自己的初始化过程，或者它把自己的一些职责或者全部职责 委托给了其他函数
             *      public:    Person(int age,float height)    {        m_age=age;        m_height=height;    }     Person():Person(18,176){}//此种就是一种委托构造函数    Person(int age):Person(age,176){}//此种也是委托构造函数
             *  执行顺序：被委托的函数初始化列表  → \\to → 被委托的函数体  → \\to → 最初调用的函数体
         *  转换构造函数
            
             *  如果构造函数只接受一个市场，则它实际上定义了转换为此类类型的隐式转换机制，我们称之为 **转换构造函数**
             *  可以在构造函数前声明为 `explicit` ，从而阻止隐式转换 —— 这只对一个实参的构造函数有效，因为只有仅有一个实参的函数可以进行隐式转换
             *  一种是，**其实本质上就只是利用了，实参转换为转换构造函数的可传入的形参而已，然后因为是构造函数的形参，会被拿来构造，所以看起来就像是实参转换为了构造对象**
             *  注意，拷贝初始化可能也会发生 隐式转换，所以得用直接初始化
                
                    Sales_data item1(null_book); // OJBK	Sales_data item2 = nullbook; // 不行，已经explicit声明，不能隐式转换
             *  另外一种是 在非构造函数的成员函数中使用 需要输入该类类型的对象，但是采用别的类型输入，然后转换为该类类型 (**一般都是指这一种**)
                
                    null_book = "9-9999";	item.combine(null_book); // 隐式转换	item.combine(Sales_data(null_book)); //等价的 显式强制转换
     *  默认构造函数的调用
        
            Sales_data obj(); // 这定义的是一个函数	Sales_data obj; // 这是调用默认构造函数来定义对象
     *  聚合类(aggregate class)使用户可以直接访问其成员，并且具有特殊的初始化语法。
        
         *  当一个类满足以下条件时，我们说它是聚合的：
            
             *  所有成员都是public
             *  没有定义构造函数
             *  没有类内初始值
             *  没有基类，也没有虚函数
         *  聚合类可以使用 \{ a,b,c \} 的方式进行赋值
     *  数据成员都是字面值类型的聚合类是**字面值常量类**。如果一个类不是聚合类，但它符合以下要求，则它也是一个字面值常量类：
        
         *  数据成员都必须是字面值类型(算术类型，引用和指针，以及字面值常量类)。
         *  类必须至少含有一个constexpr构造函数。
         *  如果一个数据成员含有类内初始值，则内置类型的初始值必须是一条常量表达式。或者如果成员属性某种类类型，则初始值必须使用成员自己的constexpr构造函数。
         *  类必须使用析构函数的默认定义，该成员负责销毁类的对象。
         *  由于constexpr构造函数要满足构造函数的要求所以不能有返回语句，又要满足constexpr函数的要求唯一可执行的语句就是返回语句，所以constexpr构造函数体只能是空的。
     *  类的静态
        
         *  有时候类需要它的一些成员**与类本身直接相关**，而不是与类的各个对象保持关联
         *  声明静态成员：我们通过在成员的声明前加上关键字static使其与类关联在一起
            
             *  不能重复 static 关键字，它只能出现在类内部的声明语句
             *  因为静态数据成员不属于类的任何一个对象，所以它们并不是在创建类的对象时，被定义的
             *  必须在类的外部定义和初始化每一个静态成员
             *  要想确保对象只定义一次，最好的办法是**把静态数据成员的定义与其他非内联函数的定义放在同一个文件中**
         *  类的对象中不包含任何与静态数据成员相关的数据
         *  静态成员函数也不予任何对象绑定在一起，不包含this指针——因此不嗯呢该被声明为const且我们也不能在其中使用this指针
         *  一定条件下，可以提供类内初始化：若静态成员为 字面值常量类型的constexpr时，可以提供 const 整数类型的类内初始值
         *  静态成员可以用于一些奇奇妙妙的 普通成员非法的 场景
            
             *  可以不完全
             *  可以作为默认实参
 *  拷贝控制 —— 第十三章节
    
     *  定义一个类的时候，我们显式或者隐式地指定在此类型的对象 **拷贝、移动、赋值、销毁**时做什么
     *  定义五种特殊的成员函数来控制这些操作
        
         *  拷贝构造函数
         *  拷贝赋值运算符
         *  移动构造函数
         *  移动赋值运算符
         *  析构函数
         *  （如果我们不定义这些操作，编译器也会为我们定义，但编译器定义的版本的行为可能并非我们所想）
     *  拷贝构造函数：第一个参数必须是自身类型的引用，而且任何额外参数都有默认值
        
         *  第一个参数几乎总是一个`const`的引用 【???】
         *  如果没有定义，编译器会自动为我们定义一个 **合成拷贝构造函数**
            
             *  对于某些类， **合成拷贝构造函数**会阻止我们拷贝该类类型的对象
             *  一般情况，合成的构造函数会将给定对象中的每个 **非static** 成员拷贝到正在创建的对象中
         *  直接初始化 与 拷贝初始化 之间的差异
            
             *  拷贝构造是 提供 拷贝的对象
             *  直接初始化这其实是使用 普通的函数匹配 来选择我们提供的参数 最匹配的构造函数
         *  拷贝初始化发生的时机
            
             *  **用 = 定义变量**
             *  将一个对象作为实参传递给一个非引用类型的形参
             *  从一个返回类型为非引用类型的函数返回一个对象
             *  用花括号列表初始化一个数组中的元素或一个聚合类中的成员
         *  注意：使用 圆括号() 是进行 直接初始化
         *  可以绕过 拷贝构造函数 使用圆括号的 直接初始化
         *  疑惑： P442
     *  拷贝赋值运算符
        
         *      Foo& operator=(const Foo&); // 赋值运算符
            
            与处理拷贝构造函数一样，如果一个类未定义自己的拷贝赋值运算符，编译器会为它生成一个 **合成拷贝赋值运算符**
            
            拷贝赋值运算符 的使用目的：将右侧运算对象的每个非 `static` 成员赋予左侧运算对象的对应成员。
            
            运算返回的对象为 左侧对象的引用
     *  析构函数
        
        构造函数初始化对象的 非static数据成员 ，拥有一个初始化部分和一个函数体；
        
        析构函数是反对向使用的资源，并销毁对象的非static数据成员，拥有一个函数体和一个析构部分；
        
        析构函数什么时候被调用？
        
         *  变量在离开其作用域时被销毁。
         *  当一个对象被销毁时，其成员被销毁。
         *  容易起被销毁时，其元素也被销毁。
         *  对于动态分配的对象，当对指向它的指针使用delete运算符时被销毁。
         *  对于临时对象，创建它的完整表达式结束时被销毁。
        
        当一个类未定义自己的构造函数时，编译器会为它定义一个 **合成析构函数**。除非它被用来阻止该类型的对象被销毁，否则 合成析构函数的函数体 就为空
        
        析构函数体并不直接销毁成员，成员是在析构函数体之后隐含的析构阶段中被销毁的。
     *  当我们决定一个类是否要定义自己版本的拷贝控制成员时，**一个基本原则是首先确定这个类是否需要一个构析函数。如果这个类需要一个构析函数，我们几乎可以肯定 它也需要一个拷贝构造函数和一个拷贝赋值运算符**
        
        **重要例子：合成构析函数不会delete一个指针数据成员，因此，此类需要定义一个构析函数来释放构造函数分配的内存**
        
            //函数定义	HasPtr f(HasPtr hp)    {        HasPtr ret = hp;        return ret;    } // 在函数返回时， hp 和 ret 都被销毁，都会调用构析函数，若构析函数函数体中delete了指针内存，则同一指针内存会被delete两次，是未定义的行为！
        
        **第二个基本原则：如果一个类需要一个拷贝构造函数，几乎可以肯定它也需要一个拷贝赋值运算符。反之亦然。**
        
        然而无论是需要拷贝构造函数还是需要拷贝赋值运算符，都不必然意味着构析函数
     *  可以使用 =default 来要求合成的版本，只能对 默认构造函数 或者 拷贝控制成员有效
     *  可以通过将拷贝构造函数和拷贝赋值运算符 定义为 **删除的函数** 来阻止拷贝。在函数的参数列表后面加上`=delete`来指出我们希望将它定义为删除的
        
        删除的函数是这样的 —— 我们虽然定义了他，但是不能以任何方式使用这个函数
        
        我们可以对任何函数指定 `=delete` ，可以用于 引导函数匹配
        
        析构函数不能是删除的成员。删除了构析函数的类型，我们无法创建对象，（尽管可以分配动态指针）也不能删除动态指针
     *  如果一个类有数据成员不能默认构造、拷贝、复制或销毁，则对应的成员函数将被定义为删除的。
        
        本质上，当不可能拷贝、赋值或销毁类的成员时，类的合成拷贝控制成员就被定义为删除的
        
        因此，如果一个类有`const`成员，则它不能使用合成的拷贝赋值运算符
     *

# 2020/2/26 #

*  范围`for`语句往往与`auto`关键字搭配
 *  多维数组
    
     *  c++11支持范围`for`语句
        
         *  要嵌套使用范围 `for`语句，除了最内层的循环外，其他所有的控制变量都应该是引用类型
         *  防止数组被转化为指针，指针无法使用范围for语句进行遍历
         *  有时可以声明为 対常量的引用`const &`，因为 `text`的元素是`string`对象，可能很大，声明为引用可以避免对元素的拷贝，又因为不需要対对象进行写抽中，所以将其声明为対常量的引用
     *      int ia[3][4] = {
                   {0},{0},{0}};//仅仅初始化每个一维数组的第一个元素 	int (&row)[4] = ia[1]; //
     *  **很多时候，使用数组的时候 编译器都会将他转化成 指针**
 *  一般来说，应该优先考虑标准库提供的类型，之后再考虑c++语言内置的低层的替代品数组或指针
 *  表达式
    
     *  运算对象，结果，表达式，运算符，要了解**优先级、结合律、求值顺序**
     *  c++中表达式只能是左值或者右值
        
         *  c语言中，左值可以在赋值语句的左边，右值不能
         *  当一个对象被用作右值的时候，用的是**对象的值（内容）**；当一个对象被用作左值的时候，用的是**对象的身份（在内存中的位置）**
         *  需要右值的地方可以用左值来代替，但是不能把右值当做左值使用
         *  取地址运算符生成右值
         *  `decltype`使用时，左值和右值也有所不同。
            
             *  `decltype (/*求值结果为左值的表达式*/)`返回得到一个应用类型
     *  对于那些没有执行顺序的运算符来说，如果表达式指向并修改了同一个对象，将会引发错误并产生未定义的行为
        
         *  4种明确规定运算对象求值顺序的运算符：`&&` `||` `?:` `,`
         *  `&&`先算左后算右
     *  溢出时，可能会发生 **环绕**现象：符号位本来是0，但由于溢出，被改成了1，结果变成一个负值
        
         *  例如，假设机器中short为16位，最大的short数值是32676，+1后输出为-32678
         *  除法中，如果两个运算对象符号相同则商为正，否则为负。C++早期版本允许负值的商向上或者向下取整，C++11新版本规定一切都向0取整，即直接切除小数部分
         *  新标准中，取余 m%n的正负和
     *  逻辑运算符号
        
         *  短路求值：先求左边的值再求右边的值（如果左边的值无法确定表达式的结果）
         *  所以要考虑使用 左侧的值来确保右侧条件求值时的**安全性**（例如下标与数组大小的关系）
         *  进行比较运算时，除非比较的对象是布尔类型，否则不要使用布尔字面值`true`和`false`作为运算对象
     *  赋值运算符
        
         *  返回的结果是其左侧的运算对象
         *  如果两侧的运算对象类型不同，则右侧对象将转化成左侧运算对象的类型
         *  满足 **右结合律**
     *  递增递减运算符
        
         *  分为 **前置**版本和 **后置**版本
         *  建议：除非必须，否则不适用递增递减运算符的后置版本
            
            原因：
            
             前置版本避免了不必要的工作，把值加1后直接返回了改变的运算对象。但是，后置版本需要将原始值存储下从而返回未修改的内容。如果我们不需要未修改的值，这样的操作就是一种浪费
         *  一种 常用的 简洁的 写法 —— 混用 解引用 和 递增运算符
            
                cout << *iter++ << endl;	//等价于	cout << *iter << enl;	++iter;	//注意：后置预算符号的优先级高于解引用运算符号
     *  成员访问运算符
        
         *  有两种：点运算符 和 箭头运算符
         *  箭头运算符 作用于 一个指针类型的对象时，结果为一个左值
         *  点运算符
            
             *  若作用的对象为左值，结果为左值
             *  若作用的对象为右值，结果为右值
     *  条件运算符
        
         *  精彩例子 **条件运算符号的嵌套**
            
                finalgrade  = (grade > 90) ? "high pass" : (grade < 60) ? "fail" : "pass";
         *  比较条件一定要加括号
     *  位运算符
        
         *  `bitset` 标准库类型 可以表示任意大小的二进制位集合
         *  关于符号位如何进行位运算，并没有明确的规定，依赖于平台，因此只应该対无符号数进行位运算
         *  所有位运算都会先保证 运算数据位数 至少为int，例如 会将 8位的`unsigned char`补上24位高位的0
            
             *  这个可能是因为 `a << 3` 中的3 为int字面值？其中发生了算术转换：元素符的运算对象将转换为最宽的类型
         *  常见的位操作
            
                quiz1 |= 1UL << 27; //置为1	quiz1 &= ~(1UL << 27); //置为0	quiz1 &= (1UL << 27); //取某位
     *  `sizeof`运算符
        
         *  并不实际对表达式求值
         *  即使是对 无效指针的解引用 sizeof(\*p) 也可以，因为并不求值，只判断类型
         *  对数组用sizeof得到整个数组的空间大小
         *  対string vector 用sizeof 只返回该类型固定部分的大小，不会计算对象中的元素占用了多少空间
         *      constexpr size_t sz = sizeof(ia)/sizeof(*ia);  	int arr2[sz];
     *  逗号运算符
        
         *  运行左边，再运算右边
         *  【疑惑】有什么用？
     *  类型转换
        
         *  两种类型可以 相互转换， 则它们 **相互关联**
         *  隐式转换：不需要程序员的了解和介入，被设计的得尽可能减少精度损失，因此通常将整型转化为浮点数
            
             *  隐式转换的一种类型：算术转换
                
                 *  整型提升：小的数变成大的数
                 *  无符号与有符号——比较复杂，并且不确定
                 *  最好的学习方法——P143的例子学习
             *  数组转化为指针
             *  转化为布尔类型
             *  转化为常量
             *  类类型定义的转化
             *  指针转化
         *  显式转换
            
             *  也称作 **强制类型转换**
             *  **命名的强制的类型转换** 格式是 cast-name （expression）
                
                 *  cast-name :
                    
                     *  static\_cast 地址不变的转换
                     *  const\_cast 去掉常量属性，只有它能做到
                        
                            const char *pc;	char *p = const_cast<char*>(pc);//只改变常量属性
                     *  reinterpret\_cast 提供低层次上的重新解释
 *  字面常量值
    
     *  前缀：u U L u8
     *  后缀：uU lL llLL fF lL
 *  解引用运算符 优先级 低于 点运算符
 *  【重要】待研究问题：**输入输出问题**——`cin`与`getline()`以及`cin.getline()`的区别
 *  **【重要】需要测试乐学环境**
    
     *  取余方向，除法取整方法（主要都是正负数问题）

### 2020/3/3 ###

*  **上课笔记**
    
     *  构造函数的类型
     *  不能把类中的全部成员与外界隔离，一般将数据隐藏private，成员函数作为接口public
     *  `protected`属性 只允许本类成员函数或者派生类成员函数访问，用于类的继承（子类可以访问父类的protected但不能访问private）
     *  对象的定义方法
        
         *  1、可以在定义类类型的同时对象
         *  2、先定义类类型，再定义对象
         *  3、不出现类名直接定义对象。定义类类型（但不需要说明类的名字）来定义对象
     *  成员函数
        
         *  成员函数的存储方式：公用的
         *  对象占用的存储空间只是对象数据成员占用的存储空间，可用`sizeof()`函数验证
     *  构造函数
        
         *  不能被继承
         *  默认值：
            
             *  应该在声明构造函数时制定参数的默认值，而不能只在定义构造函数时制定默认值
             *  在一个类中定义了全部默认参数的构造函数后，不能再定义重载构造函数，否则会出现二义性
         *  \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KJQ7atAm-1621474622260)(C:\\Users\\NHT\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200303105802208.png)\]
         *  \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BOD1DGvm-1621474622262)(C:\\Users\\NHT\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200303105741376.png)\]
     *  使用操作符 `new` \+ `delete`
        
         *      int *Age; 	Age = new int; 	*Age = 71;  	int *Age = new int(71); 	 	//配对使用，new的时候有[]，delete就有 	char *cityName = new char[9]; 	delete []cityName;
         *  堆是内存的堆积
     *  构析函数
        
         *  在对象的生存期结束的时刻系统自动调用析构函数，释放其空间
         *  具体执行时刻
            
             *  \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FaKx9cZe-1621474622263)(C:\\Users\\NHT\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200304023036499.png)\]
             *  \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TjPe7wMk-1621474622264)(C:\\Users\\NHT\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200304023046547.png)\]
         *  未声明析构函数，编译器将合成一个默认的析构函数
         *  当使用完全的限定名（包括对象、类名、函数名）时，可以调用析构函数
         *  调用顺序：先构造的后析构、后构造的先析构
     *  当指针碰上类
        
         *  \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oTagD8kv-1621474622266)(C:\\Users\\NHT\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200304023249698.png)\]
         *  \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pTwC4u91-1621474622267)(C:\\Users\\NHT\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200304023407477.png)\]
     *  友元
        
         *  友元成员函数：一个类的成员函数作为另一个类的友元时，在声明友元成员函数要加上成员函数所在的类名和作用域运算符::
            
                friend void S::ssd(void);
         *  友元类：一个类是另一个类的友元时，所有成员函数都成为另一个类的友元函数，即作为友元的类中的所有成员函数都可以访问另一个类中的私有成员
         *  特性
            
             *  不对称，A是B的友元，B不一定是A的
             *  不传递
             *  不继承：基类的友元并不能由其派生类继承
         *  尽量少使用，这对封装性是一种破坏
     *  引用与函数
        
         *  \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ASKG1ivF-1621474622268)(C:\\Users\\NHT\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200304024329365.png)\]
         *  语法上，比传递指针更容易书写，操作更简单
     *  关于引用
        
         *  引用可以作为函数参数
         *  引用可以作为返回值
            
             *  此时函数的调用可以 被赋值
             *  如果函数的返回值是一个对象的值，它会被认为是一个常量，不能成为左值
     *  类要先声明，再使用，定义若后置，则应提前引用声明
 *  return语句
    
     *  两种形式：后面接参数or not
     *  很多编译器无法发现的错误是：在含有 `return`语句的循环后面的`return`语句的缺失
     *  **值的返回方式**：
        
         返回的值用于初始化调用点的一个临时量，该临时量就是函数调用的结果
     *  不要返回局部对象的引用或者指针

### 2020/3/13 ###

*  解引用和递增运算符 混用时，解引用的指针对象由 递增运算符 的使用方式 决定（在于 递增运算符 在解引用对象的前方还是后方）
 *  友元类：一个A类为另一个B类的友元，B的所有private成员函数能够被A类的成员函数访问
 *  上课的需求：
    
     *  动态存储，动态内存管理
 *  语句
    
     *  空语句：一般最好加上注释，使得他人明白此处为故意省略
     *  异常处理
        
         *  三套机制：
            
             *  throw 表达式(expression)
             *  try 语句块 + catch 子语句
             *  异常类
         *  异常类型 位于 `stdexcept`
         *  throw
            
                throw runtime_error("Data");
         *  标准异常类
            
             *  `exception`头文件 定义了最通用的异常类 exception
     *  `stdexcept` 定义了几种常用 异常类
        
         *  `new` 定义内 bad\_alloc 异常类
         *  `type_info` 定义了 `bad_cast` 异常类
         *  exception bad\_alloc bad\_cast 只能使用默认初始化，除此之外的异常类都不允许使用默认初始化（必须提供初始值）
         *  异常类型 都具有 what() 的成员函数用于返回一个 C风格字符串，其内容可能由系统决定，或者是初始化的字符串值
         *  编写 **异常安全** 的代码非常困难
            
             *  在异常发生期间 正确执行了 清理 工作的程序 成为 **异常安全** 代码
             *  需要的不仅仅是 语言层面的技术
 *  含有可变形参的函数
    
     *  无法提前预知 应向函数传递几个实参，使用方法：
        
         *  实参类型若相同，传递一个名为 `initializer_list`的标准库类型；实参类型不同，可以写 可变参数模板
            
             *  intializer\_list 的标准库类型 也是一种模板类型
             *      initializer_list<string> ls;
             *  与vector不同，initializer\_list 对象中的元素永远是常量值
         *  特殊的形参类型——省略符
 *  数组形参
    
     *  两个常常会起影响的数组性质
        
         *  不允许拷贝数组
         *  使用数组时（通常）会将其转换成指针
     *  转换时，数组常常被转换为指向第一个元素的指针，为了解决控制下标不超过其大小的问题，常用有3中方法
        
         *  用标记制定数组长度
         *  模仿标准库规范：传递指向数组首元素 和 尾后元素的指针
         *  显示传递一个表示数组大小的形参
     *  数组形参形式
        
            f(int &arr[10]); //arr为j含有10个整型引用的数组	f(int (&arr)[10]); //arr是具有10个整型数组的引用	int *matrix[10]; //10个指针构成的数组	int (*matrix)[10]; //指向含有10个整数的数组的指针	void print(int matrix[][10], int rowSize) {;} //第一个形参看起来像是一个二维数组，实际上形参是指向含有10个整数的数组的指针
 *  函数参数问题
    
     *  调用运算符 —— 两个圆括号 （）
     *  调用函数完成两件事情：实参初始化形参，控制权转移给调用的函数
     *  局部对象
        
         *  自动对象：只存在于块执行期间的对象
         *  局部静态对象
     *  const 形参 和 实参
        
         *  尽量使用常量引用
         *  会给调用者 一种可以改变该参数的错觉 + 会限制函数所能接受的实参类型（例如，不能把const对象、字面值或者需要类型转换的对象传递给普通的引用形参）
            
            例如
            
                string::size_type find_char(string &s, char c, string::size_type &occurs);	find_char("Hello World", 'o', ctr);//将发生错误，常量无法传递给 可变的引用
        
            - 并且当其他函数将它们的形参（正确地）设置成常量引用时，那么将无法兼容其参数传递
     *  C常常用指针类型访问函数外部的对象，C++中推荐使用引用类型的形参
        
         *  使用 传引用参数 来避免拷贝（有些数据量较大的类类型或容器对象进行拷贝较低效，甚至有的类类型根本不支持拷贝操作）
     *  当使用时长初始化形式参数时，顶层`const` 会被忽略掉，因此 `void fcn(const int i)` 和 `void fcn(int i)`的重载无法实现。因为即使形式上有差异，但实际上它的形参和第一个`fcn`的形参没什么不同
     *  数组形参
        
         *  在参数传递过程中，数组名实参将被自动转化指向数组首元素的指针，失去其大小属性，为此，常有的有三种技术管理指针
         *  1、用在数组中某个元素作为结束位的标记
         *  2、使用标准库规范 传递指向首元素和尾后元素的指针
         *  3、显式传递一个表示数组大小的形参
         *  当不需要対数组元素进行读写操作的时候，数组形参应该是指向const的指针
         *  也可以使用 **数组引用的形参** —— 这个可能在传递后仍然保持数组的大小属性???
         *  多维数组的传递
            
                int *matrix[10];	int (*matrix)[10];	void print(int matrix[][10], int rowSize){ ... };
     *  main 函数 的 `int argc, char *argv[]`
        
         *  argc是字符串数量，argv是指向c风格字符串数组的指针
     *  可变形参
        
         *  initializer\_list 是 可变参数模板
         *  initializer\_list 一种标准库类型，用于表示某种特定类型的值的数组，也是一种模板类型，同
         *  initializer\_list 对象中的元素永远是常量值，无法改变 initializer\_list对象中的元素的值
         *  例子
            
                void error_msg( initializer_list<string> il)    {        for (auto beg = il.begin(); beg != il.end(); ++beg)            cout << *beg << " ";        cout << endl;    }	error_msg({"functionX", expected, actual}); //不太懂为什么这里有常量没有使用双引号??? 打算之后试一试
         *  initializer\_list 包括 begin 和 end 成员
     *  省略符形参
        
            void foo(para_list, ...);	void foo(...);
 *  函数返回
    
     *  无返回值函数若无return 会在函数体尾巴自动return
     *  返回一个值的方式和初始化一个变量或形参的方式完全一样：返回的值用于初始化调用点的**一个临时量**，该临时量就是函数调用的结果
     *  不要会局部对象的引用或指针
     *  引用返回左值
     *  列表初始化返回值
        
            vector<string> process()    {        if(expected.empty())            return {};        else if (expected == actual)            return {"functionX", "okay"};        else            return {"function", expected, actual};    }
        
        注意：返回的是 元素为string的vector
     *  主函数main的返回值
        
         *  一般 返回0 表示执行成功，返回其他值表示执行失败，其中非0值的具体含义依据机器而定
         *  为了使返回值与机器无关，`cstdlib`头文件定义了两个预处理变量，我们可以使用这两个变量分别表示为成功与失败
            
                int main(){    if (some_failure)    {        return EXIT_FAILURE;    }    else        return EXIT_SUCCESS;}
     *  返回数组指针或引用
        
         *  定义一个返回数组的指针或引用的函数比较繁琐，有一些简化的方法，其中最直接的方法是使用类型别名
            
                typedef int arrT[10]; // 这个类型别名的语法要注意 	using arrT = int[10];	arrT* func(int i); // func返回一个纸箱含有10个整数的数组的指针
         *  直接声明一个返回数组指针的函数
            
                //本来有语法	int arr[10]; // arr 是一个含有10个整数的数组	int *p1[10]; 	// p1是一个指针，它指向一个含有10个指针的数组 	int (*p2)[10]; // p2是一个指针，它指向一个包含10个整数的数组	//现在要定义函数 返回数组指针	int (*func(int i))[10];	//另外，还可以使用 【尾置返回类型】	auto func(int i) -> int(*)[10];	//使用decltype	int odd[5] = {0,2,4,6,8};	int even[5] = {1,3,5,7,9}	decltype(odd) *arrPtr(int i)    {        return (i % 2) ? &odd : &even;    }
            
            1、直接定义
            
            2、尾置返回类型0
            
             在本来应该放置返回类型的地方放置一个auto，从而表示真正的返回类型跟在形参列表后面
            
            3、使用decltype
 *  函数重载初步
    
     *  形参是否为 **顶层**const 无法确定为 重载
     *  形参是否为 **底层**const 可以确定为 重载
     *  但当底层为 非常量时，并且函数有対底层const的有无都进行重载时，编译器将会优先选用非常量版本的函数
     *  const\_cast 可以用于对变量的const属性进行修改
        
            string &shorterString(string &s1)    {        auto &r = getString(const_cast<const string&>(s1)); //先转换为対const的引用        return const_cast<string&>(r); //再转换为一个普通的string&    }
     *  函数匹配/重载确定 的过程 可能有三种结果：最优匹配，无匹配，二义匹配
        
         *  具体的匹配规则 见 《Primer C++》P220
     *  一般来说，我们都不会使用 **局部函数声明**
        
         *  但是当你使用的时候要注意，如果我们在内层作用域中声明名字，它将隐藏外层作用域中的同名实体，在不同的作用域中无法重载同名函数
         *  C++中，名字查找发生在类型检查之前。因此，使用重载函数时，编译器会首先在最局部的块中対声明进行查找，找到了之后会确定对应，而检查类型是否匹配发生在这之后++
 *  inline和constexpr函数
    
     *  调用函数其实需要完成一系列任务：调用前要先保存寄存器，并在返回时回复；可能需要拷贝实参；程序转向一个新的位置继续开始
     *  内联inline 表示直接在该处展开表达式，用于优化 规模小、流程直接、频繁调用的函数
     *  constexpr函数 是指 能用于常量表达式的函数
        
         *  定义该函数的方法与其他函数类型，不过要遵循约定：
            
             *  函数的返回类型与所有形参的类型都得是字面值类型
             *  函数体必须有且只有一条 return 语句
             *  其实也可以包含其他语句，只要这些语句在运行时不执行任何操作，例如 空语句 类型别名 以及 using 声明
         *  我们允许 constexpr 函数的返回值 并非一个常量
            
                //如果arg是常量表达式，则scale(arg)也是常量表达式constexpr size_t scale(size_t cnt){ return new_sz() * cnt; }
            
            当scale的实参是常量表达式时，它的表达式也是常量表达式，如果不是常量表达式，那么返回的不是常量表达式，反之则不然：（**也就是说，如果输入了非常量，形参仍然可以输入函数内，但是因为并不能返回常量表达式，会在编译器编译过程中被发现，然后报错，导致无法编译成功**）
            
                int arr[scale(2)];	//正确：scale(2)是常量表达式int i = 2;			//i不是常量表达式int a2[scale(i)];	//错误：scale(i)不是常量表达式
            
            当把scale函数用在需要常量表达式的上下文中时，如果其结果恰好不是常量表达式，编译器将发出错误信息。
         *  复习
            
             *  **一般来说，如果你认定变量是一个常量表达式，那就把它声明成constexpr类型**，它是用于让编译器来验证一个量是否是常量，被声明为constexpr类型的量一定是常量
             *  C++11规定，允许将变量声明为constexpr类型以便由编译器来验证变量的值是否是一个常量表达式。声明为constexpr的变量一定是一个常量，而且必须用常量表达式初始化。
     *  位置
        
         *  对于某个给定的内联函数或者constexpr函数，多个定义必须完全一致，所以一般定义在头文件中
 *  调试帮助
    
     *  两种预处理功能：assert 和 NDEBUG
     *  assert 一个预处理变量
        
         *  包含在 `cassert`头文件中
         *  因为是预处理变量，因此并没有命名空间
         *  使用 `assert( /* expr */ )` 若表达式为0，输出信息并终止程序的执行；如果为真，则什么都不做哟
         *  一般用于检查【不能发生】的条件 `assert( word.size() > threshold)`
     *  NDEBUG 预处理变量
        
         *  assert依赖于这个变量，如果定义了NDEBUG，则 assert 什么也不做
         *  可以使用一个 \#define 语句定义 NDEBUG
         *  很多编译器提供命令行选项使我们可以定义预处理变量
            
                gcc -D NDEBUG main.c
         *  另外，当NDEBUG未定义的时候，将执行 \#ifndef 和 \#endif 之间的代码；如果定义了NDEBUG，将被忽略掉
     *  C++定义了一些好东西
        
            _ _func_ _ // 当前调试的函数的名字，编译器定义的一个const char静态数组，用于存放每一个函数的名字    _ _LINE_ _ //存放当前行号的整型字面值    _ _TIME_ _ //存放文件编译时间的字符串字面值    _ _DATE_ _ //文件编译日期的字符串字面值
 *  默认实参
    
     *  一个作用域中一个形参只能被赋予一次默认实参
     *  因此有，函数的后续声明，只能为前面没有默认值的形参添加默认实参，而且该形参右侧的所有形参都必须要有默认实参
     *  局部变量不能作为默认实参
     *  只要表达式的类型能够转换为形参所需要的类型，该表达式就能作为默认实参
 *  函数指针
    
        // 函数指针的类型由它的返回类型和形参类型共同决定	// 声明直接把 函数名 换成 (*pf) 即可	bool (*pf)(const string &, const string &);		// 可以赋值	pf = lengthCompare;	pf = &lengthCompare; //取地址符可选	pf = 0; //不指向	pf = nullptr; //不指向		// 对于重载函数 必须确定声明指向哪一个	double (*pf)(int *) = ff;	// 形参可以是 指向函数的指针	void useBigger(const string &s1, bool pf(const string &)); //第二个形参会自动转化为指向函数的指针	void useBigger(const string &s1, bool (*pf)(const string &)); 	// 调用时，可以直接把函数名作为实参使用，其将自动转换为指针	useBigger(s1, lengthCompare);	// 可以通过 typedef 和 decltype 来简化声明	// 这是定义函数	typedef bool Func(const string&, const string&);	typedef decltype(lengthCompare) Func2;	// 这是定义函数指针	typedef bool (FuncP*)(const string&, const string&);	typedef decltype(lengthCompare) *FuncP2;	// 关于返回值	// 如果想要声明一个函数指针，最简单的方法是使用 类型别名	using F = int(int*, int*); //这是函数	using PF = int(*)(int*, int*); //这是函数指针		//声明方法	PF f1(int);	F  *f1(int);	//直接声明方法	int (*f1(int))(int*, int); //解读难度很高	// 由内(从f1)向外阅读，首先f1有形参列表，所以是函数，然后前面有*，所以返回一个指针	// 进一步发现 指针的类型本身也包含形参列表，因此指针指向函数，函数的返回类型是Int

### 2020/3/17 ###

*  上课笔记
    
     *  重载运算符
        
        \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GGC8wW0T-1621474622269)(C:\\Users\\NHT\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200317103403604.png)\]
     *  希望自定义的函数类型
     *  重载的方式： 友元 和 成员
        
        \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QXOvgqUM-1621474622270)(C:\\Users\\NHT\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200317103923659.png)\]
        
        有些运算符 两种方式都可以，有些只能用某种重载方式，有些两种重载运算符都可以但是一般使用某一种
     *  重载运算符的规则和限制
        
        \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dynElBKl-1621474622270)(C:\\Users\\NHT\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200317104103375.png)\]
     *  \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C6IpeRSF-1621474622271)(C:\\Users\\NHT\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200317110655120.png)\]
        
         *  注意重载 自增自减 运算符的 前置 与 后置 的区别

### 2020/3/24 ###

*  \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cmf2kCtg-1621474622272)(C:\\Users\\NHT\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200324100356973.png)\]

### 2020/3/30 ###

万众期待的【重载运算符与类型转换】来了！！

*  重载基本概念
    
     *  参数数量与原运算符作用的运算对象数量 一样多
        
         *  二元运算符，左侧对象是第一个参数，右侧对象是第二个
         *  成员函数调用法，`this`绑定到左侧运算对象
     *  除了重载的函数调用运算符oeprator()之外，重载运算符不能有默认实参
     *  重载定义的运算对象至少有一个类的成员或者类类型的对象
     *  不改变 结合律和优先级
     *  直接调用重载运算符
        
            operator+(a1,a2);	a1.operator+=(a2);
     *  因为程序员会希望在混合类型的表达式中使用对称性运算符，所以 含有类对象的混合类型表达式中的运算符必须定义成非成员函数，
        
        这是因为，当我们把运算符定义成成员函数时，它的左侧运算对象必须是 运算符所属类的一个对象
        
            string s = "world";	string t = s + "!"; // 正确	string t = s.operator+("!"); // 等价的例子	string u = "hi" + s; // 错误	string u = "hi".operator+(s); // 等价的显然错误的例子	// 若将 + 定义成普通的非成员函数，则有	u = operator+("hi",s);
 *  重载输出运算符`<<`
    
     *  一般情况下，第一个形参是 一个非常量 `ostream` 对象的引用（非常量是因为向其写入内容会改变其状态，引用是因为无法复制`ostream`对象），第二个形参 一般是一个常量的引用（是引用是因为我们希望避免复制，常量是因为通常打印不会改变其内容）
     *  一般来讲，尽可能减少 **格式化操作** 例如输出运算符
     *  输入输出运算符必须是 **非成员函数**，否则它左侧的运算对象将成为我们的类的一个对象。
        
        这是因为，假设输入输出运算符是某个类的成员，则它们也必须是 `istream` 和 `ostream` 的成员。然而，这两个类属于标准库，并且我们无法给标准库中的类添加任何成员
     *

### 2020/4/7 ###

*  上课笔记
    
     *  模板——用于实现代码重用，分为 **函数模板** 和 **类模板**
     *  \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wLA5CZO9-1621474622273)(C:\\Users\\NHT\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200407113555954.png)\]
     *  \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5vXlZcR6-1621474622274)(C:\\Users\\NHT\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200407113653001.png)\]
     *  \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QcySe3dt-1621474622275)(C:\\Users\\NHT\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200407113811323.png)\]
     *  \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NA0iYsR0-1621474622276)(C:\\Users\\NHT\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200407115240017.png)\]

### 2020/4/30 ###

开始 **面向对象程序设计**， 其核心是 **数据抽象、继承和动态绑定**。

*  继承
    
    类派生列表
    
        class Bulk_quote : public Quote {    public:        double net_price(std::size_t) const override;    }
    
    大多数类都只继承一个类，这种形式的继承被称为 **单继承**。
    
    如果基类定义了一个静态成员，则在整个继承体系中只存在该成员的唯一定义。不论从基类中派生出多少个派生类，对于每个静态成员来说都只存在唯一的实例。并且其遵循通用的访问控制规则。
    
    有时我们希望一个类不被其他类继承，或者不想考虑它是否作为一个基类——使用关键字`final` 如
    
        class Nodrived final { /* */ ;}
 *  虚函数：对于某些函数，基类希望它的派生类各自定义适合自身的版本，因此基类就将这些函数声明成虚函数
    
    派生类必须在其内部对所有重新定义的虚函数进行声明
    
    任何构造函数以外的非静态函数都可以是 虚函数
    
    如果一个函数在基类中声明为虚函数，那么在派生类中隐式地也是虚函数
    
    派生类可以在它覆盖的函数前使用virtual关键字，但不是非得怎么做。
    
    如果派生类没有覆盖基类中的某个虚函数，派生类将会直接继承其在基类中的版本
    
    C++新标准 允许派生类显式地标注它使用某个成员函数覆盖了继承的虚函数：具体做法是在 形参列表之后、或 在const成员函数的const关键字之后、 或在引用成员函数的引用限定符后面 添加一个关键字 `override`
 *  动态绑定：能够使用同一段代码分别处理 Quote 和 Bulk\_quote 的对象
    
    当我们使用基类的引用（或指针）调用一个虚函数时将发生动态绑定——基类和派生类都可以调用基类的成员函数，但是这是一个虚函数，两个类之间不同，因此编译器会根据世纪传入的参数类型决定，即即使形参是基类，也可以传入派生类来做相同的调用
    
    基类通过在其成员函数的声明前加上关键字virtual使得该函数执行动态绑定
    
    关键字`virtual`只能出现在类内部的声明语句之前而不能用于类外部的函数定义
 *  基类
    
    作为继承关系中根节点的类，即基类，通常都会定义一个**虚析函数** —— 虚的析构函数
 *  保护`protected`关键字 ： 基类希望它的派生类有权访问该成员，同时禁止其他用户访问
 *  派生类
    
    通过使用 **类派生列表** 来明确指出 它是从哪个基类继承而来的形式
    
    **形式为：** 一个冒号，后面紧跟以逗号分隔的基类列表，每个基类前面可以有以下三种说明符中的一种：public,private,protected
    
    说明符号的作用是控制派生类从基类继承而来的成员是会否対派生类的用户可见
    
    可以将派生类的对象当做基类对象来使用，而且我们也可以将 基类的指针或引用绑定到 **派生类对象中的积累部分上**，这种转换成为 派生类到基类的类型转换
    
    但是， 派生类不能直接初始化 基类部分的成员，而是必须调用 **基类的构造函数**。这是因为每个类负责定义各自的接口——要想与类的对象交互必须使用该类的接口，即使这个对象是派生类的基类部分也是如此。
    
    *如何调用基类构造函数？*
    
    派生类的作用域嵌套在基类的作用域之内。因此对派生类的一个成员来说，它使用派生类成员的方式与使用基类成员的方式没什么不同
    
    派生类的声明：包含类名但不包含其派生列表。
    
    ——声明的作用：令程序知晓某个名字的存在已经该名字比哦啊还是一个什么样的实体，如一个类、一个函数或一个变量
 *  类型转换与继承
    
    一个基类的引用或指针可以绑定到派生类的基类部分上
    
    一个基类的对象可以以独立的形式存在，也可以作为派生类对象的一部分存在
    
    因为一个基类的对象可能是派生类对象的一部分
    
    **静态类型** 和 **动态类型**
    
    静态类型在编译时是一直的，它是变量声明时的类型或表达式生成的类型
    
    动态类型是变量或者表达式表示的内存中的对象的类型，需要等到运行时才可知
    
    **即便接受基类变量的函数可以同时接受基类和派生类的对象作为参数，但是它仍然只能使用基类的功能，因为被声明为基类**
 *  虚函数
    
    当通过指针或引用调用虚函数时，对虚函数的调用在运行时才被解析，直到运行才知道是哪一个被使用
    
    可以用 `virtual` 声明为虚函数
    
    一旦某个函数被声明为虚函数，则在所有派生类中它都是虚函数
    
    一个派生类的函数如果覆盖了某个继承而来的虚函数，则它的新参类型必须与被它覆盖的基类函数完全一致。并且，返回类型也必须匹配（有一个例外，但类的虚函数返回类型是类本身的指针或者引用时，也就是说，D是B派生得到的，则基类的虚函数可以返回B \* 而派生类的对应函数可以返回 D \*）
    
    虚函数也可以拥有默认实参，由本次调用的静态类型决定，即如果通过基类的引用或者指针调用函数，则使用基类定义的默认市场，即使运行的是派生类中的函数版本也是如此
    
    **回避虚函数的机制**：可以不进行动态绑定，而是强迫执行虚函数的某个特定版本—— **使用作用域运算符**能够实现这一点 例如`baseP->Quote::net_price(42);`
    
     *  通常当一个派生类的虚函数调用它覆盖的基类的虚函数版本时，才需要这么做
     *  因为 如果一个派生类虚函数需要调用它的基类版本时，没有使用作用域运算符，则在运行时该调用将被解析为対派生列版本自身的调用，从而导致无限递归
 *  关键字override
    
    派生类如果定义了一个函数与基类中虚函数的名字相同但是 **形参列表不同**的函数，这仍然是合法的行为，但会被认为是另外一个独立的函数。如果使用override表示应该覆盖，但是实际上并没有覆盖上，那么会报错。
    
    并且只有虚函数才能被覆盖。
 *  抽象基类
    
    纯虚函数 通过使用 `=0` 来声明，并且只能出现在类内部的虚函数声明语句处
    
    含有（或者未经覆盖直接继承）纯虚函数的类 是 **抽象基类**
    
    我们不能定义抽象基类的对象，因为未定义。派生类的对象要能够定义，必须将纯虚函数覆盖完成。
 *  访问控制
    
    protected 声明 希望于派生类分享但是不想被其他公共访问使用的成员
    
    **派生类的成员或友元只能通过派生类对象来访问基类的受保护成员。派生类对于一个基类对象中的受保护成员没有任何访问特权**

### 2021/4/5 ###

int abs(int i)  //返回整型参数i的绝对值 double cabs(struct complex znum) //返回复数znum的绝对值 double fabs(double x) //返回双精度参数x的绝对值 long labs(long n) //返回长整型参数n的绝对值

## 乐学刷题经验 ##

*  排序的判断准则 < 还是 <= 居然会有影响
 *  auto 总是通不过编译气死我了
 *  不支持类内初始值

[GNU]: https://img-blog.csdnimg.cn/20190404151436589.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0RYTUFSSw==,size_16,color_FFFFFF,t_70
[https_blog.csdn.net_m0_37925202_article_details_82927656_ops_request_misc_7B_22request_5Fid_22_3A_22158253045119724835827597_22_2C_22scm_22_3A_2220140713.130056874_22_7D_request_id_158253045119724835827597_biz_id_0_utm_source_distribute.pc_search_result.none-task]: https://blog.csdn.net/m0_37925202/article/details/82927656?ops_request_misc=%7B%22request_id%22%3A%22158253045119724835827597%22%2C%22scm%22%3A%2220140713.130056874..%22%7D&request_id=158253045119724835827597&biz_id=0&utm_source=distribute.pc_search_result.none-task