零、预处理器

确保头文件多次包含仍能安全工作的常用技术是预处理器，预处理器是在编译之前执行的一段程序，任何以 # 开头的东西，都被称为预处理器命令或者预处理器指令。如 #include ，当预处理器看到 #include 标记时就会用指定的头文件内容代替 #include 。

头文件保护符

下面来说 # pargma once

pragma 本质上是一个被发送到编译器或预处理器的预处理指令。
pragma once 阻止我们单个头文件多次被 include 在同一个 cpp 文件里。

1
2
3
4
5
6
7
8

//新方法
#pargma once

//旧方法
#ifndef  _PROJECT_A
#define  _PROJECT_A
...
#endif

include 用于告诉编译器，包含文件的路径是什么，有两种写法：

• #include< >: 在所有 include 路径中搜索文件
• #include" " ：引用相对路径，现在也有 #include< > 的功能，作用范围更大

宏 macro

#define #宏 #macro

1. 预处理阶段 ：当编译 C++ 代码时，首先预处理器会检查一遍 C++ 所有的以 # 符号开头（这是预编译指令符号）的语句，当预编译器将这些代码评估完后给到编译器去进行实际的编译。

2. 宏和模板的区别：发生时间不同，宏是在预处理阶段就被评估了，而模板会被评估的更晚一点。

3. 用宏的目的：写一些宏将代码中的文本替换为其他东西（纯文本替换）**（不一定是简单的替换，是可以自定义调用宏的方式的）

   1 2 3 4 5 6 7

   #defind WAIT std::cin.get() //这里可以不用放分号，如果放分号就会加入宏里面了 int main() { WAIT; //等效于std::cin.get()，属于纯文本替换 //但单纯做这种操作是很愚蠢的，除了自己以外别人读代码会特别痛苦 }

4. 宏的用法之一：宏是可以发送参数的

1
2
3
4
5
6
7
8

#include <iostream>
#define log(x) std::cout << x << std::endl

int main() {
    log("hello");
    //这样子会输出“hello”
    return 0;
}

5. 宏可以辅助调试

在 Debug 模式下会有很多日志的输出，但是在 Release 模式下就不需要日志的输出了。正常的方法可能会删掉好多的输出日志的语句或者函数，但是用宏可以直接取消掉这些语句

利用宏中的 #if，#else，endif 来实现。如：

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <iostream>

#defind PR_DEBUG 1 //可以在这里切换成0，作为一个开关
#if PR_DEBUG == 1   //如果PR_DEBUG为1
#defind LOG(x) std::cout << x << std::endl  //则执行这个宏
#else   //反之
#defind LOG(x)   //这个宏什么也不定义，即是无意义
#endif    //结束

int main() {
    LOG("hello");
    return 0;
}

如果在 Debug (PR_DEBUG == 1) 模式下，则会打印日志，如果在 Release (PR_DEBUG == 0) 模式，则在预处理阶段就会把日志语句给删除掉。

利用 #if 0 和 #endif 删除一段宏.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <iostream>

#if 0   //从这里到最后的endif的宏都被无视掉了，某种意义上的删除

#defind PR_DEBUG 1 
#if PR_DEBUG == 1 
#defind LOG(x) std::cout << x << std::endl 
#else 
#defind LOG(x) 
#endif 

#endif  //结束

int main() {
    LOG("hello");
    return 0;
}

续行符 \

普通代码行后面编译器自动判断续行的，宏定义则不行。

宏定义规定必须用一行完成:

1

#define SomeFun(x, a, b) if(x)x=a+b;else x=a-b;

这一行定义是没有问题的，但是这样代码很不容易被理解，如果写成：

1
2
3
4
5
6
7
8
9
10
11

#define SomeFun(x, a, b)
    if (x)
        x = a + b;
    else
        x = a - b;
//这样理解是好理解了,但是编译器会出错,因为它会认为#define SomeFun(x, a, b)是完整的一行,if (x)以及后面的语句与#define SomeFun(x, a, b)没有关系.这时候我们就必须使用这样的写法:
#define SomeFun(x, a, b)\
    if (x)\
        x = a + b;\
    else\
        x = a - b; //最后一行不加续行符

# 和 ##

单个 #：
在 C 语言的宏中，# 的功能是将其后面的宏参数进行字符串化操作，简单说就是对他所引用的宏变量通过替换后再其左右各加上一个双引用。

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# define WARNIF(EXP) \
do{ \
    if (EXP) \
    {    \ 
        fprintf(stderr, "warning:" #EXP "\n"); \
    }   \  
}while(0)    
// 在实际使用中会出现下面所示的替换过程：
// WARN_IF(div == 0);被替换成以下代码
do{
    if (div == 0) 
    {        
        fprintf(stderr, "warning:" "div == 0" "\n"); 
    }       
}while(0)

两个 ##:
## 被称为连接符，用来将两个 Token 链接成一个 Token. 注意这里的连接的对象是 Token 就行，而不一定是宏的变量。比如你要做一个菜单项命令名和函数指针组成的结构体的数组，并且希望在函数和菜单项命令名直接有直观的名字上的关系，那么下面的代码就非常实用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

struct command
{
    char *name；
    void (*function)(void);
};
 
#define COMMAND(NAME){NAME, NAME##_command}
//然后就用一些预定义好的命令来方便的初始化一个command结构的数据了：
struct command commands[] = {
    COMMAND(quit),
    COMMAND(help),
    ...
}
//COMMAND宏在这里充当一个代码生成器的作用，这样可以在一定程度上减少代码的密度， 间接的也可以减少粗心所造成的错误。
//我们还可以n个##符号链接n+1个Token，这个特性也是#符号所不具备的。
//例如： 
#define LINK_MULTIPLE(a, b, c, d) a##_##b##_##c##_###d
typedef struct_record_type LINK_MULTIPLE(name, company, position, salary);
//展开内容为 ： 
typedef struct_record_type name_company_position_salary;

... 变参宏

... 在 C 语言中被称为变参宏 

1

#define myprintf (templt, ...)  fprintf (stderr, templt, ##__VA_ARGS__)  

这里 ## 这个连接符充当的作用就是当 __VA_ARGS__ 为空的时候，消除前面的那个逗号。

一、变量和基本类型

1 对象

对象：具有某种数据类型的内存空间

• 基本上，当我们编写了一个类并且到了我们实际开始使用该类的时候，就需要实例化它 (除非它是完全静态的类)
• 实例化类有两种选择，这两种选择的区别是内存来自哪里，我们的对象实际上会创建在哪里。
• 应用程序会把内存分为两个主要部分：堆和栈。还有其他部分，比如源代码部分，此时它是机器码。

栈分配

1
2
3

// 栈中创建
Entity entity;
Entity entity("lk");

• 什么时候栈分配？几乎任何时候，因为在 C++ 中这是初始化对象最快的方式和最受管控的方式。
• 什么时候不栈分配？ 如果创建的对象太大，或是需要显示地控制对象的生存期，那就需要堆上创建 。

堆分配

1
2
3

// 堆中创建
Entity* entity = new Entity("lk");
delete entity； //清除

• 当我们调用 new Entity 时，实际发生的就是我们在堆上分配了内存，我们调用了构造函数，然后这个 new Entity 实际上会返回一个 Entity 指针，它返回了这个 entity 在堆上被分配的内存地址，这就是为什么我们要声明成 Entity * 类型。
• 如果你使用了 new 关键字，那你就要用 delete 来进行清理。

new操作符

• new 的主要目的是分配内存，具体来说就是在堆上分配内存。
• 如果你用 new 和 **[] 来分配数组，那么也用 delete[] 。
• new 主要就是找到一个满足我们需求的足够大的内存块，然后返回一个指向那个内存地址的指针。

1
2
3
4
5
6
7
8
9
10
11

int* a = new int; //这就是一个在堆上分配的4字节的整数,这个a存储的就是他的内存地址.
int* b = new int[50];//在堆上需要200字节的内存。
delete a;
delete[] b;

//在堆上分配Entity类
Entity* e = new Entity();
Entity* e = new Entity;//或者这我们不需要使用括号，因为他有默认构造函数。
Entity* e0 = new Entity[50]; //如果我们想要一个Entity数组，我们可以这样加上方括号,在这个数组里，你会在内存中得到50个连续的Entity
delete e;
delete[] e0;

• 在 new 类时，该关键字做了两件事

• 分配内存
• 调用构造函数

1
2
3
4
5

Entity* e = new Entity();//1.分配内存 2.调用构造函数
Entity* e = (Entity*)malloc(sizeof(Entity);//仅仅只是分配内存**然后给我们一个指向那个内存的指针

//这两行代码之间仅有的区别就是第一行代码new调用了Entity的构造函数
delete e;//new了，必须要手动清除

• new 是一个操作符，就像加、减、等于一样。它是一个操作符，这意味着你可以重载这个操作符，并改变它的行为。
• 通常调用 new 会调用隐藏在里面的 C 函数 malloc，但是 malloc 仅仅只是分配内存然后给我们一个指向那个内存的指针，而 new 不但分配内存，还会调用构造函数。同样，delete 则会调用 destructor 析构函数。
• new 支持一种叫 placement new 的用法，这决定了他的内存来自哪里, 所以你并没有真正的分配内存。在这种情况下，你只需要调用构造函数，并在一个特定的内存地址中初始化你的 Entity，可以通过 new() 然后指定内存地址，例如：

1
2

int* b = new int[50]; 
Entity* entity = new(b) Entity(); 

2 变量

初始化

• 区分初始化和赋值：

  • 初始化不是赋值，初始化的含义是创建变量时赋予其一个初始值，而赋值的含义是把已创建对象的当前值擦除，而以一个新值来替代。
  • 只有对象被创建才会出现初始化，而赋值操作并不应用于对象的创建过程中。
  • 构造函数体中进行的是赋值（下图首先执行默认构造函数为变量设置初始值，然后在对他们赋予新值。）
  • C++规定对象的成员函数的初始化动作发生在进入构造函数本体之前。一个比较好的写法是在构造函数成员初始化列表中列出所有成员变量。

    只需要调用一次 copy 构造，通常效率更高（对于内置类型，初始化和赋值成本相同）

• 区分初始化类型

  • 拷贝初始化： 使用等号 = （赋值运算符）初始化变量
  • 直接初始化： 不使用等号，使用 （）
  • 列表初始化：使用{}

• 区分拷贝构造函数和拷贝赋值运算符运算符：[[#拷贝构造和拷贝赋值的区别]]

1
2
3
4
5
6
7
8

TestClass obj1(10,'.') //直接初始化, 调用构造函数
TestClass obj2(obj1); //直接初始化，因为obj1已经存在，所以调用拷贝构造函数

TestClass obj3 = obj1; //拷贝初始化，因为obj1已经存在，所以调用拷贝构造函数
obj3 = obj2; //不是初始化而是赋值，因为没有产生新对象。调用拷贝赋值运算符

TestClass obj4 = "abcdefg"; //拷贝初始化，先调用构造函数创建临时对象，再调用拷贝构造函数
TestClass obj5 = string(100,9); //拷贝初始化，先调用构造函数创建临时对象，再调用拷贝构造函数

注：obj2 与 obj3 的创建所调用的函数是一样的，调用复制函数的原因却有所不同。因为直接初始化是根据参数来调用构造函数的，obj2 是根据括号中的参数（一个本类的对象），来直接确定为调用拷贝构造函数，这跟函数重载时，会根据函数调用时的参数来调用相应的函数是一个道理；
而对于 obj3 则不同，它的调用并不是像 obj2 时那样是根据参数来确定要调用拷贝构造函数的，它只是因为初始化必然要调用复制构造函数而已。它理应要创建一个临时对象，但只是这个对象却已经存在，所以就省去了这一步，然后直接调用拷贝构造函数，因为拷贝初始化必然要调用拷贝构造函数，所以 obj3 的创建仍是拷贝初始化。

初始化方式的选择

1. 初始值只有一个时，使用直接初始化 或拷贝初始化都行。如果初始化多个值，一般只使用直接初始化。如果非要用拷贝初始化的方式，就要显式创建一个临时对象用于拷贝。

   1	string str = string(10,'c');

2. 如果提供的是一个【C++11】类内初始值，则只能使用拷贝初始化或使用花括号的形式初始化，不能使用圆括号。

3. 如果提供的是初始元素值的列表，则只能把初始值都放在花括号里进行列表初始化，而不能放在圆括号里。

   1 2	vector<string> v1{“a”, "an", "the"}; //正确的列表初始化 vector<string> v1(“a”, "an", "the"); //错误

列表初始化

【C++11】使用花括号进行列表初始化
当用于内置类型的变量时，花括号初始化形式有一个重要特点：如果我们使用列表初始化且初始值存在丢失信息的风险，则编译器将报错

1
2
3

long double ld = 3.1415926536;
int a{ld},b={ld};  //报错，因为存在丢失信息的风险（long double->int）
int a(ld),b=ld;  //正确，可以进行转换，但确实丢失了部分值

默认初始化

• 内置变量（包括内置变量的数组类型）默认初始化值由定义的位置决定：定义于函数体外的变量被初始化为 0，定义在函数体内部的内置变量将不被初始化，其值是未定义的（如果试图拷贝或访问会引发错误）。
• const 变量规定初始化必须有初始值，否则编译器错误
• static 变量（包括 static 数组）默认初始化为 0。
• 类、结构体的默认初始化由其构造函数决定

声明和定义

C++支持分离式编译机制，该机制允许将程序分割为若干个文件，每个文件可被独立编译。为了支持分离式编译，C++将声明和定义区分开来，声明使得名字未程序所知，一个文件如果想用别处定义的名字就必须包含对这个名字的声明，而定义负责创建与名字关联的实体。

变量、函数能且只能被定义一次，但是可以多次被声明。

- 函数声明：这个符号、这个函数是存在的。  
- 函数定义：这个函数到底是什么。

- 变量声明：告诉编译器变量的名称和类型，不分配内存，不赋初始值
- 变量定义：为变量分配内存，为变量赋初值

如果想声明一个变量而非定义它，就在变量名前加关键字 extern，且不要显式初始化变量：

1
2
3
4

extern int a； //只声明不定义
int b; //声明并定义

extern int a = 1; //如果包含了显示初始化，那么声明就会变成定义，在函数体内部会报错

函数声明（又称函数原型）建议放在头文件中

extern 关键字

#extern

extern 可以置于变量声明或者函数声明前，以标示变量或者函数的定义在别的文件中，编译器遇到此变量和函数时会在其他文件中寻找其定义。
通过为变量和函数添加 extern 声明，可以让编译器把“寻找定义”这件事情推迟到链接阶段，而不会在编译阶段报“没有定义”的错误。

1. 声明函数或全局变量的作用范围，其声明的函数和变量可以在本文件或其他文件中使用。
2. extern “C”：兼容 C 语言，详情 [[#extern “C”]]
3. C++ 中的函数声明默认被隐式的 extern 关键字修饰

使用在其它文件中定义的全局变量/函数

“用到未被定义的变量/函数”这种情况一般出现在使用在其它文件中定义的变量/函数时。

使用场景：需要在 a.cpp 文件中使用在 b.cpp 中定义的全局变量/函数:

一般而言，C++全局变量的作用范围仅限于当前的文件，但同时 C++也支持分离式编译，允许将程序分割为若干个文件被独立编译。在一个文件中定义了变量和函数，在其他文件中要使用它们，可以有两种方式：

1. 使用头文件，然后声明它们，然后其他文件去包含头文件
2. 使用 extern，引用不在同一个文件中的变量或者函数。

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <iostream>
//不需要include "B.cpp"

//使用extern声明变量和函数
extern int i;
extern void func(); //函数声明默认被extern修饰，所以此处的extern可以省略

int main()
{
    std::cout << i << std::endl; //输出10
    func(); //输出10
    return 0;
}

1
2
3
4
5
6
7
8

#include <iostream>

int i = 10;

void func()
{
    std::cout << i << std::endl;
}

在 C++中我们通常在头文件中声明变量和函数，我们可以将上述 A.cpp 文件中的声明移动到A.h 头文件中，并在 A.cpp 中 include 该头文件。

1
2
3

#pragma once
extern int i;
extern void func();

1
2
3
4
5
6
7
8
9
10

#include <iostream>
#include "A.h"

int main()
{
    std::cout << i << std::endl;
    func();
    return 0;
}

注意此时变量 i 和函数 func 已经在 B.cpp 中定义。其他任何地方不能重复定义。

const 变量多文件编程

C++ const常量在多文件编程中的3种用法 - 朴素贝叶斯 - 博客园 (cnblogs.com)

已知：
![[#const 变量]]

那么如何让 const 变量在其他文件使用？
由于 const 变量无法分离声明和定义，最简单的方法是将 const 定义在头文件中，其他 cpp 文件包含即可，但这违反了多文件编程的规定：在头文件中声明，在 cpp 文件中定义。
**有些情况下我们想要只在一个文件中定义 const，而在其他多个文件中声明并使用它，要使 const 变量能够在其他的文件中访问，必须地指定它为 extern。（将 const 改为外部链接）

1
2

#pragma once
extern const int j; //声明

1
2
3
4
5
6
7
8

#include <iostream>
#include "D.h"

const int j = 123; //定义
int main()
{
    std::cout << j << std::endl;
}

extern “C”

告诉编译器按着 C 的函数命名规则去翻译指定的C++函数，以此兼容 C 语言。
如果不用 extern C，由于 C++ 和 C 语言在编译和链接时使用的命名规则不同，这会导致 C++ 代码无法调用 C 语言编写的函数或变量（链接时找不到符号）。

简单解释一下什么是函数的命名规则：对于 C++ 语言，由于需要支持重载，所以一个函数的链接名（Linkage Name）是由函数的名称、参数类型和返回值类型等信息组成的，用于在编译和链接时唯一标识该函数。

函数的链接名的生成规则在不同的编译器和操作系统上可能有所不同，一般是由编译器自动处理，不需要手动指定。

而 C 语言的链接函数名规则又和上面三个 C++ 不一样，通过在 C++ 代码中使用 extern “C” 关键字，可以将 C++ 编译器的命名规则转换为 C 语言的命名规则，从而使得 C++ 代码可以调用 C 语言的函数或变量。

extern “C” 的语法格式如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// C 语言代码:test.c
#include <stdio.h>

void print_message(const char* message) {
    printf("%s\n", message);
}

// C++ 代码:test.cpp
extern "C" {
    // 声明 C 语言函数
    void print_message(const char* message);
}

int main() {
    // 调用 C 语言函数
    print_message("Hello, world!");
    return 0;
}

需要注意 extern “C” 关键字只对函数的名称和调用约定起作用，对于函数的参数类型和返回值类型没有影响。

所以，在使用 extern “C” 声明函数时，需要保证函数的参数类型和返回值类型与 C 语言的定义相同，否则可能会导致编译错误或运行时错误。

优点

extern 关键字在 C++ 中有几个优点，尤其在多文件项目中使用时：

1. 避免重复定义： 当在多个源文件中需要共享全局变量或函数时，extern 关键字帮助避免了重复定义的问题。通过在头文件中声明并在一个源文件中定义，其他源文件可以通过 extern 关键字访问而不会导致重复定义错误。
2. 提高可维护性： 使用 extern 显式声明全局变量或函数，可以提高代码的可维护性。通过头文件的声明，程序员可以清晰地了解哪些变量和函数是在其他文件中定义的，这有助于代码的理解和维护。
3. 分离接口和实现： extern 关键字有助于分离接口和实现。头文件中包含的声明提供了对外部功能的接口，而实际定义则可以隐藏在实现文件中，这符合良好的软件设计原则。
4. 支持模块化设计： 在大型项目中，使用 extern 可以支持模块化设计。模块化设计将代码分割成小的、独立的模块，每个模块可以在单独的源文件中进行定义，而 extern 允许这些模块之间共享数据和功能。

总体来说，extern 关键字有助于管理和组织多文件项目，提高代码的可读性和可维护性。

3 类型

指针

对计算机来说内存就是一切。x86 即 32 位地址为 32 位（8 位 16 进制数，4 * 8 = 32），那么对应指针就是 4 字节；x64 则为 64 位地址（16 位 16 进制数），则对应指针 8 字节。

• 指针是一个存储变量内存首地址的整数，指针自身也是一个变量也有自己的内存地址，所以可以使用诸如 **、*** 等多级指针。
• 解引用时，编译器怎么知道该从首地址开始取多少个字节呢？
  • 编译器会根据指针的所指元素的类型去判断应该取多少个字节。

1
2
3
4
5
6
7

int main()
{
	int var = 8;
	//指针就是一个整数，值为内存地址
	int* ptr = &var;	//&取地址：返回变量var的内存地址
	std::cout << *ptr;	//*解引用：返回指针ptr指向内存所存储的值，即8
}

指针的类型要和他所指向的对象严格匹配，有两种例外：

1. 允许令一个指向常量的指针指向一个非常量对象

   1 2	double dval = 3.14; //dval不是常量 const double *ctpr = &dval; //正确，但是不能通过cptr改变dval的值

2. 存在继承关系的类。我们可以将基类的指针或引用绑定到派生类对象上（动态多态）

[!command] 建议：初始化所有指针
使用未经初始化的指针是引发运行时错误的一大原因。

和其他变量一样，访问未经初始化的指针所引发的后果也是无法预计的。通常这一行为将造成程序崩溃，而且一旦崩溃，要想定位到出错位置将是特别棘手的问题。

在大多数编译器环境下，如果使用了未经初始化的指针，则该指针所占内存空间的当前内容将被看作一个地址值。访问该指针，相当于去访问一个本不存在的位置上的本不存在的对象。糟糕的是，如果指针所占内存空间中恰好有内容，而这些内容又被当作了某个地址，我们就很难分清它到底是合法的还是非法的了。

因此建议初始化所有的指针，并且在可能的情况下，尽量等定义了对象之后再定义指向它的指针。如果实在不清楚指针应该指向何处，就把它初始化为nullptr或者0，这样程序就能检测并知道它没有指向任何具体的对象了。

引用

根本上，引用通常只是指针一种形式，只是在指针上的语法糖（Syntactic sugar）。
也可以理解成变量的别名
当我们使用术语“引用”时，通常指的是“左值引用”

1
2
3
4
5
6

int main()
{
	int var = 8;
	int& ref = var;  //ref是var的别名
	std::cout << ref << std::endl;
}

• 引用必须被初始化，一旦定义了引用，就无法将其绑定到其他对象
• 引用本身不是对象，引用本身不占有内存空间（自身没有地址），所以不能定义引用的引用，也不能定义指向引用的指针（指针自身占有内存空间，所以存在对指针的引用）
• 引用只能绑定在对象上，而不能与字面值或某个表达式的计算结果绑定在一起
• 引用的类型要与之绑定的对象严格匹配，有两种例外情况：
  1. 在初始化常量引用时允许用任意表达式作为初始值，只要该表达式的结果能转换成引用的类型即可(编译器内部进行自动转换)。允许为一个常量引用绑定非常量的对象、字面值，甚至是一个一般表达式

     1 2 3 4 5

     int i = 42; const int &r1 = i; const int &r2 = 42; const int &r3 = r1 * 2; int &r4 = r1 * 2;

编译器内部转换的过程

1
2
3
4
5
6

double dval = 3.14；
const int &ri = dval;

//内部转换：使用一个临时对象temp进行转换
const int temp = dval; //由双精度浮点数生成一个临时的整型常量
const int &ri = temp; // 让ri绑定这个临时量

2. 存在继承关系的类。我们可以将基类的指针或引用绑定到派生类对象上（动态多态）

const 关键字

#const

[!NOTE] 重点

1. const 变量只能由常量引用或常量指针绑定，非 const 变量既可以由普通引用/指针绑定，也可以由常量引用/指针绑定。
2. 顶层 const: 对象本身是 const 。底层 const：指针所指的对象或引用绑定的对象是一个常量
3. [[#拷贝操作的区别]]
4. 非 const 指针可以转换为 const 指针，反之不行
5. 当用实参初始化形参时会忽略掉顶层 const。即当形参为 const int x 时，传给它常量或非常量对象都是可以的。
6. 非 const 对象(成员函数)即可以调用 const 对象(成员函数)，也可以调用非 const 对象(成员函数)
7. const对象(成员函数)只能调用const对象(成员函数)，想调用非const对象(成员函数)就需要强转
   

const 变量

• const 变量必须在声明时进行初始化。一旦被初始化，其值就不能再被修改。
• 默认情况下，const 变量被设定为仅在文件内有效，多个文件中出现了同名的 const 变量时，等同于在不同文件中分别定义了独立的变量（ const 默认为内部链接）。可以使用 extern 关键字修改为外部链接。

const 变量与常量的关系

首先我们要明确什么是常量：

• 常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面值常量。
• 常量可以是任何的基本数据类型，可分为整型数字、浮点数字、字符、字符串和布尔值。
• 常量就像是常规的变量，只不过常量的值在定义后不能进行修改。
  也就是诸如 123, 3.141596, true/false/, 'A' 这些都是常量。常量是本来就存在的，我们也不能将通过修改将 1 作为 2 使用。

在 C++ 中，有四种简单的定义常量的方式：

• 使用 #define 预处理器。
• 使用枚举
• 使用 const 关键字。
• 使用 constexpr 关键字

1
2
3
4

#define LENGTH 10 //宏定义不会进行类型检查，不建议使用这种方法定义
enum {length = 10}; //无名的枚举类型
const int length = 10;
constexpr int length = 10;

注意，我们不能把这里的 lenth 叫做常量，它只是一个只读变量！

使用 const 关键字只在编译期间保证该变量被使用时的不变性，无法保证运行期间的行为。 程序员直接修改 const 变量会得到一个编译错误，但是使用间接指针修改内存，只要符合语法则不会得到任何错误和警告。因为编译器无法得知你是有意还是无意的修改，但是既然定义成 const，那么程序员就不应当修改它，不然直接使用变量定义好了。

常量引用

指向常量的引用：常量对象只能用常量引用绑定！
const int &

1
2
3
4

const int ci = 1024;
const int &r1 = ci; //正确,初始化常量引用时允许用任意表达式作为初始值
r1 = 42; //错误，r1是常量的引用，不允许为ci赋值，也就不能通过引用改变ci
int &r2 = ci; //错误，非常量引用不能绑定常量对象。

[!comment] 建议
如果函数无须改变引用形参的值，最好将其声明为常量引用

常量指针

指向常量的指针：类似于常量引用，存放常量对象的地址必须使用常量指针。
const int（同 int const）
对于常量指针，const写在类型之前和类型之后是等价的：

1
2

void f1(const Widget* pw);
void f2(Wiget const* pw);

可以改变指针指向的地址, 不能再去修改指针指向的内容

1
2
3

const int* a = new int;
*a = 2; //error! 不能再去修改指针指向的内容了。
a = (int*)&Age  //可以改变指针指向的地址

• 常量指针也没有规定所指的对象必须是一个常量，所谓指向常量的指针仅仅要求不能通过该指针改变对象的值，没有规定那个对象的值能不能通过其他途径改变。

指针常量

指针本身是常量
int* const

可以改变指针指向的内容, 不能再去修改指针指向的地址

1
2
3

int* const a = new int;
*a = 2; //ok
a = (int*)&Age  //error

const int* const

指针和被指对象都是常量

既不可以改变指针指向的内容, 也不能再去修改指针指向的地址

顶层const、底层const

• 顶层 const：对象本身是个常量
• 底层 const：指针所指的对象或引用绑定的对象是一个常量

1
2
3
4
5
6
7
8
9

int i = 0;
const int ci = 42;  //顶层const， 对象ci本身是个常量
int *const p1 = &i;  //顶层const：p1是指针常量，不可改变指向的地址，即对象p1本身是一个常量。

const int *p2 = &ci; //底层const:p2是常量指针，可以改变指向的地址，所以p2不是常量。不可以改变指向的内容，即指向的ci是一个常量
const int &r = ci;  //用于声明引用的const都是底层const


const int *const p3 = p2; //左边的const是底层const，右边的是顶层const

拷贝操作的区别

顶层const和底层const在执行对象的拷贝操作时区别明显

1. 顶层 const 不受影响：拷入或拷出的对象是否是常量没什么影响

   1 2	i = ci; //正确：拷贝ci的值，ci是一个顶层const p2 = p3; //正确：p2 p3指向的类型相同，p3顶层const的部分不影响。

2. 底层 const 有限制：执行对象的的拷贝操作时，**拷入和拷出的对象必须具有相同的底层 const 资格，或两个对象的数据类型必须能够转换（非 const 指针可以转换为 const 指针 ，反之不行）：

1
2
3
4
5

int *p = p3;  //错误：p3包含底层const的定义，而p没有
p2 = p3;  //正确：p2和p3都是都是底层const
p2 = &i;  //正确：非const变量可以由const引用绑定
int &i = ci;  //错误，const变量不能由非const引用绑定
const int &r2 = i;  //正确：非const变量可以由const引用绑定

const形参和实参

和其他初始化过程一样，当用实参初始化形参时会忽略掉顶层const。即当形参有const时，传给它常量或非常量对象都是可以的。

1
2
3
4
5

void fcn(const int i) { };  //因为忽略了const，所以这句等价于fcn(int i)
void fcn(int i) { };  //等价上句，相当于重新定义了 fcn(int)

//如果调用该函数将会报错
fcn(1); //error: redefinition of ‘void fcn(int)’

常量表达式

常量表达式（const expression）是指值不会改变并且在编译期就能得到计算结果的表达式。

哪些是常量表达式？ #常量表达式

1. 字面值常量
   • 整型和浮点型字面值：12、3.14等
   • 字符和字符串字面值：’a’、”hello world!”等
   • 转义序列：转义序列均以反斜线作为开始，如换行符\n等
   • 指定字面值的类型：1E、3.15L等
   • 布尔字面值：true、bool
   • 指针字面值：nullptr
2. 用常量表达式初始化的 const 对象

一个对象是不是常量表达式由他的数据类型和初始值共同决定

1. 数据类型必须为 const
2. 初始值可以在编译期获取

   1 2 3 4

   const int a = 20; //a是 const int b = a + 1； //b是 int c = 27; //c不是，因为不是const int const int d = get_size(); //d不是，因为初始值get_size()必须在运行时才能获取，不符合在编译过程中获取。

【C++11】constexpr 变量

#constexpr
将变量声明为 constexpr 类型，由编译器来验证变量的值是否是一个常量表达式。声明为 constexpr 的变量一定是一个常量，而且必须用常量表达式初始化

1
2

constexpr int a = 20;
constexpr int b = test(); //该函数必须为constexpr函数

声明constexpr的数据类型必须是“字面值类型”

字面值类型

• 算术类型（包含字符、整形数、布尔值、浮点数）
• 引用和指针（初始值必须是nullptr或0或存储与某个固定地址中的对象）
• [[#字面值常量类]]
• 枚举类型

【C++11】constexpr函数

不能使用普通函数作为constexpr变量的初始值，允许定义一种特殊的constexpr函数，这种函数可以在编译时计算器结果。

[!info] 定义遵循的约定

• 函数的返回类型及所有形参的类型都得是字面值类型
• 函数体中必须有且只有一条return语句

1
2
3
4
5
6

constexpr int new_func()
{
  return 12;
}

constexpr int c = new_func(); //正确，c是常量表达式

执行初始化任务时，编译器把对 constexpr 函数的调用替换成结果值，并且constexpr 函数被隐式指定为内联函数，得以在编译过程中展开。

• constexpr函数体内可以包含其他语句，只要这些语句在运行时不执行任何操作就行，例如空语句、类型别名以及using声明。
• 允许constexpr函数返回值并非一个常量

[!bug] 把内联函数和constexpr函数放在头文件内
和其他函数不一样，内联函数和 constexpr 函数可以在程序中多次定义，不过对于某个给定的内联函数或者 constexpr 函数来说，它的多个定义必须完全一致，因此通常定义在头文件中。

constexpr指针

限定符constexpr只对指针有效，与指针所指的对象无关

1
2

const int *a = nullptr;  //指向整型常量的指针，底层const
constexpr int *b = nullptr; //指针本身是constexpr，顶层const

const成员函数

#const成员函数
const 的第三种用法，他和变量没有关系，而是用在方法名的后面 ( 只有类才有这样的写法 )
本质上是将this指针类型改变为常量指针，因此不能修改类的成员变量。
![[#4 this指针]]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Entity
{
private:
    int m_x,m_y;
public:
    int Getx() const  //const的第三种用法，他和变量没有关系，而是用在方法名的后面 
    {
        return m_x; //不能修改类的成员变量
        m_x = 2; //ERROR!
    }
    
    void Getx(int a) {
        m_x = a; //ok
    }
};

void PrintEntity(const Entity& e)  //const Entity调用const函数 {
    std::cout << e.Getx() << std::endl;
}

int main() {
    Entity e;
}

然后有时我们就会写两个 Getx 版本，一个有 const 一个没有，然后上面面这个传 const Enity & 的方法就会调用 const 的 GetX 版本。

所以，我们把成员方法标记为 const 是因为如果我们真的有一些 const Entity 对象，我们可以调用 const 方法。如果没有 const 方法，那 const Entity & 对象就掉用不了该方法。

[!NOTE]
如果实际上没有修改类或者它们不应该修改类，总是标记你的方法为 const，否则在有常量引用或类似的情况下就用不了你的方法。

注意： const 对象只能调用 const 成员函数

mutable关键字

#mutable

mutable 意为“可变的”，与 constant（即 C++中的 const） 是相反词。

被 const 修饰的函数无法改变类成员变量，把类成员标记为 mutable（可变数据成员），意味着类中的 const 方法可以修改这个成员。即一个 const 成员函数可以改变一个可变数据成员的值。

需要注意的是：mutable 不能修饰 const 和 static 类型的变量。

1
2
3
4
5
6
7
8
9
10
11
12

class Entity
{
private:
    int x = 1;
    mutable int y = 3;
public:
    void change() const 
    {   
      x = 2; //ERROR!表达式必须是可修改的左值
      y = 2; //可以修改！
    }
};

inline 内联函数

#inline
在 C++ 中，可以在定义函数时，在返回值类型前面加上 inline 关键字。增加了 inline 关键字的函数称为“内联函数”。

内联函数和普通函数的区别在于：当编译器处理调用内联函数的语句时，不会将该语句编译成函数调用的指令，而是直接将整个函数体的代码插人调用语句处，就像整个函数体在调用处被重写了一遍一样。

有了内联函数，就能像调用一个函数那样方便地重复使用一段代码，而不需要付出执行函数调用的额外开销。很显然，使用内联函数会使最终可执行程序的体积增加。以时间换取空间，或增加空间消耗来节省时间，这是计算机学科中常用的方法。

• 内联函数中的代码应该只是很简单、执行很快的几条语句。如果一个函数较为复杂，它执行的时间可能上万倍于函数调用的额外开销，那么将其作为内联函数处理的结果是付出让代码体积增加不少的代价，却只使速度提高了万分之一，这显然是不划算的。
  • **另外，需要注意的是，调用内联函数的语句前必须已经出现内联函数的定义（即整个函数体），而不能只出现内联函数的声明。
• 有时函数看上去很简单，例如只有一个包含一两条语句的循环，但该循环的执行次数可能很多，要消耗大量时间，那么这种情况也不适合将其实现为内联函数。

[!warning]
注意将函数定义为 inline 对编译器来说只是一个建议，编译器可以选择忽略该建议。例如递归函数的内联通常会被编译器忽略，因为编译器无法预知递归深度，且会造成代码膨胀。

⭐定义在类内部的成员函数是默认 inline 的

1
2
3
4
5
6
7

class A
{
public:
    void Foo(int x, int y) {  } // 自动地成为内联函数
    //等价
    //inline void Foo(int x, int y) { }
}

如果在类中未给出成员函数定义，而又想内联该函数的话，那在类外要加上 inline，否则就认为不是内联的。

将成员函数的定义体放在类声明之中虽然能带来书写上的方便，但不是一种良好的编程风格，上例应该改成：

1
2
3
4
5
6
7
8
9
10

// a.cpp
class A
{
public:
    void Foo(int x, int y); //声明
}
 
 
// a.h
inline void A::Foo(int x, int y){} //定义

总结：加上 inline 的函数在调用时和普通函数不同，相当于把这段函数展开后复制到执行语句前，减少了时间上的开销，增大了空间开销。C++ 用 inline 关键字较好地解决了函数调用开销的问题。

【C++11】using类型别名

1
2

typedef int zhengxing; //zhengxing是int的类型别名
using zhengxing = int; //等价

【C++11】auto类型说明符

让编译器通过初始值推算变量类型，所以auto定义的变量必须有初始值

在函数返回值 / 范围 for 循环 等情况中使用 auto 时，有 5 种用法

• auto ：拷贝
• auto& ：左值引用，只能接左值（和常量右值）
• auto&& ：万能引用，能接左值和右值
• const auto& ：const 万能引用，能接左值和右值
• const auto&& ：常量右值引用，只能接右值

很多人直接就写 auto&&，但尽量分场景使用

• auto：用于你想修改右值的情形
• auto&：用于你想修改左值的情形
• auto&&：用于泛型编程中的转发
• const auto&：用于只读
• const auto&&：基本没用，基本可被 const auto& 替代（比 const auto& 多一个语义：一定得是右值。然而这没什么用，因为你都不对其进行修改，是左还是右没什么影响）

看下边的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

vector<ElementType> arr;
for(auto ele : arr) {
  // auto, 意味着下边的代码需要修改并使用 ele，但并不影响 arr
  // ...
}

for(auto& ele : arr) {
  // auto&，意味着下边的代码需要修改 arr 中的 ele
  // ...
}

for(const auto& ele : arr) {
  // const auto&，意味着下边的代码无需改动 ele
}

auto&& result = foo(); // auto&& 意味着后边要转发
bar(std::forward<decltype(result)>(result));

也就是说，4 种情形后边代表的语义是不一样的

比如明明不需要修改值的场合却用了 auto&&赋予了修改权限

所以一般情况下，我默认选择的是 const auto&，如果发现需要修改，再选择 auto&或auto（函数返回值如果是右值，是不用标记为 && 的，并且赋值处也不需要写上 &&，编译器会把这个部分优化掉）

在泛型编程的转发情况中，选择 auto&&（非转发情况就跟上边的一样）

auto&& 还有一种特殊情况，就是需要区分是左值引用还是右值引用的情形（这属于超级高级的优化了）

1
2
3
4
5

auto&& result = foo();
if constexpr (std::is_lvalue_reference_v<decltype(result)>)
  // 左值引用情形
else // std::is_rvalue_reference_v<decltype(result)>
  // 右值引用情形

类型别名

除auto之外类型名过长的时候也可以使用 using 或 typedef 方法：

1
2
3
4

using DeviceMap = std::unordered_map<std::string, std::vector<Device*>>;
typedef std::unordered_map<std::string, std::vector<Device*>> DeviceMap;

const DeviceMap& devices = dm.GetDevices();

【C++11】decltype类型指示符

#decltype
decl/type：declare type（声明类型）
作用：并返回操作数的数据类型
从表达式的类型推断出要定义的变量的类型，但是不用该表达式的值初始化变量。

1

decltype(func()) sum = x; //sum的类型就是函数func()的返回类型

如果decltype使用的表达式是一个变量，则返回该变量的类型

1
2
3
4
5

const int a = 0, &b = a; 
decltype(a) x = 0;  //x的类型是const int
decltype(b) y = x;  //y的类型是const int&,y绑定到变量x
decltype(b) z;  //错误，z是引用，必须初始化
//引用从来都作为其所指对象的同义词出现，只有在用在decltype处是一个例外。

如果decltype使用的表达式是不是一个变量，则返回表达式结果对应的类型。

1
2
3
4
5
6
7

//decltype的结果可以是引用类型
int i = 42, *p = &i, &r = i;
decltype(r + 0) b; //加法结果是int，所以b是一个（未初始化）的int

//decltype的表达式如果加上了括号，编译器会把它当成一个表达式，得到引用类型
decltype((i)) d; //错误，d是int &，必须初始化
decltype(i) e;  //正确，e是一个（未初始化的）int

[!bug] 多层括号
decltype((i))（注意是双层括号）的返回结果永远是引用，而decltype(i)的返回结果只有当i本身是引用时才是引用

枚举enum

#enum #枚举

• 枚举类型(enumeration ）将一组整型常数组织在一起。
• 默认情况下，编译器设置第一个 枚举变量值为 0，下一个为 1，以此类推（也可以手动给每个枚举量赋值），且 未被初始化的枚举值的值默认将比其前面的枚举值大 1。 ）

分类：

• 【C++11】限定作用域的枚举类型，默认成员类型位int

  1 2 3 4

  //限定作用域的枚举类型 //关键字enum class + 枚举类型名 + {枚举成员}; enum class color{red, yellow, green}; enum struct color{red, yellow, green}; //等价

• 不限定作用域的枚举类型，无默认类型，分配一个足够容纳枚举值的类型

  1 2 3 4 5

  //不限定作用域的枚举类型，省略关键字class或struct enum color{red, yellow, green}; //未命名的、不限定作用域的枚举类型 enum {red = 1, yellow = 2, green = 3};

在限定作用域的枚举类型中，枚举成员的名字遵循常规的作用域准则，并且在枚举类型的作用域外是不可访问的。
与之相反，在不限定作用域的枚举类型中，枚举成员的作用域与枚举类型本身的作用域相同：

1
2
3
4
5
6
7
8

enum color {red, yellow, green};  //不限定作用域的枚举类型
enum stoplight (red, yellow, green};  //错误：重复定义了枚举成员
enum class peppers {red, yellow, green};//正确：枚举成员被隐藏了
color eyes = green;  //正确：不限定作用域的枚举类型的枚举成员位于有效的作用域中
peppers p = green;   //错误：peppers的枚举成员不在有效的作用域中
						//color::green在有效的作用域中，但是类型错误
color hair = color::red;  //正确：允许显式地访问枚举成员
peppers p2 = peppers::red;  //正确：使用pappers的red

【C++11】指定enum的大小

只能指定不同大小的整型！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

enum example : unsigned char //将类型指定成unsigned char，枚举变量变成了8位整型，减少内存使用。  char型是大小为1字节（8位）的整型
{
 Aa, Bb = 10, Cc
};

enum intValues unsigned long long //将类型指定成unsigned longlong
{
		charTyp = 255,shortTyp = 65535,intTyp = 65535,
		longTyp = 4294967295UL,
		1ong_ongTyp = 18446744073709551615ULL
}

enum example : float  //错误！枚举量必须是一个整数，float不是整数（double也不行）。
{
 Aa, Bb = 10, Cc
};

【C++11】枚举类型的前置声明

提前声明 enum，前置声明必须指定其成员的类型

1
2
3

//不限定作用域的枚举类型intValues的前置声明
enum intvalues : unsigned long long;//不限定作用域的，必须指定成员类型
enum class open modes;  //限定作用域的枚举类型可以使用默认成员类型int

枚举的定义和初始化

可利用新的枚举类型 example 声明这种类型的变量 example Dd，可以在定义枚举类型时定义枚举变量：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

//普通定义+初始化
enum  example 
{
     Aa, Bb, Cc
}
example Dd = Aa;

//在声明枚举的时候直接定义了枚举变量Dd,并初始化为Aa 
enum  example 
{
     Aa, Bb, Cc
}Dd = Aa; 

//只定义Dd而不初始化
enum  example 
{
     Aa, Bb, Cc
}Dd
Dd=Aa

与基本变量类型不同的地方是，在不进行强制转换的前提下，只能将定义的枚举量赋值给该种枚举的变量 (非绝对的，可用强制类型转换将其他类型值赋给枚举变量)

1
2
3
4

Dd = Bb; //ok
Dd = Cc; //ok

Dd = 5; //Error!因为5不是枚举量

枚举量可赋给非枚举变量

1

int a = Aa; //ok.枚举量是符号常量，赋值时编译器会自动把枚举量转换为int类型。

对于枚举，只定义了赋值运算符，没有为枚举定义算术运算 ，但能参与其他类型变量的运算

1
2
3

Aa++;          //非法！
Dd = Aa + Cc   //非法！
int a = 1 + Aa //Ok,编译器会自动把枚举量转换为int类型。

可以通过强制转换将其他类型值赋给枚举变量

1
2
3
4
5

Dd = example(2);
//等同于
Dd = Cc
//若试图将一个超出枚举取值范围的值通过强制转换赋给枚举变量
Dd = example(10); //结果将是不确定的，这么做不会出错，但得不到想要的结果

枚举应用

枚举和 switch 是最好的搭档：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

enum enumType{
    Step0, Step1, Step2
}Step=Step0;      //注意这里在声明枚举的时候直接定义了枚举变量Step,并初始化为Step0 

switch (Step)
{
case Step0:{…;break;}

case Step1:{…;break;}

case Step2:{…;break;}

default:break;
}

位域

类可以将其（非static）成员定义为位域（bit-field）, 位域的类型必须是整型或枚举类型（通常声明为unsigned int）。
位域的声明形式是在成员名字之后紧跟一个冒号以及一个常量表达式，该表达式用于指定成员所占的二进制位数:

1
2
3
4
5
6
7
8
9
10
11
12
13

struct <位域结构名>
{
   ...
   <类型说明符> <位域名> : <位域长度> // 位域列表
   ...
};

struct Demo
{
 int a : 8;
 int b : 2;
 int c : 4;
};

位域，就是把一个字节中的二进制位划分为不同的区域，并说明每个区域的位数。这样就可以把几个不同的对象用一个字节的二进制位域来表示。

有些信息在存储时，并不需要占用一个完整的字节，而只需要占一个或几个二进制位。例如在存放一个开关量时，只有 0 和 1 两种状态，只需要用一位二进制位即可。这样可以节省内存

ue 中通常用位域表示 bool，字段后面都加了 ：1，连续八个这种类型的变量才占一个字节，而一个 bool 就要占一字节。

1

uint32 bPending: 1

注意事项：

1. 一个位域必须存储在同一个字节中，不能跨字节存储。如一个字节所剩空间不能存储下一个位域的时候，应从下一个字节开始存储。也可以有意使某个位域从下一单元开始，如：

   1 2 3 4 5 6 7

   struct Demo { int a : 4; int : 0;//空域 int b : 6;//从第二个字节开始存放 }; //在这个位域定义中，a占第一个字节的4bit，这个字节的另4bit填0表示不使用，b从第二个字节开始，占4bit。

2. 由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说位域的不能超过8bit；

3. 位域可以无位域名，这时它只用作填充或调整位置。无名的位域是不能使用的。例如：

二、字符串和数组

数组

• C++ 数组就是表示一堆的变量组成的集合，一般是一行相同类型的变量。

初始化数组

1
2

int a[] = {0,1,2,}
int b[5] = {0,1,2,0,0} //多的元素初始化为默认值

[!bug] 不允许拷贝和赋值
不能将数组的内容拷贝给其他数组作为其初始值，也不能用数组为其他数组赋值

1
2
3

int a[] = {0,1,2};
int b[] = a; //错误
b = a; //错误

数组的特殊性

字符数组：用字符串字面值对数组初始化，使用这种方式时注意字符串字面值的结尾处还有一个’\0’空字符，这个空字符也被拷贝到字符数组中去。

1

const char a[6] = “abcdef”; //错误，没有空间存放空字符，数组大小至少为7

直接使用数组名字时，编译器自动将其转换为指向数组首元素的指针。

1
2

string nums[] = {"one","two"."three"};
string *p2 = nums; //等价于p2 = &nums[0]

当使用decltype关键字时，转换不会发生：

1
2

//返回的仍是数组类型
decltype（nums） num =  {"one","two"."three"};

数组的下标是 size_t 无符号类型，定义在 cstddef 头文件中，内置的下标运算符所用的索引值是有符号类型，可以处理负数下标，只是我们用负数作为下标的情况比较少。
而标准库类型限定使用下标必须是无符号类型

【C++11】标准库函数begin和end

数组的指针也是迭代器。数组的begin和end函数与容器中的begin和end成员函数类似，但数组不是类，所以这里的begin和end不是成员函数，直接调用即可

1
2
3
4
5

int ia[] = {1,2,3,4,5};
int *beg = begin(ia); //指向ia首元素的指针
int *last = end(ia); //指向ia尾元素的下一位置的指针

cout << *beg << endl; //返回1

两个指针相减的结果是一种名为ptrdiff_t的带符号类型。

栈数组和堆数组

• 不能把栈上分配的数组（字符串）作为返回值，除非你传入的参数是一个内存地址。
• 如果你想返回的是在函数内新创建的数组，那你就要用 new 关键字来创建。
• 栈数组int example[5]; 堆数组int* another = new int[5];

1
2
3
4
5
6
7
8
9
10
11

int main()
{
    int example[5]; //这个是创建在栈上的，它会在跳出这个作用域时被销毁
    for (int i = 0; i< 5;i++) //5个元素全部设置为2
    example[i] = 2; 
    int* another = new int[5];//这行代码和之前的是同一个意思，但是它们的生存期是不同的.因为这个是创建在堆上的,实际上它会一直存活到直到我们把它销毁或者程序结束。所以你需要用delete关键字来删除它。
    for (int i = 0; i< 5;i++) //5个元素全部设置为2
    another[i] = 2; 
    delete[] another;
    std::cin.get();
}

上述的两个数组在内存上看都是一样的，元素都是 5 个 2；
那为什么要使用 new 关键字来动态分配，而不是在栈上创建它们呢？最大的原因是因为生存期, 因为 new 分配的内存，会一直存在，直到你手动删除它。
如果你有个函数要返回新创建的数组，那么你必须要使用 new 来分配，除非你传入的参数是一个内存地址。

字符串

#char

• 字符型变量用于显示单个字符
• 字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元

1
2
3
4
5
6
7
8
9
10
11
12

int main() {
	
	char ch = 'a';
	//ch = "abcde"; //错误，不可以用双引号
	//ch = 'abcde'; //错误，单引号内只能引用一个字符

	cout << (int)ch << endl;  //查看字符a对应的ASCII码
	ch = 97; //可以直接用ASCII给字符型变量赋值
	cout << ch << endl;     //输出的是97对应的字符a

	return 0;
}

c++中的string是字符串类，const char * 是字符串常量指针。

c_str()

虽然 C++ 提供了 string 类来替代C语言中的字符串，但是在实际编程中，有时候必须要使用C风格的字符串（例如打开文件时的路径），为此，string 类为我们提供了一个转换函数 c_str()，该函数能够将 string 字符串转换为C风格的字符串，并返回该字符串的 const 指针（const char*）。请看下面的代码：

1
2
3

//为了使用C语言中的 fopen() 函数打开文件，必须将 string 字符串转换为C风格的字符串。
string path = "D:\\demo.txt";
FILE *fp = fopen(path.c_str(), "rt");

C++ 字符串字面量

• 字符串字面量就是双引号中的内容。
• 字符串字面量是存储在内存的只读部分的，不可对只读内存进行写操作。
• C++11 以后，默认为const char*, 否则会报错。

1
2
3
4
5
6
7
8
9
10

char* name = "cherno";//Error!
name[2] = 'a'; 
//ERROR! 未定义行为；是因为你实际上是在用一个指针指向那个字符串字面量的内存位置，
//但字符串字面量是存储在内存的只读部分的，而你正在试图对只读内存进行写操作
--------------------------------------
const char* name = "cherno"; //Ok!
name[2] = 'a'; //ERROR!const不可修改
//如果你真的想要修改这个字符串，你只需要把类型定义为一个数组而不是指针
char name[] = "cherno"; //Ok!
name[2] = 'a'; //ok

• 从 C++11 开始，有些编译器比如 Clang，实际上只允许你编译const char*, 如果你想从一个字符串字面量编译 char, 你必须手动将他转换成char*

1
2

char* name = (char*)"cherno"; //Ok!
name[2] = 'a'; //OK

• 别的一些字符串

基本上，char 是一个字节的字符，char16_t 是两个字节的 16 个比特的字符（utf16），char32_t 是 32 比特 4 字节的字符（utf32），const char 就是 utf8. 那么 wchar_t 也是两个字节，和 char16_t 的区别是什么呢？事实上宽字符的大小，实际上是由编译器决定的，可能是一个字节也可能是两个字节也可能是 4 个字节，实际应用中通常不是 2 个就是 4 个（Windows 是 2 个字节，Linux 是 4 个字节），所以这是一个变动的值。如果要两个字节就用 char16_t，它总是 16 个比特的。

1
2
3
4
5

const char* name = "lk";
const wchar_t* name2 = L"lk";
const char16_t* name3 = u"lk";
const char32_t* name4 = U"lk";
const char* name5 = u8"lk";

string_literals

1
2
3
4
5
6
7
8
9
10

#include <iostream>
#include <string>

int main() {
    using namespace std::string_literals;

    std::string name0 = "hbh"s + " hello";

    std::cin.get();
}

string_literals 中定义了很多方便的东西，这里字符串字面量末尾加 s，可以看到实际上是一个操作符函数，它返回标准字符串对象（std::string）

然后我们就还能方便地这样写等等：

1

std::wstring name0 = L"hbh"s + L" hello";

string_literals 也可以忽略转义字符

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <iostream>
#include <string>

int main() {
    using namespace std::string_literals;

    const char* example =R"(line1
    line2
    line3
    line4)"

    std::cin.get();
}

printf

用于格式化输出字符串

1

printf("The number is: %d", num);

常用
%c char 字符
%d 有符号十进制整数（d 代表了”decimal”十进制）
%f 浮点数、十进制记数法（默认输出六位小数，使用 %.2f 指定为指定为两位小数）
%s 字符串

其他：
%a 浮点数、十六进制 bai 数字和 p-记法（C99）
%e 浮点数、e-记数法
%g 根据数值不同自动选择％f 或％e．
%i 有符号十进制数（与％d 相同）
%o 无符号八进制整数
%p 指针
%u 无符号十进制整数
%x 使用十六进制数字 0f 的无符号十六进制整数
%% 打印一个百分号
等等

使用案例：

输出整数

1
2
3
4

printf("%d",-12)//有符号
//-12
printf("%u",-12)//无符号
//12

输出小数（默认输出六位小数）

1
2

printf("%f",12.3)
//12.300000

输出字符

1
2

printf("%s","ww")
//ww

按照指定位数输出整数

1
2
3
4

printf("%2d\n",1234);//指定位数小于实际位数，按照实际位数输出
//12
printf("%5d",1234);//大于，默认右对齐，缺的用空格补齐
// 1234

按照指定位数输出小数

1
2
3
4
5
6
7
8
9
10
11

printf("%1.3f\n",123.456);//整数部分指定位数小于实际位数，按照实际位数输出
//123.456
printf("%9.3f\n",123.456);//整数部分指定位数大于实际位数，默认右对齐，缺的空格补齐,小数点也算一位
//  123.456
printf("%3.2f\n",123.456);//小数部分指定位数小于实际位数，默认四舍五入
//123.46
printf("%3.5f",123.456);//小数部分指定位数大于实际位数，缺的0补齐
//123.45600

printf("%.2f\n",123.456);//保留两位小数，默认四舍五入
//123.46

添加填充

1
2

printf("%08d",123);//默认以0填充
//00000123

三、表达式

1 左值与右值 (lvalue and rvalue)

[!NOTE] 简单总结

• 当一个对象被用作左值的时候，用的是对象的地址（在内存中的位置）

• 当一个对象被用作右值的时候，用的是对象的值（内容）

• 左值有地址和值，可以出现在赋值运算符左边或者右边。

• 右值只有临时值，无地址，只能在右边

1. 左值：
   有地址 数值 有存储空间的值，往往长期存在； 左值是由某种存储支持的变量；左值有地址和值，可以出现在赋值运算符左边或者右边。

2. 左值引用:

• 非 const 的左值引用只接受左值
• const 左值引用。兼容右值和左值。
  为什么？

3. 右值：
   是临时量，无地址（或者说有地址但访问不到，它只是一个临时量） 没有存储空间的短暂存在的值 。

4. 右值引用：
   右值引用只能引用右值，不能绑定到左值，可以通过 const 引用或者右值引用延长右值的生命周期

5. 在给函数形参列表传参时，有四种情况：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include<iostream>
void PrintName(std::string name) // 可接受左值和右值 {
    std::cout<<name<<std::endl;
}
void PrintName(std::string& name) // 只接受左值引用，不接受右值 {
    std::cout << name << std::endl;
}
void PrintName(const std::string& name) // 接受左值和右值，把右值当作 const lvalue& 
{
    std::cout << name << std::endl;
}
void PrintName(std::string&& name) // 接受右值引用 {
    std::cout << name << std::endl;
}
int main() {
    std::string firstName = "yang";
    std::string lastName = "dingchao";
    std::string fullName = firstName + lastName; //右边的表达式是个右值。
    PrintName(fullName);
    PrintName(firstName+lastName);
    std::cin.get();

右值引用

常规引用称为”左值引用“

”右值引用“就是必须绑定到右值的引用，通过&&获得。
”右值引用“只能绑定到右值（右值是临时的，没有地址），因此可以自由的将右值引用的资源“移动” 到另一个对象中。

1
2
3
4
5
6

int i = 42;
int &r = i;  //正确：r引用i
int &&rr = i;  //错误：不能将一个右值引用绑定到一个左值上
int &r2 = i * 42;  //错误：i * 42是一个右值
const int &r3 =i * 42;  //正确：我们可以将一个const的引用绑定到一个右值上
int &&rr2 = i * 42;  //正确：将rr2绑定到右值上

右值引用的优势：

如果我们知道传入的是一个临时对象的话，那么我们就不需要担心它们是否活着，是否完整，是否拷贝。我们可以简单地偷它的资源，给到特定的对象，或者其他地方使用它们。因为我们知道它是暂时的，它不会存在很长时间。而如果如上使用 const string& str，虽然可以兼容右值，但是却不能从这个字符串中窃取任何东西！因为这个 str 可能会在很多函数中使用，不可乱修改！（所以才加了 const）

2 递增递减运算符

[!comment] 建议：除非必须，否则不用递增递减运算符的后置版本
前置版本避免了不必要的工作，它把值加1后直接返回了改变了的运算对象。

后置版本需要将原始值存储下来以便于返回这个未修改的内容，如果我们不需要修改前的值，那么后置版本的操作就是一种浪费。

现代编译器中它门的性能差距非常小，可以忽略不计。

在 C++ 中，前置递增运算符（++i）和后置递增运算符（i++）是用于增加变量值的运算符。它们的区别在于它们返回的值和执行的顺序。

前置递增运算符（++i）：

• 先将变量递增，然后返回递增后的值。
• 例如，int i = 5; int a = ++i;，a 的值为 6，i 的值也为 6。

后置递增运算符（i++）：

• 先返回变量原始值，然后再将变量递增。
• 例如，int i = 5; int a = i++;，a 的值为 5，而 i 的值会在语句结束之后变为 6。

需要注意的是，在表达式中使用这两种递增运算符时可以产生不同的结果。例如：

1
2
3
4

int i = 5;
cout << ++i << endl; // 输出：6
int i = 5;
cout << i++ << endl; // 输出：5

3 箭头操作符->

1. 特点：

• 箭头运算符必须是类的成员。
• 一般将箭头运算符定义成了 const 成员，这是因为与递增和递减运算符不一样，获取一个元素并不会改变类对象的状态。

2. 对箭头运算符返回值的限定

箭头运算符的重载永远不能丢掉成员访问这个最基本的含义。当我们重载箭头时，可以改变的是箭头从哪个对象当中获取成员，而箭头获取成员这一事实则永远不变。
对于形如 point->mem 的表达式来说，point 必须是指向类对象的指针或者是一个重载了 operator-> 的类的对象。 根据 point 类型的不同，point->mem 分别等价于

1
2
3
4

point->mem;

(*point).mem; //point 是一个内置的指针类型, 点运算符获取类对象的一个成员
point.operator()->mem; //point是类的一个对象

重载的箭头运算符必须返回类的指针或者自定义了箭头运算符的某个类的对象。

3. 三种应用场景

1. 可用于指针调用成员：p->x 等价于 (* p).x (最常见的情况)

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   class Entity { public: int x; }; int main() { Entity e; Entity* ptr = &e; //两种方式等价 (*ptr).x=2; ptr->x = 2; }

2. 重载箭头操作符

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

   #include <iostream> class Entity { private: int x; public: void Print() { std::cout << "Hello!" << std::endl; } }; class ScopedPtr { private: Entity* m_Ptr; public: ScopedPtr(Entity* ptr): m_Ptr(ptr) { } ~ScopedPtr() { delete m_Ptr; } Entity* operator->() //重载操作符 { return m_Ptr; } }; int main() { { ScopedPtr entity = new Entity(); entity->Print(); } std::cin.get(); }

进一步, 可以写为 const 版本的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#include <iostream>
class Entity
{
private:
    int x;
public:
    void Print() const   //添加const {
        std::cout << "hello!" << std::endl;
    }
};

class ScopedPtr
{
private:
    Entity* m_Ptr;
public:
    ScopedPtr(Entity* ptr)
        : m_Ptr(ptr)
    {
    }
    ~ScopedPtr()
    {
        delete m_Ptr;
    }
    Entity* operator->()
    {
        return m_Ptr;
    }
    const Entity* operator->() const //添加const
    {
        return m_Ptr;
    }
};

int main() {
    {
        const ScopedPtr entity = new Entity(); //如果是const，则上面代码要改为const版本的。
        entity->Print();
    }
    std::cin.get();
}

3. 可用于计算成员变量的 offset：

引自 B 站评论：
因为 “指针 -> 属性” 访问属性的方法实际上是通过把指针的值和属性的偏移量相加，得到属性的内存地址进而实现访问。 而把指针设为 nullptr(0)，然后 -> 属性就等于 0 + 属性偏移量。编译器能知道你指定属性的偏移量是因为你把 nullptr 转换为类指针，而这个类的结构你已经写出来了 (float x,y,z)，float4 字节，所以它在编译的时候就知道偏移量 (0,4,8)，所以无关对象是否创建

1
2
3
4
5
6
7
8
9
10

struct vec2
{
    int x,y;
    float pos,v;
};
int main() {   
    int offset = (int)&((vec2*)nullptr)->x; // x,y,pos,v的offset分别为0,4,8,12
    std::cout<<offset<<std::endl;
    std::cin.get();
}

4 sizeof 运算符

返回一条表达式或一个类型所占的字节数，结果是 size_t 类型的常量表达式。

1
2
3

// 两种形式：
sizeof(type);
sizeof expr; //返回表达式结果类型的大小

5 强制类型转换

c 风格强制类型转换

直接用括号进行转换，可以实现 cast 相同功能，缺点是表现形式不清晰，不容易 debug。

• 形式一：C 语言风格的转型语法：

1

(T)expression     //将expression转换为T类型

• 形式二: 函数风格的转型：

1

T(expression)     ////将expression转换为T类型

上面两种形式并无差别，只是小括号摆放位置不同。

static_cast

static_cast 用于进行比较 “自然” 和低风险的转换

1. 基本类型如整型和浮点型、字符型之间的互相转换。
2. 指针/引用类型之间的转换，不执行运行时类型检查，可能不安全。

任何具有明确定义的类型转换，只要不包含底层 const，都可以使用 static_cast。

1
2

double dPi = 3.1415926;
int num = static_cast<int>(dPi);  //num的值为3

reinterpret_cast

reinterpret：重新解释

reinterpret_cast 用于进行各种不同类型的指针之间强制转换。

通常为运算对象的位模式提供较低层次上的重新解释。危险，不推荐。

1
2

int *ip;
char *pc = reinterpret_cast<char *>(ip);

const_cast

const_cast<T> 中的类型必须是指针、引用，用于去除指针或引用的 const 或 volatile 属性。

使用场景：const 对象（或 const 成员函数）调用非 const 成员函数，必须将 const 去掉才能调用。

1
2
3
4
5
6
7
8

class MyClass {
public:
    void func() { /* ... */ } //非 const 成员函数
};

const MyClass obj;
MyClass* obj_ptr = const_cast<MyClass*>(&obj); // 删除const属性，使得可以调用非const成员函数
obj_ptr->func(); // 调用非const成员函数

使用 const_cast 可能导致未定义的行为，因此应谨慎使用。

运行时类型识别

RTTI 即通过运行时类型识别，程序能够使用基类的指针或引用来检查着这些指针或引用所指的对象的实际派生类型。

C++ 是一种静态类型语言。在静态类型语言中，变量的类型在编译时确定，，不能在运行时更改。然而由于面向对象程序设计中多态性的要求，C++中的指针或引用(Reference)本身的类型，可能与它实际代表(指向或引用)的类型并不一致。有时我们需要将一个多态指针转换为其实际指向对象的类型，就需要知道运行时的类型信息，这就产生了运行时类型识别的要求。

运行时类型识别（run-time type identification,RTTI）由两个运算符实现：

• typeid运算符，用于返回表达式的类型
• dynamic_cast运算符，用于将基类的指针或引用安全地转换成派生类的指针或引用。

dynamic_cast

[!NOTE] 总结

• 子类向父类转换（向上转换）可以使用 static_cast 或 dynamic_cast 。向上转换始终是安全的，没必要使用 dynamic_cast，它会增加运行时的开销。我们通常使用隐式转换即可。
• 父类向子类转换（向下转换）必须使用 dynamic_cast ，且要保证父类有虚函数。

1. dynamic_cast 运算符，用于将基类的指针或引用安全地转换成派生类的指针或引用， 如果转换失败会返回空指针（对于指针）或 std::bad_cast 异常（对于引用）。
2. 使用时需要保证是多态，即只能用于基类含有虚函数的类。
3. 支持运行时类型识别。

适用于以下情况：我们想使用基类对象的指针或引用执行某个派生类操作并且该操作不是虚函数。

使用形式：
其中，type 必须是一个类类型，并且通常情况下该类型含有虚函数。

1
2
3

dynamic cast<type*> (e) //e必须是一个有效的指针
dynamic cast<type&> (e) //e必须是一个左值
dynamic cast<type&&> (e) //e不能是左值

在上面的所有形式中，e 的类型必须符合以下三个条件中的任意一个：

• e 的类型是目标 type 的公有派生类
• e 的类型是目标 type 的公有基类
• e 的类型就是目标 type 的类型。
  如果符合，则类型转换可以成功。否则，转换失败。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include <iostream>
using namespace std;

class Parent
{
public:
    virtual ~Parent() {} 

    int x = 1;
    int y = 2;
};

class Son : public Parent
{
public:
    int z = 123;
};

int main()
{
    // 创建父类指针指向子类对象，这里进行了隐式【向上转换】
    Parent *parent = new Son();

    // 如果想访问子类创建的成员，需要进行【向下转换】
    if(Son* son = dynamic_cast<Son*>(parent))
    {
        // 访问子类的成员变量
        cout << son->z << endl; // 输出123
    }
    else
    {
        cout << "转换失败" << endl;
    }
}

[!NOTE]
可以对一个空指针执行 dynamic_cast，结果是所需类型的空指针

typeid运算符

typeid运算符允许向程序表达式提问：你的对象是什么类型？

1
2

typeid(e)  //e可以是任意表达式或类型的名字
//返回一个常量对象的引用，该对象的类型时标准库类型type_info或type_info的公有派生类型（type_info类在不同编译器上有所区别）。

typeid运算符可以作用于任意类型的表达式。和往常一样，顶层const被忽略，如果表达式是一个引用，则typeid返回该引用所引对象的类型。不过当typeid作用于数组或函数时，并不会执行向指针的标准类型转换。也就是说，如果我们对数组a执行typeid(a),则所得的结果是数组类型而非指针类型。

• 当运算对象不属于类类型或者是一个不包含任何虚函数的类时，typeid 运算符指示的是运算对象的静态类型。
• 而当运算对象是定义了至少一个虚函数的类的左值时，typeid 的结果直到运行时才会求得。

通常我们使用typeid比较两条表达式的类型是否相同，或者比较一条表达式的类型是否与指定类型相同：

1
2
3
4
5
6
7
8
9
10

Derived *dp = new Derived;
Base *bp = dp;
//两个指针都指向Derived对象
//在运行时比较两个对象的类型
if (typeid(*bp)==typeid(*dp)){
//bp和dp指向同一类型的对象
}
//检查运行时类型是否是某种指定的类型
if (typeid(*bp)==typeid(Derived)){
//bp实际指向Derived对象

type_info 类

type_info 类的精确定义随着编译器的不同而略有差异。不过，C++标准规定 type_info 类必须定义在 typeinfo 头文件中，并且至少提供表 19.1 所列的操作。

除此之外，因为 type_info 类一般是作为一个基类出现，所以它还应该提供一个公有的虚析构函数。当编译器希望提供额外的类型信息时, 通常在 type_info 的派生类中完成。
type_info 类没有默认构造函数，而且它的拷贝和移动构造函数以及赋值运算符都被定义成删除的。因此，我们无法定义或拷贝 type_info 类型的对象，也不能为 type_info 类型的对象赋值。创建 type_info 对象的唯一途径是使用 typeid 运算符。
type_info 类的 name 成员函数返回一个 C 风格字符串，表示对象的类型名字。对于某种给定的类型来说，name 的返回值因编译器而异并且不一定与在程序中使用的名字一致。对于 name 返回值的唯一要求是，类型不同则返回的字符串必须有所区别。例如:

1
2
3
4
5
6
7
8
9
10
11
12
13

int arr [10];
Derived d;
Base *p = &d;

cout << typeid (42).name ( ) << ","
     <<typeid(arr) .name () <<","
     <<typeid (Sales_data) .name () << ",“
     <<typeid(std: :string) .name ()<< ",”
     <<typeid(p).name ( ) << "，"
     <<typeid(*p) .name () <<endl;
 //输出
 //i， A10_i, 10sales_data, Ss,P4Base, 7Derived

type_info 对象是在编译的时候决定其内容的，作为静态数据存在于最终生成的目标代码里。编译器会在静态存储空间里为这些 type_info 对象分配空间，并生成代码来初始化它们的内容。

类型转换函数（类型转换运算符）

又称类型转换运算符，使用类型转换函数可以将该类类型转换为其他类型。
用法：P514

一个类型转换函数必须是类的成员函数，他不能声明返回类型，形参列表也必须为空。类型转换函数通常是 const 函数。
operator type () const

6 运算符优先级

从上到下优先级递减

四、控制流

switch

执行多条件分支语句

注意1：switch语句中表达式类型只能是整型或者字符型
注意2：case里如果没有break，那么程序会一直向下执行

总结：与if语句比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

switch(表达式)

{

	case 结果1:
		执行语句;
		break;

	case 结果2
		执行语句;
		break;

	...

	default:
		执行语句;
		break;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

int main() 
{
	//请给电影评分 
	//10 ~ 9   经典   
	// 8 ~ 7   非常好
	// 6 ~ 5   一般
	// 5分以下 烂片
	int score = 0;
	cout << "请给电影打分" << endl;
	cin >> score;

	switch (score)
	{
		case 10:
		case 9:
			cout << "经典" << endl;
			break;
			
		case 8:
			cout << "非常好" << endl;
			break;
			
		case 7:
		case 6:
			cout << "一般" << endl;
			break;
			
		default:
			cout << "烂片" << endl;
			break;
	}
	system("pause");
	return 0;
}

for

1
2
3
4
5

//语法形式
for(init-statement;condition;expression)
{
		statement;
}

语句头多重定义

init-statement可以定义多个对象，但是只能由一条声明语句，因此，所有变量的基础类型必须相同。

1
2
3
4
5

//init-statement定义了两个对象：i和sz
for(decltype(v.size()) i = 0, sz = v.size(); i!=sz; ++i)
{
		v.pushback(v[i]);
}

省略语句头的某些部分

for语句头能省略掉init-statement、condition、expression中的任何一个（或全部）。

省略condition：等价于在条件部分写了一个true，所以循环体内必须有语句负责退出循环，否则将会无限循环。

省略expression：要求condition部分或者循环体必须有改变迭代变量的值。

1
2
3
4
5

vector<int> v;
for(int i; cin>>i; /*expression为空*/)  //condition能改变i的值
{
		v.push_back(i);
}

【C++11】范围for

1
2
3
4
5

//range for语法
for(declaration : expression)
		statement
//expression表示的必须是一个序列，比如用花括号括起来的初始值列表、数组、vector、string，这些类型的共同特点是拥有能返回迭代器的begin和end成员。
//declaration定义一个变量，该变量用于访问序列中的基础元素，每次迭代，该部分的变量都会初始化为expression部分的下一个元素值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//遍历string对象中的每个字符
string str("Hello world!");
for(auto i : str)
{
		cout<<i<<endl;
}

//对string元素执行写操作，必须把循环变量定义为引用类型
for(auto &i : str)
{
		i = 1;  //将string全部改为1
}
// 原理
for(auto beg = v.begin, end = v.end(); beg!=end; ++beg)
{
		auto &i = *beg;
		i = 1;
}

do while

与while的区别在于do…while会先执行一次循环语句，再判断循环条件。

1
2
3

do
		statement;
while(condition);

break

终止离他最近的while、do while、for或swtich语句，并从这些语句之后的第一条语句开始执行。

break使用的时机：

• 出现在switch条件语句中，作用是 终止case 并跳出switch
• 出现在循环语句中，作用是跳出 当前 的循环语句
• 出现在嵌套循环中，跳出 最近的 内层循环语句

continue

终止最近的循环中的当前迭代，并立即开始下一次迭代。

五、函数

函数就是我们写的代码块，被设计为用来执行特定的任务。在 class 中这些代码块则被称为方法 method。

这里所说函数单独指类外的。

每次调用函数，编译器生成一个 call 指令（类外的，因此没有什么动态绑定，也暂时不考虑内联）。这基本上意义着，在一个运行的程序中，为了调用一个函数，我们需要创建一个堆栈结构，这意味着我们必须把像参数这样的东西推进堆栈。我们还需要一个叫做返回地址的东西压入堆栈。然后我们要做的是跳到二进制执行文件的不同部分，以便开始执行我们的函数指令。
为了将 push 进去的结果返回，然后我们得回去到最初调用函数之前。跳跃和执行这些都需要时间，所以它会减慢我们的程序。

而对于 main 函数，返回值是 int，并且只有 main 函数可以不 return——它会自动假设返回 0.（这是现代 C 和 C++ 的一个特性）

1 空形参列表

1
2
3

//形参列表可以为空，下列两种方式等价
void func() {};
void func(void) {};  //兼容c

2 main 处理命令行选项

有时我们需要给main传递实参，一种常见的情况是用户通过设置一组选项来确定函数所要执行的操作。
例如，假定main函数位于可执行文件prog内，我们可以向程序传递下面的选项：

1

prog -d -o ofile date0

这些命令通过两个（可选的）形参传递给main函数

1
2
3
4

int main(int argc, char *argv[]) {......}
int main(int argc, char **argv) {......} //等价表示，其中argv指向char*
//argc表示数组中字符串的数量
//argv是一个数组，他的元素是指向C风格字符串的指针

当实参传递给main函数之后，argv的第一个元素指向程序的名字或者一个空字符串，接下里的元素依次传递命令行提供的是实参，最后一个指针之后的元素值保证为0

例子中，argc的值等于5，argv应该包含如下的C风格字符串：

1
2
3
4
5
6

argv[0] = "prog"; //指向程序的名字或者一个空字符串
argv[1] = "-d";
argv[2] = "-o";
argv[3] = "ofile";
argv[4] = "date0";
argv[5] = "0";  //最后一个指针之后的元素值保证为0

[!warning]
当使用 argv 中的实参时，一定要记得可选的实参从 argv[1]开始；argv[0]保证是程序的名字，而非用户输入

深入理解argc和argv

 argc 是 argument count的缩写，表示传入main函数的参数个数；
 
 argv 是 argument vector的缩写，表示传入main函数的参数序列或指针，并且第一个参数argv[0]一定是程序的名称，并且包含了程序所在的完整路径，所以确切的说需要我们输入的main函数的参数个数应该是argc-1个；

简单用法示例，新建工程键代码：

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>
 
using namespace std;
 
void main(int argc,char *argv[])
{
		for(int i=0;i<argc;i++)
		{
			cout<<"argument["<<i<<"] is: "<<argv[i]<<endl;
		}
		system("pause");
}

argv是指向指针的指针，main函数的第二个参数替换为 char** argv，两者是等价的。

在编译环境下按F5运行，输出如下：

可见，在没有参数传入的情况下，保存程序名称的第一个变量argv[0]依然存在。

传参数给main函数有两种方法，第一种方式是在编译环境中设置，以vs2012为例，右击项目—>属性—>配置属性—>调试—>命令参数，在命令参数中输入，每个参数之间用空格隔开。

之后点击确定并应用，运行之后显示如下：

第二种方式也是经常会用到的方式是通过命令提示符传入。首先需要打开命令提示符窗口，点击开始菜单在“搜索程序和文件”里输入命令“cmd”或者直接按快捷键 Windows+R，在弹出的对话框里输入“cmd”即可打开命令提示符窗口：

打开命令提示符窗口后需要输入生成的exe文件所在的完整路径，一个简便的方法是把exe文件直接拖入提示符窗口即可，之后输入传入参数，以空格分隔，之后回车，显示如下：

如果你坚持要手工输入完整路径的话，你会发现等你“Ctrl+C”路径后，在提示符窗口中按“Ctrl+V”却不能粘贴，这时候可以在窗口中右键单击一下试试，你会发现右键菜单里的粘贴功能还是有效的。

下一个例子演示使用opencv显示一幅图片：

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>
#include <core/core.hpp>
#include <highgui/highgui.hpp>
using namespace std;
using namespace cv;
 
void main(int argc,char **argv)
{
		Mat image=imread(argv[1]);
		imshow("Lena",image);
		waitKey();
}

注意读入的参数是argv[1]，在命令提示符窗口运行：

最后说明一下：一般编译器默认使用argc和argv两个名称作为main函数的参数，但这两个参数如此命名并不是必须的，你可以使用任何符合C++语言命名规范的变量名作为入参，效果是一样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <iostream>
#include <core/core.hpp>
#include <highgui/highgui.hpp>
using namespace std;
using namespace cv;
 
void main(int value,char **point)
{
	for(int i=0;i<value;i++)
	{
		cout<<"argument["<<i<<"] is: "<<point[i]<<endl;
	}
	system("pause");
}

3 【C++11】 含有可变形参的函数

编写处理不同数量形参的函数，C++11有两种方法：

1. 如果所有实参类型相同，可以使用 initialize_list 的标准库类型
2. 如果实参类型不同，可以编写可变参数模板P618

还有一种特殊的形参类型（省略符 .....），可以用它传递可变数量的形参，这种功能一般只用于与 C 函数交互得接口程序。

initialize_list 初始化列表

如果函数的实参数量未知但是全部实参的类型相同，可以使用 initialize_list 类型的形参。initialize_list 是一种标准库类型，用于表示某种特定类型的值的数组。

initialize_list 对象中的元素永远是常量值

1
2
3
4
5
6
7
8
9
10
11
12
13

//例子：输出错误信息
void error_msg (initializer_list<string> il)
{
    for (auto beg = il.begin() ; beg != il.end ( ) ; ++beg)
        cout << *beg << " " ;
    cout cc endl;
}

//也可以同时拥有其他形参
//void error msg(ErrCode e, initializer_list<string> il)
//{
//
//}

如果想向 initializer_list 形参中传递一个值的序列, 则必须把序列放在一对花括号内:

1
2
3
4
5

// expected和actual是string对象
if (expected != actual)
    error__msg( { " functionx" , expected, actual }) ;
else
    error_msg ({"functionx" ,"okay" } ) ;

省略符形参

省略符形参是为了便于 C++程序访问某些特殊的 C 代码而设置的, 这些代码使用了名为 varargs 的 C 标准库功能。通常，省略符形参不应用于其他目的。你的 C 编译器文档会描述如何使用 varargs。

[!bug] Title
省略符形参应该仅仅用于 C 和 C++通用的类型。特别应该注意的是，大多数类类型的对象在传递给省略符形参时都无法正确拷贝。

省略符形参只能出现在形参列表的最后一个位置，它的形式无外乎以下两种:

1
2

void foo (parm_list, ...);
void foo (...);

第一种形式指定了 foo 函数的部分形参的类型，对应于这些形参的实参将会执行正常的类型检查。省略符形参所对应的实参无须类型检查。在第一种形式中，形参声明后面的逗号是可选的。

4 【C++11】尾置返回类型

任何函数的定义都能使用尾置返回，但是这种形式对于返回类型比较复杂的函数最有效，比如返回类型是数组的指针或者数组的引用。

下面的例子是返回一个指向维度为10的数组指针的函数定义方法：

1

int (*func(int i))[10]

下面逐层理解上述例子的含义：

• func(int i)表示调用函数时，需要一个int类型的参数；
• * func(int i)表示对调用func的结果执行解引用的操作；
• (* func(int i))[10]表示解引用之后得到一个维度为10的数组；
• int (* func(int i))[10]表示数组的数据类型为int；

若使用尾置返回类型，上述函数的定义可以写成：

尾置返回类型跟在形参列表后面并以一个 -> 符号开头。为了表示函数真正的返回类型跟在形参列表之后，我们在本应该出现返回类型的地方放置一个 auto：

1
2

// func接受了一个int类型的实参，返回了一个指针，该指针指向一个含有10个整数的数组
auto func(int i) -> int (*)[10];

因为我们把函数的返回类型放在了形参列表之后，所以我们可以很清晰地看到func函数返回的是一个指针，并且该指针指向了一个含有10个整数的数组。

尾置返回类型的另一个好处是我们可以在函数返回类型中使用函数形参相关的信息：

1
2
3
4
5
6
7
8
9
10
11
12
13

template<typename Container, typename Index>    //可以工作，但是需要改良
auto authAndAccess(Container& c, Index i)->decltype(c[i]) //尾置返回类型
{
    authenticateUser();
    return c[i];
}

//错误写法
template<typename Container, typename Index>
decltype(c[i]) authAndAccess(Container& c, Index i) //error
{
    ...
}

在 authAndAccess 函数中，我们使用 c 和 i 指定返回类型。如果我们按照传统语法把函数返回类型放在函数名称之前，c 和 i 就未被声明所以不能使用。

5 默认实参

• 局部变量不能作为默认实参
• 调用含有默认实参的函数时，可以包含该实参，也可以省略该实参
• 设计时尽量让不怎么使用默认值的参数出现在前面

  1 2 3 4 5 6 7 8 9 10

  //函数具有默认实参 string screen(int height = 24, int width = 80, char background = ' '); //函数调用时实参按位置解析，默认实参负责填补函数调用缺少的尾部实参 string window; window = screen(); // 等价于screen(24, 80, ' ') window = screen(66); // 等价于screen(66, 80, ' ') window = screen(66,256); // 等价于screen(66, 256, ' ') window = screen(66,256,'#'); // 等价于screen(66, 256, '#') window = screen( , , "S") // 错误，只能从尾部填充

6 函数指针

#函数指针

1
2
3
4

bool lengthCompare(const string &, const string &);

// 声明一个指向该函数的指针，只需要用指针替换掉函数即可
bool (*pf)(const string &, const string &);

[!NOTE] Title
（*pf）两端的括号必不可少，如果不写括号，则pf是一个返回值为bool指针类型的函数

bool *pf(const string &, const stirng &);

使用函数指针

当把函数名作为一个值使用时，该函数自动转换成指针

1
2
3
4
5

pf = lengthCompare; //pf指向lengthCompare函数
pf = &lengthCompare; //等价，&取地址符是可选的

//使用auto简写
auto pf = lengthCompare;

可以直接使用函数指针调用该函数，无须提前解引用

1
2
3
4
5
6

bool b = pf("hello","world");
bool b = (*pf)("hello","world"); //等价，*解引用符是可选的
bool b = lengthCompare("hello","world"); //等价，常规调用方法

//使用auto简写
auto b = pf("hello","world")

函数指针作为参数

函数指针可以作为一个参数传递给另一个函数。这时函数指针的使用就像普通的常量和变量一样。
当函数指针作为参数传递的时候，这时接收参数传递的函数通常需要根据这个指针调用这个函数。作为参数传递的函数指针通常表示 回调函数（Callback Functions）。

[!NOTE] 回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17