字符串是由零个或多个字符组成的有限串行。

  子串的定义：串中任意个连续的字符组成的子序列，并规定空串是任意串的子串，任意串是其自身的子串

字符串变量与常量

C风格的字符串包括两种：字符串常量和末尾添加了'\0'的字符数组。无论怎么表示，都以'\0'结尾。

字符串变量

• 字符串是一个特殊的字符数组，以空字符'\0'结尾;
• 空字符'\0'自动添加到字符串的内部表示中;
• 在声明字符串变量的时候，要时刻记得为这个空结束符预留一个额外元素的空间：char str[11] = {"helloworld"},十个字符要留11个位置

字符串常量

• 字符串常量就是一对双引号括起来的字符序列："helloworld";
• 字符串常量中的每个元素可以作为一个数组元素访问;
• 字符串常量也是以'\0'结尾的;

字符串的指针表示

1

const char* pStrHelloWorld = "helloworld";

表示一个char型的指针变量，指向内存中一个存储字符串“helloworld”的地址。

定义字符串有两种方式，char[]和char*，要区分以下两个概念：

1. 区分地址本身和地址存储的信息；
2. 区分可变与不可变；

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

int main()
{
	//char strHello[10] = { "helloworld" };  //错误定义，没有给'\0'留空间

	char strHello[11] = { "helloworld" };
	char strHello[] = { "helloworld" };  //这样定义也可以
	//strHello是数组变量，它本身的值是不允许改变的，但是它指向的区域的值strHello[index]是可以改变的
	strHello[2] = '6';    //strHello = he6loworld
	//strHello = { "helloworld" };    //本身不允许改变，编译不通过


	//ptrHello是指针变量，它本身是可以改变的，但是ptrHello[index]指向的值可变与否要取绝与所指向的区间是否可以改变
	const char* ptrHello_1 = "helloworld";  //指针指向常量区(必须要加const)，ptrHello[index]不可改变，但本身指向的地址可以变。
	ptrHello_1 = "change";

	char tmp[7] = "change";
	char* ptrHello_2 = strHello;      //指针指向数组变量，ptrHello[index]可以改变,本身也可以变
	ptrHello_2[2] = 'l';
	ptrHello_2 = tmp;

	return 0;
}

char* pstr是指针，pstr本身可变，pstr[index]是否可变取决于指向的存储区间是否可变；

char str[]是字符串数组，str本身的值不允许改变，但可以改变str[index];

字符串操作

头文件：string.h

  C/C++字符串处理函数，传递给这些标准库函数例程的指针必须具有非零值，并且指向以null结束的字符数组中的第一个元素。其中一些标准库函数会修改传递给它的字符串，这些函数将假定它们所修改的字符串具有足够大的空间接收新字符串，程序员需要保证目标字符串足够大。

字符串遍历

  一般来说，我们使用指针的算数操作来编译C风格的字符串，每次对指针进行测试并递增1，直到到达结束符null为止：

1
2
3
4
5
6

const char *cp = "helloworld";
while(*cp)
{
	//do something
	++cp;
}

字符串长度

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

strlen(s);    //返回字符串s的长度，要注意字符串的长度不包含'\0'。

sizeof(s);   //返回字符串所占用的空间，包含'\0'


int main()
{
	char strA[11] = "helloworld";
	auto n1 = sizeof(strA);     //11
	auto n2 = strlen(strA);     //10


	wchar_t strB[11] = L"helloworld";
	auto n3 = sizeof(strB);        //22
	auto n4 = wcslen(strB);        //10

	return 0;
}

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

//自定义实现strlen
int strlen(const char* str)
{
	assert(str != NULL);
	int len = 0;
	while((*str++) != '\0'){
		len++;
	}
	return len;
}

//或者不使用临时变量,用递归：
int strlen(const char* str)
{
	assert(str != NULL);
	return *str == '\0' ? 0 : (1 + strlen(++str));
}

字符串比较

1
2
3
4
5

strcmp(s1,s2); 
wcscmp(s1,s2); 
//s1 == s2,返回0
//s1 < s2 ,返回值小于0
//s1 > s2 ，返回值大于0

两个字符串自左向右逐个字符相比，按照ASCII值大小来比较，直到出现不同字符或遇到'\0'为止；

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

//自定义实现strcmp：
int strcmp(const char* str1, const char* str2)
{
	assert(str1 != NULL && str2 != NULL);
	int ret = 0;
	while(!(ret = *(unsigned char*)str1 - *(unsigned char*)str2) && str1)
	{
		str1++;
		str2++;
	}
	if(ret < 0)  ret = -1;
	else if(ret > 0)  ret = 1;

	return ret;
}

字符串拷贝

1
2
3

strcpy(s1,s2);   //赋值字符串s2到字符串s1的地址空间

strncpy(s1,s2,n);   //将字符串s2中的前n个字符拷贝到s1的地址空间

要注意一个陷阱，一定要保证字符串s1的内存大小能存的下要拷贝的s2的大小

1
2
3
4
5
6
7
8

//自定义实现strcpy
char* strcpy(char* strDestination, const char* strSource)
{
	assert(strDestination != NULL && strSource != NULL);
	char* strD = strDestination;
	while((*strDestination++ = *strSource++) != '\0');
	return strD;
}

拷贝还可以使用内存拷贝函数：

1
2

//从src所指向的内存地址起始位置开始拷贝n个字节到dest所指的内存地址的起始位置中。返回指向dest的指针
void* memcpy(void* dest, const* src, size_t n); 

memcpy和strcpy的区别：

1. 复制内容不同。strcpy只能复制字符串，而且不仅复制字符串内容，也复制结束符'\0'；memcpy可以复制任意内容，用途更广；
2. strcpy不需要指定长度，memcpy需要指定长度

字符串拼接

1
2
3

strcat(s1,s2);   //将字符串s2拼接到s1后面(覆盖s1的'\0'),返回s1

strncat(s1, s2, n); //将s2的前n个字符拼接到s1，并返回s1

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

//自定义实现strcat：
char *strcat(char* strDest, const char* strSrc)
{
	char* address = strDest;
	assert((strDest != NULL) && strSrc != NULL);
	while(*strDest)  //如果是strncat，这里用n作为结束标志
	{
		strDest++;
	}
	while(*strDest++ = *strSrc++);
	return address;
}

这个更加要注意，s1的大小要足够存放拼接后的s1+s2字符串的大小

两个char*不能直接相加，字符串拼接必须要用这个函数。（指针相加是什么操作啊(#`O′)）

字符串查找

1
2

strchr(s1,ch);   //指向字符串s1中字符ch第一次出现的位置
strstr(s1,s2);   //指向字符串s1中字符串s2的第一次出现的位置

内容替换

1
2

//将s中的前n个字节用ch替换并返回s
void* memset(void* s, int ch, size_t n);

这个函数的作用是在一块内存中填充某个给定的值，是对较大的结构体或者数组进行清零的最快方法。

安全函数

C语言的字符串处理有其漏洞所在。上面的所有方法都无法做边界检查，如果不注意就会发生缓冲区溢出的问题，这个问题在编码时是很严重的事故。。现在我们往往在程序中使用更加安全的API函数：

上述所有API函数都有其_s版本，如strcpy_s()，在执行操作的同时要告诉系统当前可使用的缓冲区的大小。 strlen()的安全版本是strnlen_s()，传入字符串的同时要传入一个最大的边界，以防止某些字符串没有'\0'结束标志。

C++新型字符串--string类

C++标准库中提供了string类型专门表示字符串

1
2

#include<string>
using namespace std;

使用string可以更加方便和安全的管理字符串，对性能要求不是特别高的场景可以使用。

定义

1
2
3
4

string s;   //定义空字符串
string s = "helloworld";  //定义并初始化
string s("helloworld");
string s = string("helloworld");

字符串长度

1
2
3

cout<<s1.length()<<endl;    //输出字符串长度
cout<<s1.size()<<endl;      //本质和上面一样
cout<<s1.capacity()<<endl;  // 字符串的容量

字符串比较

直接使用运算符== != < > >= < = 即可，通过ASCII码来比较。

转换为C风格字符串

1
2

string s1 = "hello";
const char* c_str1 = s1.c_str();

随机访问

字符串本身就是数组，可以使用下标的方式访问

1
2

string s = "hello";
cout<<s[0]<<endl;

字符串拷贝

不需要使用函数，直接使用=赋值

1
2

string s1 = "hello";
string s2 = s1;

字符串拼接

string重载了+和+=，不需要使用函数

1
2
3

string s1 = "hell0",s2 = "world";
string s3 = s1+s2;
s1 += s2;

数组

序列型容器

数组代表内存里一组连续的同类型的存储区，可以用来把多个存储区合并成一个整体。比如：int arr[10] = {1,2,3,4,5,6,7,8};

数组声明：

• int arr[10];
• 类型名int表示数组里所有元素的类型
• 整数10表示数组里包含的元素个数
• 数组元素个数不可以改变，是常量

使用注意：

• 每个元素都有下标，标识一个元素在当前数组容器中的位置。通过下标可以直接访问数组内任意元素
• 下标从零开始
• 超过范围的下标不可以使用，会内存错误。一定要注意，内存溢出是程序中经常出现的BUG
• 数组名和下标可以表示数组里的元素，如a[2]表示第三个元素
• 数组定义中的类型可以是除引用之外的任意类型，引用是不能赋值的，所以没有引用数组：int& a[10]错误

数组优点：

• 可以编写循环程序，依次处理数组里的所有元素；
• 循环变量依次代表所有有效下标；

数组使用常见错误：off-by-one error(差一错误)

考虑一个问题，假定整数x满足边界条件x>=16且x<=37，那么此范围内的整数x可能的取值有多少？这个问题思考有两个基本原则：

1. 首先考虑最简单的情况（特例），然后将结果外推；
2. 仔细计算边界问题；

特例：x的上界与下界重合，即x>=16与x<=16，显然其中的x个数为1；那么假定下界位low，上界位high；当low与high重合，个数为1，即共有high-low+1个元素。那么外推，这里共有37-16+1=22个元素。 最容易出错的地方就是+1，很容易就仅仅计算high-low。

  我们可以抽象出一个编程技巧来规避这个错误：用数学上的左闭右开[,)区间表示，上述问题可以看作[16,38)，即38-16=22。C++中，我们编程也遵循这个原则，从0开始，使用非对称区间，让下界可以取到值，上界取不到值。这样设计程序，可以直接用上界-下界来取得范围大小；当取值范围为空的时候，上界值=下界值；即使取值范围为空，上界值也永远不可能小于下界值。

1
2
3
4
5
6
7
8
9
10
11

//推荐的方式：
for(int index=0;index < 10;++index)
{
	cout<<a[index]<<" ";
}

//不推荐的方式
for(int index=0;index <= 9;++index)
{
	cout<<a[index]<<" ";
}

结论--C语言设计数组下标的原则：从0开始，使用非对称区间[,)；让下界可以取到值，上界取不到值；这样设计的好处：

1. 取值的范围大小可以直接上界-下界；
2. 如果这个取值范围为空，上界值=下界值；
3. 即使取值范围为空，上界值永远不可能小于下界值；

初始化

  定义数组时，可以为其元素提供一组用逗号分隔的初值，用{}括起来，称为初始化列表。数组元素初始化时若没有显式提供元素初值，则元素会被向普通变量一样初始化：

1. 全局的数组变量，元素初始化为0；
2. 函数内部的局部内置类型数组，元素无初始化；如果只初始化部分元素，剩余元素也会被初始化为0；
3. 数组类型不是内置类型，则无论在哪里定义，自动调用其默认的构造函数为其初始化，若该类无默认构造函数则会报错；

增删改查

• 在尾部添加和删除操作，时间复杂度为O(1)。只需要操作尾部元素即可，对与其他元素没有干扰。
• 在数组中间进行添加和删除操作，时间复杂度为O(n)。在中间操作，会对其他元素造成影响，操作元素后面的每一个元素都需要进一步操作
• 数组的访问用遍历很高效，时间复杂度为O(1)；
• 数组的查找复杂度一般为O(n)，取决于数组的容量(数组容量很大的时候并不适合遍历查找，时间复杂度太高，可以用二分查找)；

1
2
3
4
5
6

//下标访问
a[2] = 5;

//指针访问
int* p = a;
*(p+2) = 5;

1
2
3
4
5
6
7
8
9

//寻找a[]中第一个值为3的目标：
int len = sizeof(a)/sizeof(a[0]);
for(int index = 0; index < len; ++index)
{
	if(a[index] == 3)
	{
		return index;
	}
}

二维数组

二维数组是包含行列两个维度的数组。二维数组的初始化既可以按行初始化，也可以顺序初始化：

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

int ia[3][4] = {
	{0,1,2,3},
	{4,5,6,7},
	{8,9,10,11}
};

int ia[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};


//只初始化每行第一个元素,其余元素为0：
int ia[3][4] = {{0}, {4}, {8}};

//只初始化第一行元素，其余元素默认为0：
int ia[3][4] = {0, 3, 6, 9};

//如果对二维数组所有元素赋值，则第一维(行数)可以省略
//只有第一维可以省略，哪怕是100维的数组也只能忽略第一维
int ia[][3] = {1，2，3，4，5，6}； //相当于int ia[2][3] = {1，2，3，4，5，6}

二维数组访问：

1
2
3
4
5
6
7
8
9

int a[2][4] = {{1,2,3,4},{5,6,7,8}};
for(int row = 0; row < 2; ++row)  //行
{
	for(int col = 0; col < 4; ++col) //列
	{
		cout<<a[row][col]<<" ";
	}
	cout<<endl;
}

  二维数组我们一般按照一行一行的遍历，虽然可以进行一列一列的遍历的，但是实际操作中不建议这么做：因为循环需要满足“空间局部性”：在一个小的时间窗口内，访问的地址越接近越好，这样执行的速度快；也就是说我们一般把最长的循环放在内层，最短的循环放在最外层，以减少CPU跨切循环的次数。

  本质上所有数组在内存中都是一维线性的。不同的语言采用的存储方式不同，有的采用行优先存储，有的采用列优先存储。C/C++中采用行优先顺序存储。

二维数组动态声明：

1
2
3
4
5
6
7
8
9
10
11

//a[m][n]
int **a = new int*[m];
for(int i = 0; i < m; i++){
	a[i] = new int[n];
}

//动态声明的数组需要释放内存：
for(int i = 0; i < m; ++i){
	delete []a[i];
}
delete []a;

C++新型数组--vector

Vector是面向对象方式的动态数组。

动态是指容量不固定：我们经常使用的简单的数组，因为定义的时候就有固定容量，所以无法实现动态扩容插入元素。使用vector容器，可以轻松实现动态扩容添加元素。

面向对象是C++的特性，vector封装了一系列的方法，我们创建vecor的对象可以方便的使用。

添加

  使用vector容器，可以轻松实现动态扩容插入元素，传统的C数组容量有限，vector可以动态管理扩容。

• push_back，尾添加
• insert，任意位置添加（效率不高）

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

#include<vector>
using namespace std;

int main()
{
	vector<int> vec = { 1,2,3,4 };

	//尾添加
	vec.push_back(5);  //尾添加，不会出现下标越界 {1,2,3,4,5}


	//指定位置添加
	//insert方法，传入位置和值
	vec.insert(--vec.end(), 6);   //{1,2,3,4,6,5}
	return 0;
}

遍历

1
2
3
4

for(int index = 0;index < vec.size(); ++index)
{
	cout<<vec[index]<<endl;
}

  我们可以使用vector中的capacity()方法来查看vector当前的容量，用size()的方法来查看已经存储的元素的个数。这两者有区别，容量是指容器可以容纳元素的个数，数量是已经存储的数据个数；

删除

• vec.pop_back(); //尾删除
• vec.eraser(pos); //指定位置删除

  要注意如果打算使用eraser的方法进行尾删除，要注意end()的位置。数组的区间往往是左闭右开，end()指向的是尾元素的后面的地址，并不是尾元素自身。

1
2

vec.pop_back();
vec.eraser(vec.end()-1);   //这两者等价

  编写代码时，我们总会做出一些假设，断言就是用在代码中捕获这些假设。断言表示为一些布尔表达式，我们相信在程序中的某个特定点该表达式的值为真，可以在任意时刻启用和禁用断言来验证。

  举个例子，在离散数学中有个德摩根定律，我们在C++语言中可以验证：

1
2
3
4
5
6
7
8
9
10

#include<iostream>
using namespace std;
int main()
{
	bool A = false;
	bool B= true;
	//德摩根率：
	cout<<(!(A || B) == (!A && !B))<<endl;  //输出1
	cout<<(!(A && B) == (!A || !B))<<endl;  //输出1
}

这种代码方式在开发中并不常见，而是使用以下断言的方式：

1
2
3
4
5
6
7
8
9
10
11

#include<iostream>
#include<assert.h>
using namespace std;
int main()
{
	bool A = false;
	bool B= true;
	//德摩根率：
	assert( !(A || B) == (!A && !B) );  
	assert( !(A && B) == (!A || !B) );  
}

在这个程序中，并不会有任何输出结果，但是程序正常运行。

假如assert()函数中表达式出错(非真)，整个程序在运行的时候就会报错，并指出哪里出了问题。

所以今后在我们开发的时候可以运用这一特性，完成开发测试用例的编写：

1

assert(函数返回值 == 预期结果);

只要函数运行符合预期结果，程序正常运行，一旦不符合就会出错。

注意assert()不是函数，而是一个宏定义。

  运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C++内置了丰富的运算符，并提供了以下类型的运算符：

• 算数运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 杂项运算符

  在程序中，运算符是用来操作数据的，因此，这些数据也被称作操作数。使用运算符将操作数连接而成的式子称为:表达式。 表达式的特点：

• 变量和常量都可以认为是表达式；
• 运算符的类型对应了表达式的类型，如算术运算符对应算数表达式；
• 每一个表达式都有自己的值，即表达式都有运算结果；

算数运算符

A=10，B=20

  除法运算中整数和浮点数的运算结果不太一样，整数除的话结果就是整数，要想输出完整整型数:需要用浮点数去除：

1
2
3

int A = 10;
cout << 15 / A << endl;   //输出1
cout << 15.0 / A << endl;  //输出1.5

  自增/自减运算符放在变量的前面和后面是不一样的。放在变量前面称为前缀运算，先取变量的地址，做运算后再把值放入寄存器（先变后用）；放在变量后面称为后缀运算，先取变量的地址中的内容放入寄存器，然后对内存中的信息做运算（先用后变）。因为前缀运算返回的是操作数本身，所以前缀运算可以作为左值表达式；后缀运算返回的是临时变量，只能用于后缀表达式。

  自增和自减运算符只能用于变量，不能用于表达式：6++、(i+j)++、(&p)++这些都是不合法的。

  C/C++编译器对程序编译时，从左到右尽可能多的将字符组成一个运算符或者标识符，因此"i+++j++"是合法的，因为编译器会理解为"(i++)+(j++)"，这两个自增运算符作用的对象都是变量；但是"++i+++j"是不合法的，编译器会理解为"++(i++)+j"，其中第一个自增运算符作用的对象是"i++"，这是一个表达式，不合法。

1
2
3
4

int A = 10;
int B = 10;
cout << ++A << endl;   //输出11
cout << B++ << endl;  //输出10（但是B变为11）

关系运算符

A=10 ；B=20

关系运算符返回的都是bool类型的值。千万不要连起来用："i< j < k"这种写法有问题，"i < j"运算完成后直接返回true或false，是拿这个true或false来和k做比较的。

逻辑运算符

A = true； B = false;

可以用逻辑运算符来表示德摩根律：\(\neg(A \land B)\) 等价于 \(\neg A \lor \neg B\)； \(\neg(A \lor B)\) 等价于 \(\neg A \land \neg B\)

1
2

cout << (!(A || B) == (!A && !B)) << endl;
cout << (!(A && B) == (!A || !B)) <<endl;

逻辑运算符本身也是有优先级的

1
2

auto a = true || true && false;     //true
auto b = (true || true) && false;   //false

逻辑与和逻辑或求值策略都是“短路求值”：先计算其左边的操作数，只有再仅靠左操作数无法确定逻辑表达式的值的时候，才会求解右操作数。

赋值运算符

把右侧的值赋给左侧。注意左侧的值一定要是一个变量。

位运算符

位运算符作用于位（bit），并逐位进行操作。

位运算符还包括取反操作"~"和移位运算"<<"和">>"，都是以bit为单位运算。

与、或、异或都是双目运算符，结合性从左到右，优先级高于逻辑运算符，低于关系运算符，且从高到低为&、^、|

使用移位运算符需要注意，左移运算还比较简单，移走的位自动填充0，但右移运算有两种情况，逻辑右移时移走的位填充0，但算数右移时移走的位与符号位有关。底层到底是逻辑右移还是算数右移取决于编译器，而不是程序员，所以对于有符号数，尽可能不要使用右移运算！！！

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

// 位运算
int A = 10,B = 20;

cout << (A&B) << endl;      //  01010 & 10100  = 00000  ==> 0

cout << (A | B) << endl;       //  01010 | 10100  = 11110  ==> 30

cout << (A^B) << endl;     //  01010 ^ 10100  = 11110 ==> 30

//取反运算需要补码的知识，计算机中都是用补码表示的
cout << (~A) << endl;       //  ~0000000000001010 = 11111111111110101 ==> 0000000000001011==-11

cout << (A << 2) << endl;  //  00001010 << 2 ==> 00101000 ==> 40

cout << (A >> 2) << endl;// 00001010 >> 2 ==> 00000010 ==> 2

  异或操作有特性：两个相同的数异或后结果为0，且满足交换律，即"A ^ B ^ C ^ D ^ F ^ B"等价于"A ^ C ^ D ^ E ^ F"。这个特性常用来寻找成对出现的数据时缺失的哪一个数：如对于一组数【A、B、C、D、A、B、C】，直接做异或运算"A ^ B ^ C ^ D ^ A ^ B ^ C = D"找出缺失的D。

  异或操作还可以交换两个变量的值，利用了异或操作的自反性(a ^ a = 0)、恒等性(a ^ 0 = a)以及交换律(a ^ b = b ^ a、(a ^ b) ^ c = a ^ (b ^ c))。不过要注意两个变量不能相等，相等后结果为0：

1
2
3
4
5
6
7
8
9
10
11

a = a ^ b; //步骤1
b = a ^ b; //步骤2
a = a ^ b; //步骤3

/*
设a = A ,b = B
步骤1执行完后：a = A^B , b = B
步骤2执行完后：a = A^B , b = A^B^B=A^0=A
步骤3执行完后：a = A^B^A=B , b = A
*/

杂项运算符

  一定要注意，sizeof是运算符，不要理解为函数！！！sizeof的操作数可以是一个表达式或者是类型名。需要牢记sizeof的计算发生在编译时期，所以它可以被当作常量表达式使用，且会忽略括号内的运算。比如sizeof(a++)中的++不会执行。

  如果sizeof中传递的是个函数调用，则返回函数返回类型的大小，函数不会调用。这里只能传递函数调用，不能传递函数名（Func()这个是函数调用，Func是函数名）。且如果函数返回的是void，不能确定类型，也不可以使用sizeof运算符。

运算符优先级

下表从高到低列出各个运算符，较高的运算符会被优先计算：

只需要记住两点：

1. 一般来说，一元运算符优先级高于对应的二元运算符；
2. 弄不清就加括号

编译型语言

编程语言可以分为四个层次，从上到下，语言会更接近人类使用语言的方式，但相对应的程序运行效率逐渐降低

1. 机器语言、汇编语言：这些语言执行效率很高，但移植性很差；
2. 编译型语言：C/C++。这种类型的语言更接近人类的使用方式，在不同的机器上也可以跨平台使用。但跨平台有一些难度；
3. 解释型语言：Basic、Python。这种类型的语言通过解释器作为中间层，跨平台性很强；
4. 脚本语言：bash、csh。不同的平台拥有不同的脚本，本身的功能并不强大，但是很容易把各种语言融合在一起。

C++属于编译型语言，需要经历编译和链接的过程，才能变成真正的可执行程序：

数据类型

  C++中的每个变量都有其数据类型，数据类型决定这个变量所占用内存空间的大小和布局方式、该空间能存储的值的范围，以及变量能参与的运算。

  在计算机中，1byte=8bit。我们在说数据类型的大小的时候一般以byte作为单位来计算。

  计算机中都是用0、1这种二进制存储的。日常中我们习惯用10进制来看，有时候为了方便，调试过程中更习惯用16进制的方式来表示。

  内置的C++类型分为基本类型和复合类型。基本类型包括整数、浮点数及两者的多种变体；复合类型包括数组、字符串、指针、引用、结构体和共用体等。一般32位编译环境中的类型大小如下，需要注意不同的编译环境结果可能不同：

1
2
3
4
5
6
7
8
9
10
11

//常见的数据类型的定义
char a[10] = "a";
short int s = 97;
int m = 97;
long int n = 97;
//给float类型的变量赋值时，要在数值后面加上一个f或F，表示这是一个float类型的常量，否则默认为double类型的常量
float f = 97.0f; 
double d = 97.0;
long double k = 97.0;
bool b = true;
wchar_t w[10] = L"a";

内存分区

1. 堆：由程序员手动分配和释放，完全不同于数据结构中的堆，分配方式类似链表。由malloc(C)或new(C++)来分配，free(C)和delete(C++)释放。若程序员不释放，程序结束时由系统释放；
2. 栈：由编译器自动分配和释放的，存放函数的参数值、局部变量等。操作方式类似数据结构中的栈；
3. 全局（静态）存储区：存放全局变量和静态变量。包括DATA段(全局初始化区)和BSS段(全局未初始化区)。其中初始化的全局变量和静态变量存放在DATA段，未初始化的全局变量和未初始化的静态变量存放在BSS段。程序结束后由系统释放；在程序执行之前BSS段会自动清0，所以未初始化的全局变量和静态变量在程序执行之前就已经是0了；
4. 文字常量区：常量字符串存储在这里，程序结束后由系统释放；
5. 程序代码区：存放函数体的二进制代码

标识符和关键字

C++中的标识符是用来标识变量、函数、类、模块，或者任何其他用户自定义项目的名字；

• 一个标识符通常以字母A~Z或a ~z或下划线_开始，后面跟零个或者多个字母、下划线和数字；
• 一个标识符不允许使用数字开头；
• 一个标识符内不允许出现标点字符，如@、&等等；
• 不能混淆大小写，C++是区分大小写的编程语言；
• 不能使用C++关键字作为标识符，原则上不允许长度超过32位；

标识符命名规则：

• 不要试图发明最好的命名规则，要制定一个让大部分人都满意的命名并在项目组中贯彻执行；
• 标识符应该直观，可以望文知意，尽量使用英文单词组合，不要使用拼音；
• 标识符长度要符合“min-length&max-information”原则，长度尽可能短，信息尽可能多
• 变量名字尽可能使用“名词”或“形容词+名词”形式，尽量避免出现数字；函数名尽量使用“动词+名词”
• 可借鉴的命名规则：
  • 匈牙利命名法：开头字母用变量类型缩写，其余部分用变量的英文或者英文缩写，要求第一个字母大写，如int iMyAge;
  • Camel(驼峰)命名法：第一个单词首字母小写，后面单词首字母大写，如int myAge;
  • Pascal命名法：每个单词的第一个字母都大写，如int MyAge;

C++的关键字

变量与常量

变量

• 变量就是在程序运行过程中，值可以改变的量；
• 变量在程序的执行中可以进行赋值造作，发生变化；
• 变量有一个名字，并在使用之前要说明其类型，一经说明，就在内存中占据与其类型相应的存储单元；

变量定义：

• 首先是类型说明符，随后紧跟一个或者多个变量名组成的列表，其中变量名以逗号分隔，最后以分号结束：int m = 1,n = 1;
• 当变量在创建时获得了一个特定的值，我们说这个变量被初始化了。用于初始化变量的值可以是任意复杂的表达式；
• 当一次定义了一个或多个变量时，变量的名字随着定义就可以使用了，如：int m=1,n=1; int sum = m + n;

常量

• 在程序运行过程中，其值一直保持不变的量为常量；
• 常量也区分不同的数据类型；

常量在C++中有两种定义的方法：

1. 使用#define，如：#define PI 3.14
2. 使用const，如：const double PI = 3.14

尽量使用const形式定义变量，因为#define不会出现在编译时期，在编译出错时不容易排错。define是C语言时期的习惯。

整数常量

整数常量可以是十进制、八进制或者十六进制的常量:

• 前缀指定基数：0x或者0X表示十六进制，0表示八进制，不带前缀则默认十进制；
• 整数常量也可以带一个后缀，后缀是U和L的组合，U表示无符号整数，L表示长整数。后缀可以是大写也可以小写，不区分顺序。后缀不能重复。

布尔常量

布尔常量共有两个，他们都是C++关键字，true代表真，false代表假。

字符常量

• 字符常量是括在单引号中的。如果常量以L(仅当大写时)开头，则表示宽字符常量(如L'x')，此时必须保存在wchar_t类型的变量中;否则就是窄字符常量(如'x')，此处可以存储在char类型的简单变量中；
• 字符常量可以是一个普通字符('x')、一个转义序列('\t')、或者一个通用字符('\u02C0')。
• 需要表达一些符号的时候需要用到转义字符；

常见转义字符如下：

C++概况

C++语言应用广泛，凡是要求大型的、对性能要求很高的程序，以及物联网应用上，都会用到C++语言。

C++历史

• C++编程语言可追溯到1979年，Bjarne Stroustrup创立了带类的C，这就是C语言的超集。1983年，这个语言被命名为C++；
• C++最开始仅仅是C语言的增强版，但是后来又引入了很多功能。1998年伴随着STL标准库的诞生，一堆新功能和特性的产生，C++标准委员会发布了第一个国际标准C++ + ISO/IEC 1488：称为C++ 98；
• 2011年中期，C++标准（被称作C++ 11）完成了新的标准。Boost库项目对新标准产生了相当大的影响，一些新模块直接从响应的Boost库中派生出来；
• C++ 11之后，每三年C++都会发布新的语言标准，每一版都在基本保留向后兼容性的同时，提供着改进和新功能；

C++特点

优点：

1. 强大的抽象封装能力：这让C++语言具备了强大的开发工程能力；
2. 高性能：运行快，占用资源少；
3. 低功耗：特别适合在各种微型嵌入式设备中高效运行程序；

缺点：

1. 语法相对复杂，细节比较多；
2. 需要一些好的规范和范式，否则代码很难维护；

C++的应用

• 大型桌面应用程序（如Google Chrome、Miscrosoft Office）
• 大型网站的后台（Google的搜索引擎）
• 游戏和游戏引擎（Unity）
• 视觉库和AI引擎（Opencv和Tensorflow）
• 数据库（Mircrosoft SQL Server）
• 嵌入式领域

总的来说，在开发成本比较高，对于内存和CPU要求很高，低功耗并且程序被调用非常频繁等场景中，目前C++是最合适的语言。

Hexo博客要求必须使用Github风格的Markdown语言编辑。所以需要了解具体的编写格式。

一、编辑器

市面上有很多的Markdown编辑器，之前很多人喜欢用Typora，但目前这个已经没有免费版可以用了。干脆直接用VSCode。

使用VSCode需要下载两个插件，第一个是【Markdown All in One】，是一个组合包，把最常用的markdown优化都安装好；第二个是【Markdown Preview Github Styling】,是Github使用的Markdown渲染样式。使用这个样式，在本地就能预览Markdown文件最终在Github Pages中显示的效果。

二、常用语法

标题

利用#设置标题，一个表示一级，两个表示二级，依次类推

1
2
3

#      一级标题
##     二级标题
……………… 以此类推

引用

利用>可以创建引用块

文本高亮

利用一组反引号`来把文本包起来。

1

`这里面是需要高亮的字符`

代码块

利用三个反引号`把内容扩起来即可。在上面的那个反引号后面还可以加上语言名称来进行自适应。

斜体

可以用一组*号来把文字包起来，也可以直接用快捷键Ctrl+I。

加粗

k可以用一组**来把文字包起来，也可以用快捷键Ctrl+B。

删除线

用一组~~把文字包起来。

下划线

下划线可以用<u> </u>把文字包起来。

按键效果

可以用一组<kbd> </kbd>把文字包起来，实现按键效果。

列表

列表分为有序列表和无序列表

1
2
3
4
5
6
7

无序列表：用-加空格
- 第一
- 第二

有序列表：用数字加.加空格
1. 第一
2. 第二

三、链接与图片

图片其实是一种超链接，所以把图片归类为链接里面。

1、跳转链接

普通的网站跳转都属于跳转链接，语法很简单：

1

[网站说明](跳转链接)

2、图片链接

图片链接的markdown语法和跳转链接类似：

1

![](图片链接)

3、图片存储

网上很多教程都是利用相对路径来存储图片，操作如下： 1. 安装图片插件

1

npm install hexo-asset-image --save

2. _config.yml配置文件中，修改为 post_asset_folder: true

其中第二步可以忽略，第二步的意义在于我们新建文章的时候，会在soruce目录下生成文章同名文件夹供我们存储图片，我们也可以手动创建文件夹。

但是对于GitPages或者云服务器来说，其提供的免费存储空间都是有上限的，这样操作只适用于图片较少的情况。我们可以利用云服务器对象存储功能实现图床。

我的域名使用的是腾讯的，那就用腾讯的COS来操作，并且腾讯提供可视化工具COSBrowser，很方便。 参考博客： Hexo 博客图片添加至图床---腾讯云COS图床使用

一个图片测试：

四、公式

公式使用的是Latex语法。但需要注意，Hexo并不支持Laxte语法，所以我们需要开启相关的开关。有些主题就自带这个功能。

Markdown使用$包裹实现行内公式，使用$$包裹实现行间公式。

Latex语法可以不掌握，借助工具即可： HostMath

不过Hexo显示数学公式还需要一些其他设置，Hexo默认使用 hexo-renderer-marked 引擎渲染网页，该引擎会把一些特殊的 markdown 符号转换为相应的 html 标签，导致公式不显示。

五、表格

1
2
3
4
5
6

|     1   |      T2       |  T3   |
|----------|:-------------:|------:|
|   1      |  1            |  1    |
|   22     |  22           | 22    |
|   333    |  333          | 333   |

------表示左对齐，:------：表示居中，-----:表示右对齐 Hexo的表格必须和正文之间有空行，否则不能正常显示

六、流程图

流程图的使用参考自Hexo-Next 主题的图形工具 -- Mermaid

Mermaid 是一个支持在Markdown文档中绘制流程图、甘特图、序列图等图形的工具。它基于JavaScript实现，能够将Markdown中的元素渲染成HTML元素，从而在网页上直观地展示各种图表‌。我使用的是Next主题，所以记录Next主题中使用流程图的方式。

配置：

• NexT config file 中找到mermaid配置，并设置为true，theme 可以设置浅色和深色背景的样式，共有4个可用选项

1
2
3
4
5
6

mermaid:
  enable: true
  # Available themes: default | dark | forest | neutral
  theme:
    light: dark
    dark: dark

使用方法：mermaid与endmermaid是固定搭配，type 用于设置图形的种类，如流程图、时序图、甘特图等

1
2

{% mermaid type %}
{% endmermaid %}

也可以使用代码块的方式：

1
2
3
4
5

// 去掉前面的#
#```mermaid
type

#```

但是此时需要在 Hexo config file 中找到highlight，并添加如下内容，才会使代码块的形式生效：

1
2
3

highlight:
  exclude_languages:
    - mermaid

Flowchart

• 用于绘制流程图，支持方向（例如从左到右、从上到下）和节点间关系的定义。
• type 为 "graph TD"或者"graph LR"，分别表示从上到下和从左到右的方向

1
2
3
4
5
6

- 流程图方向:
  - TB - 从上到下
  - TD - 自上而下，等同于TB
  - BT - 从下到上
  - RL - 从右到左
  - LR - 从左到右

示例：

1
2
3
4
5
6

{% mermaid graph TD %}
A[Hard] -->|Text| B(Round)
B --> C{Decision}
C -->|One| D[Result 1]
C -->|Two| E[Result 2]
{% endmermaid %}

效果：

            graph TD
            A[Hard] -->|Text| B(Round)
B --> C{Decision}
C -->|One| D[Result 1]
C -->|Two| E[Result 2]
          

说明：

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

graph TD，定义一个从上到下的流程图。
TD 是 Top to Down 的缩写，表示流程图从上向下排列。

A[Hard] -->|Text| B(Round)，定义了一个节点 A，显示为 Hard。
一个带标签的箭头 -->|Text| 指向节点 B，箭头上的标签为 Text。
节点 B 被定义为 Round，这是一个椭圆形节点。

B --> C{Decision}，节点 B 指向节点 C。
节点 C 被定义为 Decision，这是一个决策节点，用大括号 {} 表示。

C -->|One| D[Result 1]，决策节点 C 的一个分支，带标签 One，指向节点 D。
节点 D 显示为 Result 1，这是一个矩形节点。

C -->|Two| E[Result 2]，决策节点 C 的另一个分支，带标签 Two，指向节点 E。
节点 E 显示为 Result 2，也是一个矩形节点。

七、特殊字符

常见转义如下：

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

! ! — 惊叹号 Exclamation mark
” " " 双引号 Quotation mark
# # — 数字标志 Number sign
$ $ — 美元标志 Dollar sign
% % — 百分号 Percent sign
& & & Ampersand
‘ ' — 单引号 Apostrophe
( ( — 小括号左边部分 Left parenthesis
) ) — 小括号右边部分 Right parenthesis
* * — 星号 Asterisk
+ + — 加号 Plus sign
< &#60; &lt; 小于号 Less than
= &#61; — 等于符号 Equals sign
- &#45; &minus; — 减号
> &#62; &gt; 大于号 Greater than
? &#63; — 问号 Question mark
@ &#64; — Commercial at
[ &#91; --- 中括号左边部分 Left square bracket
\ &#92; --- 反斜杠 Reverse solidus (backslash)
] &#93; — 中括号右边部分 Right square bracket
{ &#123; — 大括号左边部分 Left curly brace
| &#124; — 竖线Vertical bar
} &#125; — 大括号右边部分 Right curly brace

八、hexo模板

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

# ！！！！！！！！！！
# 每一项的 : 后面均有一个空格
# 且 : 为英文符号
# ！！！！！！！！！！

title:
# 文章标题，可以为中文

date:
# 建立日期，如果自己手动添加，请按固定格式
# 就算不写，页面每篇文章顶部的发表于……也能显示
# 只要在主题配置文件中，配置了 created_at 就行
# 那为什么还要自己加上？
# 自定义文章发布的时间

updated:
# 更新日期，其它与上面的建立日期类似
# 不过在页面每篇文章顶部，是更新于……
# 在主题配置文件中，是 updated_at

permalink:
# 若站点配置文件下的 permalink 配置了 title
# 则可以替换文章 URL 里面的 title（文章标题）

categories:
# 分类，支持多级，比如：
# - technology
# - computer
# - computer-aided-art
# 则为 technology/computer/computer-aided-art
# （不适用于 layout: page）

tags:
# 标签
# 多个可以这样写 [标签1,标签2,标签3]
# （不适用于 layout: page）

description:
# 文章的描述，在每篇文章标题下方显示
# 并且作为网页的 description 元数据
# 如果不写，则自动取 <!-- more -->
# 之前的文字作为网页的 description 元数据

keywords:
# 关键字，并且作为网页的 keywords 元数据
# 如果不写，则自动取 tags 里的项
# 作为网页的 keywords 元数据

comments:
# 是否开启评论
# 默认值是 true
# 要关闭写 false

layout:
# 页面布局，默认值是 post，默认值可以在
# 站点配置文件中修改 default_layout
# 另：404 页面可能用到，将其值改为 false

type:
# categories，目录页面
# tags，标签页面
# picture，用来生成 group-pictures
# quote？
# https://io-oi.me/tech/test/

photos:
# Gallery support，用来支持画廊╱相册，用法如下：
# - photo_url_1
# - photo_url_2
# - photo_url_3
# https://io-oi.me/tech/test/

link:
# 文章的外部链接
# https://io-oi.me/tech/test/

image:
# 自定义的文章摘要图片，只在页面展示，文章内消失
# 此项只有参考本文 5.14 节配置好，否则请勿添加！

sticky:
# 文章置顶
# 此项只有参考本文 5.15 节配置好，否则请勿添加！

password:
# 文章密码，此项只有参考教程：
# http://shenzekun.cn/hexo的next主题个性化配置教程.html
# 第 24 节，配置好，否则请勿添加！
# 发现还是有 bug 的，就是右键在新标签中打开
# 然后无论是否输入密码，都能看到内容

由于Hexo属于静态博客，文章内容都是本地存储，只有静态页面（public文件夹）会push到git上面。如果我们更换电脑的话，配置相同的环境、依赖和博客文件，如果用U盘拷贝就太low了。所以我们可以利用Github远程仓库来实现多台终端的博客更新部署。

主要思路是利用git的分支，把静态博客页面文件放在master主分支，把hexo的部署环境文件和博客原文放在新建的Hexo分支上。

# 一、Hexo的原理和依赖

1、环境

Hexo需要有Node.js环境和Git环境，这在哪个电脑都必须有的。

2、资源配置依赖

首先要安装Hexo

1

npm install -g hexo-cli 

hexo所需要的包信息都已经存储在package.json文件中了，我们可以直接利用这个文件，执行命令行安装所需资源：

1

npm install

3、博客内容

博客的内容主要就是主题文件和博客文件

• node_modules: hexo所需要的文件，这个文件不需要上传git
• themes：主题文件
• source：博文的md文件
• public：生成的静态页面，这个一般都clean掉
• _config.yml：全局配置文件
• .gitignore：hexo自动生成的，里面一般会记录node_modules，我们不许要改，这个文件就会被忽略掉

二、Git仓库修改

对我们之前创建的username.github.io仓库，创建一个新的hexo分支，并在仓库->Settings->Branches->Default branch中把这个分支设置为默认分支。clone到本地，此时本地应该是Hexo分支。

之后我们把我们之前写的博客目录下的文件，全部拷贝到这个本地仓库中【注意要把之前themes目录中的.git文件删掉。因为一个git目录下不能有另一个git仓库。如果我们需要更新主题文件，只能把主题clone到本地后进行拷贝覆盖】。然后提交git到Hexo分支：

1
2
3

git add .
git commit -m 'update'
git push

此时我们观察github，可以看到，master分支里面保存着静态博客资源（在_config.yml中的Deployment配置的），Hexo分支备份博客部署文件，供我们维护更新。两者在一个仓库中互不干扰。

三、新的提交操作

目前我们在写博客时，就要在提交前做git更新了

1
2
3
4
5
6
7
8
9
10
11

git pull     //提交前最好更新最新


git add .
git commit -m 'update'
git push 


hexo clean
hexo g
hexo d

Hexo是一个快速，简单而强大的博客框架，使用Markdown语言编写文章，Hexo可以在几秒钟内生成具有美丽主题的静态页面文件。

一、环境搭建

1、Node.js

Node.js是基于Chrome JavaScript运行时建立的一个平台，npm是node.js的包管理工具。Hexo是基于Node.js的，使用Hexo搭建博客，就需要本地有Node.js环境。Node.js环境点击这里，一路next。安装完成后可以用命令行查看版本号。

1
2
3

node -v //查看node.js的版本

npm -v  //查看包管理器的版本

由于国内环境使用npm速度感人，可以安装cnpm，把镜像源换成淘宝的

1

npm install -g cnpm --registry=https://registry.npm.taobao.org

之后可以命令行输入cnpm，如果能打出帮助界面表示安装成功。

2、Git

git的相关配置不在此赘述。hexo的很多操作都要依赖于git

3、Hexo

Hexo依托于npm包管理器，我们可以直接下载

1

cnpm install -g hexo-cli

1

hexo -v    //查看Hexo版本

二、博客搭建

首先我们新建一个存放博客的文件目录。之后我们的操作全部在此目录下。如果之后我们搭建错误想要从头再来，直接删掉这个目录新建一个即可。

然后我们初始化hexo

1

hexo init

之后安装hexo的依赖组件

1

cnpm install

目前目录下面有如下几个部分：

• node_modules：存的是利用【npm install --save】下载安装的组件
• scaffolds：存放模板文件，可以创建post、page、draft三种页面
• source：存放用户资源，即我们的待发布文档
• themes：存放主题文件夹，默认landspace
• _config.yml：此文件很重要，是我们网站的配置信息
• package.json：应用程序的信息

此时会自动生成一篇Helloworld的博客，我们可以启动博客来看看效果。

1
2
3

hexo clean      //清空缓存，即清空我们的public文件夹
hexo g          //hexo generate命令，在本地生成静态页面，即pubilc文件夹
hexo s          //hexo server命令，开启本地服务器，可供我们本地预览

三、写博客

1
2
3
4
5
6
7

hexo n "第一篇文章"
//hexo new [layout] <title>
//hexo new命令，不设置layout会根据_config.yml中的default_layout在source\\_posts目录下生成一篇博客文章
//如果标题包含空格，使用引号括起来

//-p 自定义路径
hexo new page --path about/me "About me"

生成博客还是老三样

1
2
3

hexo clean
hexo g
hexo s

四、部署到github

执行完上述步骤，我们的博客只能在本地看，我们必须部署到网上才能通过网络来看。Github提供GitPages免费站点服务，自带域名和1G免费空间，存放博客资源和网页信息足够。

git本地配置和ssh公钥配不再赘述

1、新建git仓库

要注意仓库名必须要符合规则，即【用户名.github.io】格式。git会跟进这个仓库来创建域名。

2、hexo配置git插件

1

cnpm install --save hexo-deployer-git

安装完成后我们需要修改_config.yml文件中的Deployment信息（最下面）

1
2
3
4

deploy:
    type: git
    repo: git@github.com:Liuqianci/Liuqianci.github.io.git
    branch: master

3、部署远端

在之前的基础上，可以把本地文章部署到远端了

1
2
3
4
5

hexo clean
hexo g
hexo s

hexo d   //hexo deploy命令，部署远端

此时我们的github仓库就有内容了，我们也可以输入域名直接访问我们的博客。

五、自定义域名

虽然gitpages给我们提供了一个域名，但是我们还可以自己申请一个属于自己的域名。我绑定的是腾讯的域名。

在腾讯云里申请域名，此流程很快。

域名申请下来后，需要绑定我们的博客网站。在腾讯云的控制台上进行域名解析。一般解析两条，A对应IP，CNAME对应域名。我们博客的IP，直接ping我们博客的域名即可。

域名解析完成后，我们要进行域名绑定，在source目录下新建一个CNAME文件，写入自己的域名。然后在GitPages上也进行配置，进入Github的settings中，添加GitPages的Custom Domain为我们的自定义域名。我们可以勾选Enforce HTTPS来开启https

最后在_config.yml的url选项中填写我们的自定义域名。完成发布。