C语言基础一
C语言基础
原文链接：
C程序基本格式
前面在创建项目之后自动生成了一个.c文件，这个就是编写的程序代码文件：
#include <stdio.h>
int main() {
printf("Hello World!");
return 0;
}
操作系统需要执行的程序，C语言程序入口点就是main函数：
int main() { //所有的符号一律采用英文的，别用中文
程序代码...
}
注意是int后面空格跟上main()，的程序代码使用花括号{}进行囊括
printf("Hello World!"); //注意最后需要添加;来结束这一行，注意是英文的分号，不是中文的！
最顶上还有一句：
#include <stdio.h>
这个是引入系统库为提供的函数，包括printf在内，编写一个C语言程序，就按照固定模式：
#include <stdio.h>
int main() {
程序代码
}
基本数据类型
计算机底层实际上只有0和1能够表示，这时如果要存储一个数据，比如十进制的3，那么就需要使用2个二进制位来保存，二进制格式为11，占用两个位置，再比如要表示十进制的15，这时转换为二进制就是1111占用四个位置（4个bit位）来保存。一般占用8个bit位表示一个字节（B），2个字节等于1个字，所以一个字表示16个bit位，它们是计量单位。
常说的内存大小1G、2G等，实际上就是按照下面的进制进行计算的：
8 bit = 1 B ，1024 B = 1KB，1024 KB = 1 MB，1024 MB = 1GB，1024 GB = 1TB，1024TB = 1PB（基本上是1024一个大进位，但是有些硬盘生产厂商是按照1000来计算的，所以买电脑的硬盘容量可能是512G的但是实际容量会缩水）
原码、反码和补码
原码
上面说了实际上所有的数字都是使用0和1这样的二进制数来进行表示的，但是这样仅仅只能保存正数，那么负数怎么办呢？
比如现在一共有4个bit位来保存的数据，为了表示正负，可以让第一个bit位专门来保存符号，这样，这4个bit位能够表示的数据范围就是：
- 最小：1111 => - (22+21+2^0) => -7
- 最大：0111 => + (22+21+2^0) => +7 => 7
虽然原码表示简单，但是原码在做加减法的时候，很麻烦！以4bit位为例：
1+(-1) = 0001 + 1001 = 怎么让计算机去计算？（虽然知道该去怎么算，但是计算机不知道，计算机顶多知道1+1需要进位！）
得创造一种更好的表示方式！于是引入了反码：
反码
正数的反码是其本身
负数的反码是在其原码的基础上, 符号位不变，其余各个位取反
经过上面的定义，再来进行加减法：
1+(-1) = 0001 + 1110 = 1111 => -0 （直接相加，这样就简单多了！）
思考：1111代表-0，0000代表+0，在实数的范围内，0有正负之分吗？
0既不是正数也不是负数，那么显然这样的表示依然不够合理！
补码
根据上面的问题，引入了最终的解决方案，那就是补码，定义如下：
正数的补码就是其本身 （不变！）
负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)
其实现在就已经能够想通了，-0其实已经被消除了！再来看上面的运算：
1+(-1) = 0001 + 1111 = (1)0000 => +0 （现在无论你怎么算，也不会有-0了！）
所以现在，4bit位能够表示的范围是：-8~+7（C使用的就是补码！）
整数类型
首先来看看整数类型，整数就是不包含小数点的数据，比如1，99，666等数字，整数包含以下几种类型：
- int - 占用 4 个字节，32个bit位，能够表示 -2,147,483,648 到 2,147,483,647 之间的数字，默认一般都是使用这种类型
- long - 占用 8 个字节，64个bit位。
- short - 占用2个字节，16个bit位。
浮点类型
浮点类一般用于保存小数，不过为啥不叫小数类型而是浮点类型呢？因为一个小数分为整数部分和小数部分，需要用一部分的bit位去表示整数部分，而另一部分去表示小数部分，至于整数部分和小数部分各自占多少并不是固定的，而是浮动决定的（在计算机组成原理中会深入学习）
- float - 单精度浮点，占用4个字节，32个bit位。
- double - 双精度浮点，占用8个字节，64个bit位。
字符类型
除了保存数字之外，C语言还支持字符类型，的每一个字符都可以使用字符类型来保存：
-
char - 占用1个字节（-128~127），可以表示所有的ASCII码字符，每一个数字对应的是编码表中的一个字符
编码表中包含了所有常见的字符，包括运算符号、数字、大小写字母等（注意只有英文相关的，没有中文和其他语言字符，包括中文的标点符号也没有）
某些无法直接显示的字符（比如换行，换行也算一个字符）需要使用转义字符来进行表示
变量
变量的使用
变量就像在数学中学习的x，y一样，可以直接声明一个变量，并利用这些变量进行基本的运算，声明变量的格式为：
数据类型 变量名称 = 初始值; //其中初始值可以不用在定义变量时设定
// = 是赋值操作，可以将等号后面的值赋值给前面的变量，等号后面可以直接写一个数字（常量）、变量名称、算式
现在想要声明一个整数类型的变量：
int a = 10; //变量类型为int（常用），变量名称为a，变量的初始值为10
int a = 10, b = 20; //多个变量可以另起一行编写，也可以像这样用逗号隔开，注意类型必须是一样的
其中，变量的名称并不是随便什么都可以的，它有以下规则：
- 不能重复使用其他变量使用过的名字。
- 只能包含英文字母或是下划线、数字，并且严格区分大小写，比如
a和A不算同一个变量。 - 虽然可以包含数字，但是不能以数字开头。
- 不能是关键字（比如上面提到的所有基本数据类型，当然还有一些关键字会在后面认识）
- （建议）使用英文单词，不要使用拼音，多个词可以使用驼峰命名法或是通过下划线连接。
初始值可以是一个常量数据（比如直接写10、0.5这样的数字）也可以是其他变量，或是运算表达式的结果，这样会将其他变量的值作为初始值。
使用变量来做一些基本的运算：
#include <stdio.h>
int main() {
int a = 10; //将10作为a的值
int b = 20;
int c = a + b; //注意变量一定要先声明再使用，这里是计算a + b的结果（算式），并作为c的初始值
}
这里使用到了+运算符（之后还会介绍其他类型的运算符）这个运算符其实就是数学中学习的加法运算，会将左右两边的变量值加起来，得到结果，可以将运算结果作为其他变量的初始值
所以这里通过前面认识的printf函数来将结果打印到控制台：
#include <stdio.h>
int main() {
int a = 10;
int b = 20;
int c = a + b;
printf(c); //直接打印变量c
}
但是实际上printf是用于格式化打印的，输出变量值
printf("c的结果是：%d", ); //使用%d来代表一个整数类型的数据（占位符），在打印时会自动将c的值替换上去
除了使用%d打印有符号整数之外，还有其他的：
| 格式控制符 | 说明 |
|---|---|
| %c | 输出一个单一的字符 |
| %hd、%d、%ld | 以十进制、有符号的形式输出 short、int、long 类型的整数 |
| %hu、%u、%lu | 以十进制、无符号的形式输出 short、int、long 类型的整数 |
| %ho、%o、%lo | 以八进制、不带前缀、无符号的形式输出 short、int、long 类型的整数 |
| %#ho、%#o、%#lo | 以八进制、带前缀、无符号的形式输出 short、int、long 类型的整数 |
| %hx、%x、%lx %hX、%X、%lX | 以十六进制、不带前缀、无符号的形式输出 short、int、long 类型的整数。如果 x 小写，那么输出的十六进制数字也小写；如果 X 大写，那么输出的十六进制数字也大写。 |
| %#hx、%#x、%#lx %#hX、%#X、%#lX | 以十六进制、带前缀、无符号的形式输出 short、int、long 类型的整数。如果 x 小写，那么输出的十六进制数字和前缀都小写；如果 X 大写，那么输出的十六进制数字和前缀都大写。 |
| %f、%lf | 以十进制的形式输出 float、double 类型的小数 |
| %e、%le %E、%lE | 以指数的形式输出 float、double 类型的小数。如果 e 小写，那么输出结果中的 e 也小写；如果 E 大写，那么输出结果中的 E 也大写。 |
| %g、%lg %G、%lG | 以十进制和指数中较短的形式输出 float、double 类型的小数，并且小数部分的最后不会添加多余的 0。如果 g 小写，那么当以指数形式输出时 e 也小写；如果 G 大写，那么当以指数形式输出时 E 也大写。 |
| %s | 输出一个字符串 |
比如现在进行小数的运算
#include <stdio.h>
int main() {
double a = 0.5;
float b = 2.5f; //注意直接写2.5默认表示的是一个double类型的值，需要再后面加一个f或是F表示是flaot类型值
printf("a + b的结果是：%f", a + b); //根据上表得到，小数类型需要使用%f表示，这里可以直接将a + b放入其中
}
可以看到，结果也是正确的：
可以一次性打印多个，只需要填写多个占位符表示即可：
#include <stdio.h>
int main() {
double a = 0.5;
float b = 2.5f; //整数类型默认是int，如果要表示为long类型的值，也是需要在最后添加一个l或L
printf("a = %f, b = %f", a, b); //后面可以一直添加（逗号隔开），但是注意要和前面的占位符对应
}
结果也是正常的：
字符类型：
char c = 'A'; //字符需要使用单引号囊括，且只能有一个字符，不能写成'AA'，这就不是单个字符了
//注意这里的A代表的是A这个字符，对应的ASCII码是65，实际上c存储的是65这个数字
通过格式化打印来查看它的值：
#include <stdio.h>
int main() {
char c = 'A';
printf("变量c的值为：%c 对应的ASCII码为：%d", c, c); //这里使用%c来以字符形式输出，%d输出的是变量数据的整数形式，其实就是对应的ASCII码
}
char存储一个数字（ASCII码），同样也可以打印出对应的字符：
#include <stdio.h>
int main() {
char c = 66;
printf("变量c的值为：%c 对应的ASCII码为：%d", c, c);
}
：
#include <stdio.h>
int main() {
int a = 10;
char c = 'a';
printf("变量c的ASCII码为：%d", c);
}
结果就是字符a的ASCII码值，注意千万不要认为c得到的是变量a的值，这里使用的是字符a，跟上面的变量a半毛钱关系都没有：
如果去掉引号，就相当于把变量a的值给了c，c现在的ASCII码就是10了，所以这里一定要分清楚。
对于某些无法表示的字符，比如换行这类字符，没办法直接敲出来，只能使用转义字符进行表示：
char c = '\n';
详细的转义字符表参见前面的基本数据类型章节。
变量除了有初始值之外，也可以在后续的过程中得到新的值：
#include <stdio.h>
int main() {
short s = 10;
s = 20; //重新赋值为20，注意这里就不要再指定类型了，指定类型只有在声明变量时才需要
printf("%d", s); //打印结果
}
变量会不会有默认值：
#include <stdio.h>
int main() {
int a, b, c, d;
printf("%d,%d,%d,%d", a, b, c, d);
}
可以看到，虽然定义变量但是没有为其设定初始值，那么它的值就是不确定的了（千万注意并不是不设定值默认就是0）：
至于为什么不是0，这是因为内存分配机制，高级篇再进行讲解。
再来看一个例子：
#include <stdio.h>
int main() {
char c = 127; //已经到达c的最大值了
c = c + 1; //我不管，我就要再加
printf("%d", c); //这时会得到什么结果？
}
怎么127加上1还变成-128了呢？这是由于位数不够，导致运算结果值溢出：
- 127 + 1= 01111111 + 1
- 由于现在是二进制，满2进1，所以最后变成
- 10000000 = 补码形式的 -128
了解上面这些计算机底层原理是很重要的，能够很轻松地知道为什么会这样。
在运算中，可能也会存在一些一成不变的值，比如π的值永远都是3.1415....，在程序中，也可以使用这样不可变的变量，成为常量。
定义常量和变量比较类似，但是需要在前面添加一个const关键字，表示这是一个常量：
可以看到，常量在一开始设定初始值后，后续是不允许进行修改的。
无符号数
知道，所有的数据底层都是采用二进制来进行保存的，而第一位则是用于保存符号位，但是如果不考虑这个符号位，那么所有的数都是按照正数来表示，比如考虑了符号位的char类型：
- 考虑符号表示范围：-128~127
- 不考虑符号：0~255
可以直接使用这些不带符号位的数据类型：
int main() {
unsigned char c = -65; //数据类型前面添加unsigned关键字表示采用无符号形式
printf("%u", c); //%u以无符号形式输出十进制数据
}
可以看到这里给了无符号char类型c一个-65的值，但是现在很明显符号位也是作为数值的表示部分，所以结果肯定不是-65：
结合前面学习的基础知识，来看看为什么得到的是191这个数字。首先char类型占据一个字节，8个bit位：
- 00000000 -> 现在赋值-65 -> -65的补码形式 -> 10111111
- 由于现在没有符号位，一律都是正数，所以，10111111 = 128 + 32 + 16 + 8 + 4 + 2 + 1 = 191
直接以无符号数形式打印：
#include <stdio.h>
int main() {
int i = -1;
printf("%u", i); //%u以无符号形式输出十进制数据
}
得到无符号int的最大值。
类型转换
一种类型的数据可以转换为其他类型的数据，这种操作称为类型转换，类型转换分为自动类型转换和强制类型转换，比如现在希望将一个short类型的数据转换为int类型的数据：
#include <stdio.h>
int main() {
short s = 10;
int i = s; //直接将s的值传递给i即可，但是注意此时s和i的类型不同
}
这里其实就是一种自动类型转换，自动类型转换就是编译器隐式地进行的数据类型转换，这种转换不需要做什么，直接写就行，会自动进行转换操作。
float a = 3; //包括这里给的明明是一个int整数3但是却可以赋值给float类型，说明也是进行了自动类型转换
如果使用一个比转换的类型最大值都还要大的值进行类型转换，比如：
#include <stdio.h>
int main() {
int a = 511;
char b = a; //最大127
printf("%d", b);
}
很明显char类型是无法容纳大于127的数据的，因为只占一个字节，而int占4个字节，如果需要进行转换，那么就只能丢掉前面的就只保留char所需要的那几位了，所以这里得到的就是-1：
- 511 = int -> 00000000 00000000 00000001 11111111
- char -> 11111111 -> -1
也可以将整数和小数类型的数据进行互相转换：
#include <stdio.h>
int main() {
int a = 99;
double d = a;
printf("%f", d);
}
不过这里需要注意的是，小数类型在转换回整数类型时，会丢失小数部分（注意，不是四舍五入，是直接丢失小数！）：
#include <stdio.h>
int main() {
double a = 3.14;
int b = a; //这里编译器还提示了黄标，可以通过之后讲到的强制类型转换来处理
printf("%d", b);
}
除了赋值操作可以进行自动类型转换之外，在运算中也会进行自动类型转换，比如：
#include <stdio.h>
int main() {
float a = 2;
int b = 3;
double c = b / a; // "/" 是除以的意思，也就是数学中的除法运算，这里表示a除以b
printf("%f", c);
}
可以看到，这里得到的结果是小数1.5，但是参与运算的既有整数类型，又有浮点类型，结果为什么就确定为浮点类型了呢？这显然是由于类型转换导致的。规则如图
- 不同的类型优先级不同（根据长度而定）
- char和short类型在参与运算时一律转换为int再进行运算。
- 浮点类型默认按双精度进行计算，所以就算有float类型，也会转换为double类型参与计算。
- 当有一个更高优先级的类型和一个低优先级的类型同时参与运算时，统一转换为高优先级运算，比如int和long参与运算，那么int转换为long再算，所以结果也是long类型，int和double参与运算，那么先把int转换为double再算。
接着来看看强制类型转换，可以为手动去指定类型，强制类型转换格式如下：
(强制转换类型) 变量、常量或表达式;
比如：
#include <stdio.h>
int main() {
int a = (int) 2.5; //2.5是一个double类型的值，但是可以强制转换为int类型赋值给a，强制转换之后小数部分丢失
printf("%d", a);
}
对一个算式的结果进行类型转换：
#include <stdio.h>
int main() {
double a = 3.14;
int b = (int) (a + 2.8); //注意得括起来表示对整个算式的结果进行类型转换（括号跟数学中的挺像，也是提升优先级使用的，会在运算符部分详细讲解），不然强制类型转换只对其之后紧跟着的变量生效
printf("%d", b);
}
在需要得到两个int相除之后带小数的结果时，强制类型转换就显得很有用：
#include <stdio.h>
int main() {
int a = 10, b = 4;
double c = a / b; //不进行任何的类型转换，int除以int结果仍然是int，导致小数丢失
double d = (double) a / b; //对a进行强制类型转换，现在是double和int计算，根据上面自动类型转换规则，后面的int自动转换为double，结果也是double了，这样就是正确的结果了
printf("不进行类型转换: %f, 进行类型转换: %f", c, d);
}
合理地使用强制类型转换，能够解决很多情况下的计算问题。
运算符
前面了解了如何声明变量以及变量的类型转换，那么如何去使用这些变量来参与计算呢？这是本小节的重点。
基本运算符
基本运算符包含在数学中常用的一些操作，比如加减乘除，分别对应：
- 加法运算符：+
- 减法运算符：-
- 乘法运算符：*
- 除法运算符：/（注意不是“\”，看清楚一点）
当然，还有之前使用的赋值运算符=，先来看看赋值运算符的使用，其实在之前已经学习过了：
变量 = 值 //其中，值可以直接是一个数字、一个变量、表达式的结果等
实际上等号左边的内容准确的说应该是一个左值，不过大部分情况下都是变量，这里就不展开左值和右值的话题了（有助于后面学习C++理解右值引用）
最简单的用法就是前面所说的，对一个变量进行赋值操作：
int a = 10;
也可以连续地使用赋值操作，让一连串的变量都等于后面的值：
int a, b;
a = b = 20; //从右往左依次给b和a赋值20
可以看出，实际上=运算除了赋值之外，和加减乘除运算一样也是有结果的，比如上面的 a = 就是b = 20 运算的结果（可以看着一个整体），只不过运算的结果就是b被赋值的值，也就是20。
加减法，这个就和数学中的是一样的了：
#include <stdio.h>
int main() {
int a = 10, b = 5;
printf("%d", a + b); //打印 a + b 的结果
}
当然也可以像数学中那样写在一个数或是变量的最前面，表示是正数：
int a = +10, b = +5;
不过默认情况下就是正数，所以没必要去写一个+号。减法运算符其实也是一样的：
#include <stdio.h>
int main() {
int a = 10, b = 5;
printf("%d", a - b); //打印 a - b 的结果
}
#include <stdio.h>
int main() {
int a = -10; //等于 -10
printf("%d", -a); //输出 -a 的值，就反着来嘛
}
乘法和除法运算：
#include <stdio.h>
int main() {
int a = 20, b = 10;
printf("%d, %d", a * b, a / b); //使用方式和上面的加减法是差不多的
}
还有一个比较有意思的取模运算：
#include <stdio.h>
int main() {
int a = 20, b = 8;
printf("%d", a % b); //取模运算实际上就是计算a除以b的余数
}
不过很遗憾，在C中没有指数相关的运算符（比如要计算5的10次方），在后面学习了循环语句之后，可以尝试来自己实现一个指数运算。
运算符优先级
和数学中一样，运算符是有优先级的：
#include <stdio.h>
int main() {
int a = 20, b = 10;
printf("%d", a + a * b); //如果没有优先级，那么结果应该是400
}
很明显这里的结果是考虑了优先级的：
在数学中，加减运算的优先级是没有乘除运算优先级高的，所以需要先计算那些乘除法，最后再来进行加减法的计算，而C语言中也是这样，运算符之间存在优先级概念。在数学中，如果需要优先计算加减法再计算乘除法，那么就需要使用括号来提升加减法的优先级，C语言也可以：
#include <stdio.h>
int main() {
int a = 20, b = 10;
printf("%d", (a + a) * b); //优先计算 a + a 的结果，再乘以 b
}
那要是遇到多重的呢？类似于下面的这种：
数学上的写法：[1 - (3 + 4)] x (-2 ÷ 1) = ?
那么在C中就可以这样编写：
#include <stdio.h>
int main() {
printf("%d", (1 - (3 + 4)) * (-2 / 1)); //其实写法基本差不多，只需要一律使用小括号即可
}
这样，就可以通过()运算符，来提升运算优先级了。
来总结一下，上面运算符优先级如下，从左往右依次递减：
()>+ - (做符号表示，比如-9)>* / %>+ - (做加减运算)>=
根据上面的优先级，来看看下面a的结果是什么：
int c;
int a = (3 + (c = 2)) * 6;
int b, c;
int a = (b = 5, c = b + 8); //逗号运算符从前往后依次执行，赋值结果是最后边的结果
自增自减运算符
快速使用自增运算符来将变量的值+1，正常情况下想要让一个变量值自增需要：
int a = 10;
a = a + 1;
只需要替换为：
int a = 10;
++a; //使用自增运算符，效果等价于 a = a + 1
并且它也是有结果的，除了做自增运算之外，它的结果是自增之后的值：
#include <stdio.h>
int main() {
int a = 10;
//int b = a = a + 1; 下面效果完全一致
int b = ++a;
printf("%d", b);
}
可以将自增运算符写到后面，和写在前面的区别是，它是先返回当前变量的结果，再进行自增，顺序是完全相反：
#include <stdio.h>
int main() {
int a = 10;
int b = a++; //写在后面和写在前面是有区别的
printf("a = %d, b = %d", a, b);
}
重点内容：自增运算符
++在前，那么先自增再出结果；自增运算符++在后，那么先出结果再自增。直接记运算符的位置，来方便记忆。
不想自增1而是自增2或是其他的数字，可使用复合赋值运算符，正常情况下依然是使用普通的赋值运算符：
int a = 10;
a = a + 5;
可以简写：
int a = 10;
a += 5;
效果和上面是完全一样，并且得到的结果也是在自增之后的：
#include <stdio.h>
int main() {
int a = 10;
int b = a += 5;
printf("a = %d", b);
}
复合赋值运算符不仅仅支持加法，还支持各种各样的运算：
#include <stdio.h>
int main() {
int a = 10;
a %= 3; //可以复合各种运算，比如加减乘除、模运算、包括还要讲到的位运算等
printf("a = %d", a);
}
自增操作之外，还有自减操作：
#include <stdio.h>
int main() {
int a = 10;
a--; //--是自减操作，相当于a = a - 1，也可以在前后写，规则和上面的自增是一样的
printf("a = %d", a);
}
注意自增自减运算符和+、-做符号是的优先级一样，仅次于()运算符，编写时一定要注意：
#include <stdio.h>
int main() {
int a = 10;
int b = 5 * --a;
printf("b = %d", b);
}
位运算符
乘法运算符*，当想要让一个变量的值变成2倍，只需要做一次乘法运算即可：
int a = 10;
a *= 2; //很明显算完之后a就是20了
可以利用位运算来快速进行计算：
int a = 10;
a = a << 1; //也可以写成复合形式 a <<= 1
运算之后得到的结果居然也是20，实际上<<是让所有的bit位进行左移操作，上面就是左移1位，可以来看看：
- 10 = 00001010 现在所以bit位上的数据左移一位 00010100 = 20
就像在十进制中，做乘以10的操作一样：22乘以10那么就直接左移了一位变成220，而二进制也是一样的，如果让这些二进制数据左移的话，那么相当于在进行乘2的操作。
比如：
#include <stdio.h>
int main() {
int a = 6;
a = a << 2; //让a左移2位，实际上就是 a * 2 * 2，a * 2的平方（类比十进制，其实还是很好理解的）
printf("a = %d", a);
}
当然能左移那肯定也可以右移：
#include <stdio.h>
int main() {
int a = 6;
a = a >> 1; //右移其实就是除以2的操作
printf("a = %d", a);
}
当然除了移动操作之外，也可以进行按位比较操作，先来看看按位与操作：
#include <stdio.h>
int main() {
int a = 6, b = 4;
int c = a & b; //按位与操作
printf("c = %d", c);
}
按位与实际上也是根据每个bit位来进行计算的：
- 4 = 00000100
- 6 = 00000110
- 按位与实际上就是让两个数的每一位都进行比较，如果两个数对应的bit位都是1，那么结果的对应bit位上就是1，其他情况一律为0
- 所以计算结果为：00000100 = 4
除了按位与之外，还有按位或运算：
int a = 6, b = 4;
int c = a | b;
- 4 = 00000100
- 6 = 00000110
- 按位与实际上也是让两个数的每一位都进行比较，如果两个数对应bit位上其中一个是1，那么结果的对应bit位上就是1，其他情况为0。
- 所以计算结果为：00000110 = 6
还有异或和按位非（按位否定）：
int a = 6, b = 4;
int c = a ^ b; //注意^不是指数运算，表示按位异或运算，让两个数的每一位都进行比较，如果两个数对应bit位上不同时为1或是同时为0，那么结果就是1，否则结果就是0，所以这里的结果就是2
a = ~a; //按位否定针对某个数进行操作，它会将这个数的每一个bit位都置反，0变成1，1变成0，猜猜会变成几
按位运算都是操作数据底层的二进制位来进行的。
逻辑运算符
逻辑运算符用于计算真和假：
#include <stdio.h>
int main() {
int a = 10;
_Bool c = a < 0; //现在想要判断a的值是否小于0，可以直接使用小于符号进行判断，最后得到的结果只能是1或0
//虽然结果是一个整数，但是这里推荐使用_Bool类型进行接收，它只能表示0和1（更加专业一些）
printf("c = %d", c);
}
实际上在C语言中，0一般都表示为假，而非0的所有值（包括正数和负数）都表示为真，上面得到1表示真，0表示假。
除了小于符号可以判断大小之外，还有：<、 <=、>=、>
比如现在想要判断字符C是否为大写字母：
#include <stdio.h>
int main() {
char c = 'D';
printf("c是否为大写字母：%d", c >= 'A'); //由于底层存储的就是ASCII码，这里可以比较ASCII码，也可以写成字符的形式
}
判断只能判断一个条件，只能判断c是否是大于等于'A'的，但是不能同时判断c的值是否是小于等于'Z'的，利用逻辑与和逻辑或来连接两个条件了：
#include <stdio.h>
int main() {
char c = 'D';
printf("c是否为大写字母：%d", c >= 'A' && c <= 'Z'); //使用&&表示逻辑与，逻辑与要求两边都是真，结果才是真
}
判断c是否不是大写字母：
#include <stdio.h>
int main() {
char c = 'D';
printf("c是否不为大写字母：%d", c < 'A' || c > 'Z'); //使用||表示逻辑或，只要两边其中一个为真或是都为真，结果就是真
}
判断c是否为某个字母：
#include <stdio.h>
int main() {
char c = 'D';
printf("c是否为字母A：%d", c == 'A'); //注意判断相等时使用==双等号
}
判断不相等：
printf("c是否不为字母A：%d", c != 'A');
对某个结果取反：
#include <stdio.h>
int main() {
int i = 20;
printf("i是否不小于20：%d", !(i < 20)); //使用!来对结果取反，注意!优先级很高，一定要括起来，不然会直接对i生效
}
这里要注意一下!如果直接作用于某个变量或是常量，那么会直接按照上面的规则（0表示假，非0表示真）非0一律转换为0，0一律转换为1。
这里可以结合三目运算符来使用这些逻辑运算符：
#include <stdio.h>
int main() {
int i = 0;
char c = i > 10 ? 'A' : 'B'; //三目运算符格式为：expression ? 值1 : 值2，返回的结果会根据前面判断的结果来的
//这里是判断i是否大于10，如果大于那么c的值就是A，否则就是B
printf("%d", c);
}
总结所有运算符的优先级，从上往下依次降低：
| 运算符 | 解释 | 结合方式 |
|---|---|---|
| () | 同数学中的括号，直接提升到最高优先级 | 由左向右 |
| ! ~ ++ -- + - | 否定，按位否定，增量，减量，正负号 | 由右向左 |
| * / % | 乘，除，取模 | 由左向右 |
| + - | 加，减 | 由左向右 |
| << >> | 左移，右移 | 由左向右 |
| < <= >= > | 小于，小于等于，大于等于，大于 | 由左向右 |
| == != | 等于，不等于 | 由左向右 |
| & | 按位与 | 由左向右 |
| ^ | 按位异或 | 由左向右 |
| | | 按位或 | 由左向右 |
| && | 逻辑与 | 由左向右 |
| || | 逻辑或 | 由左向右 |
| ? : | 条件 | 由右向左 |
| = += -= *= /= &= ^= |= <<= >>= | 各种赋值 | 由右向左 |
| , | 逗号（顺序） | 由左向右 |
流程控制
分支语句 - if
判断某个条件，当满足此条件时，才执行某些代码，使用if语句来实现：
#include <stdio.h>
int main() {
int i = 0;
if(i > 20) { //只希望i大于20的时候才执行下面的打印语句
printf("Hello World!");
}
printf("Hello World?"); //后面的代码在if之外，无论是否满足if条件，都跟后面的代码无关，所以这里的代码任何情况下都会执行
}
if语句的标准格式如下：
if(判断条件) {
执行的代码
}
执行一行代码，省略花括号：
if(判断条件)
一行执行的代码 //注意这样只有后一行代码生效，其他的算作if之外的代码了
判断某个条件，满足此条件时，执行某些代码，不满足时，想要执行另一段代码，就可以结合else语句来实现：
#include <stdio.h>
int main() {
int i = 0;
if(i > 20) {
printf("Hello World!"); //满足if条件才执行
} else {
printf("LBWNB"); //不满足if条件才执行
}
}
连续判断，需要使用else-if来完成：
#include <stdio.h>
int main() {
int score = 2;
if(score >= 90) {
printf("优秀");
} else if (score >= 70) {
printf("良好");
} else if (score >= 60){
printf("及格");
} else{
printf("不及格");
}
}
if这类的语句（包括下面还要介绍的三种）支持嵌套使用：
#include <stdio.h>
int main() {
int score = 2;
if(score < 60) { //先判断不及格
if(score > 30) { //在内层再嵌套一个if语句进行进一步的判断
printf("学习C++");
} else{
printf("学习Java");
}
}
}
分支语句 - switch
switch更适用于多分支的情况：
switch (目标) { //需要传入一个目标，比如变量，或是计算表达式等
case 匹配值: //如果目标的值等于这里给定的匹配值，那么就执行case后面的代码
代码...
break; //代码执行结束后需要使用break来结束，否则会继续溜到下一个case继续执行代码
}
等级进行分班，学生有ABC三个等级：
#include <stdio.h>
int main() {
char c = 'A';
switch (c) { //这里目标就是变量c
case 'A': //分别指定ABC三个匹配值，并且执行不同的代码
printf("去尖子班！准备冲刺985大学！");
break; //执行完之后一定记得break，否则会继续向下执行下一个case中的代码
case 'B':
printf("去平行班！准备冲刺一本！");
break;
case 'C':
printf("去职高深造。");
break;
}
}
switch可以精准匹配某个值，但是它不能进行范围判断，比如要判断分数段，这时用switch就很鸡肋了。
当然除了精准匹配之外，其他的情况可以用default来表示：
switch (目标) {
case: ...
default:
其他情况下执行的代码
}
比如：
#include <stdio.h>
int main() {
char c = 'A';
switch (c) {
case 'A':
printf("去尖子班！");
break;
case 'B':
printf("去平行班！");
break;
case 'C':
printf("去差生班！");
break;
default: //其他情况一律就是下面的代码了
printf("去读职高，分流");
}
}
switch中继续嵌套其他的流程控制语句，比如if：
#include <stdio.h>
int main() {
char c = 'A';
switch (c) {
case 'A':
if(c == 'A') { //嵌套一个if语句
printf("去尖子班！");
}
break;
case 'B':
printf("去平行班！");
break;
}
}
循环语句 - for
批量执行某些代码：
#include <stdio.h>
int main() {
printf("伞兵一号卢本伟准备就绪！"); //把这句话给我打印三遍
printf("伞兵一号卢本伟准备就绪！");
printf("伞兵一号卢本伟准备就绪！");
}
for循环语句来多次执行：
for (表达式1表达式2;表达式3) {
循环体
}
来介绍一下：
- 表达式1：在循环开始时仅执行一次。
- 表达式2：每次循环开始前会执行一次，要求为判断语句，用于判断是否可以结束循环，若结果为真，那么继续循环，否则结束循环。
- 表达式3：每次循环完成后会执行一次。
- 循环体：每次循环都会执行循环体里面的内容，直到循环结束。
一个标准的for循环语句写法如下：
//比如现在希望循环4次
for (int i = 0; i < 4; ++i) {
//首先定义一个变量i用于控制循环结束
//表达式2在循环开始之前判断是否小于4
//表达式3每次循环结束都让i自增一次，这样当自增4次之后不再满足条件，循环就会结束，正好4次循环
}
来看看按顺序打印的结果：
#include <stdio.h>
int main() {
//比如现在希望循环4次
for (int i = 0; i < 4; ++i) {
printf("%d, ", i);
}
}
注意，如果表达式2什么都不写，那么会默认判定为真：
#include <stdio.h>
int main() {
for (int i = 0; ; ++i) { //表达式2不编写任何内容，默认为真，这样的话循环永远都不会结束
printf("%d, ", i);
}
}
无限循环，都不用写：
#include <stdio.h>
int main() {
for (;;) { //什么都不写直接无限循环，但是注意，两个分号还是要写的
printf("Hello World!\n"); //这里用到了\n表示换行
}
}
提前终止或是加速循环新的关键字：
for (int i = 0; i < 10; ++i) {
if(i == 5) break; //比如现在希望在满足某个条件下提前终止循环，可以使用break关键字来跳出循环
printf("%d", i);
}
也可以加速循环：
for (int i = 0; i < 10; ++i) {
if(i == 5) continue; //使用continue关键字会加速循环，无论后面有没有未执行完的代码，都会直接开启下一轮循环
printf("%d", i);
}
break和continue关键字能够更方便的控制循环，在多重循环嵌套下，它只对离它最近的循环生效（就近原则）：
for (int i = 1; i < 4; ++i) {
for (int j = 1; j < 4; ++j) {
if(i == j) continue; //当i == j时加速循环
printf("%d, %d\n", i, j);
}
}
continue仅仅加速的是内层循环，而对外层循环没有任何效果，break也只会终结离它最近的：
for (int i = 1; i < 4; ++i) {
for (int j = 1; j < 4; ++j) {
if(i == j) break; //当i == j时终止循环
printf("%d, %d\n", i, j);
}
}
循环语句 - while
while循环，for循环要求填写三个表达式，而while相当于是一个简化版本，它只需要填写循环的维持条件即可，比如：
#include <stdio.h>
int main() {
while (1) { //每次循环开始之前都会判断括号内的内容是否为真，如果是就继续循环
printf("Hello World!\n"); //这里会无限循环
}
}
相比for循环，while循环更多的用在不明确具体的结束时机的情况下，而for循环更多用于明确知道循环的情况，比如现在明确要进行循环10次，此时用for循环会更加合适一些，又比如现在只知道当i大于10时需要结束循环，但是i在循环多少次之后才不满足循环条件并不知道，此时使用while就比较合适了。
#include <stdio.h>
int main() {
int i = 100; //比如现在想看看i不断除以2得到的结果会是什么，但是循环次数并不明确
while (i > 0) { //现在唯一知道的是循环条件，只要大于0那么就可以继续除
printf("%d, ", i);
i /= 2; //每次循环都除以2
}
}
while也支持使用break和continue来进行循环的控制：
int i = 100;
while (i > 0) {
if(i < 30) break;
printf("%d, ", i);
i /= 2;
}
可以反转循环判断的位置，可以先执行循环内容，然后再做循环条件判断，这里要用到do-while语句：
#include <stdio.h>
int main() {
do { //无论满不满足循环条件，先执行循环体里面的内容
printf("Hello World!");
} while (0); //再做判断，如果判断成功，开启下一轮循环，否则结束
}
实战：寻找水仙花数
“水仙花数（Narcissistic number）也被称为超完全数字不变数（pluperfect digital invariant, PPDI）、自恋数、自幂数、阿姆斯壮数或阿姆斯特朗数（Armstrong number），水仙花数是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身。例如：1^3 + 5^3+ 3^3 = 153。”
现在请你设计一个C语言程序，打印出所有1000以内的水仙花数。
for (int i = 100; i < 1000; ++i) {
int g = i % 10 % 10, s = i / 10 % 10, b = i / 100;
if (g * g * g + s * s * s + b * b * b == i) {
printf("%d\n", i);
}
// printf("%d,%d,%d\n", b, s, g);
}
实战：打印九九乘法表
现在要做的是在的程序中，也打印出这样的一个乘法表出来，请你设计一个C语言程序来实现它。
#include <stdio.h>
int main() {
for (int i = 1; i < 10; ++i) {
for (int j = 01; j < i; ++j) {
printf("%d×%d=%d\t", i, j, i * j);
}
printf("\n");
}
}
实战：斐波那契数列解法其一
斐波那契数列（Fibonacci sequence），又称黄金分割数列，因数学家莱昂纳多·斐波那契（Leonardo Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……在数学上，斐波那契数列以如下被以递推的方法定义：F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 2，n ∈ N*）在现代物理、准晶体结构、化学等领域，斐波纳契数列都有直接的应用，为此，美国数学会从 1963 年起出版了以《斐波纳契数列季刊》为名的一份数学杂志，用于专门刊载这方面的研究成果。
斐波那契数列：1，1，2，3，5，8，13，21，34，55，89...，不难发现一个规律，实际上从第三个数开始，每个数字的值都是前两个数字的和，现在请你设计一个C语言程序，可以获取斐波那契数列上任意一位的数字，比如获取第5个数，那么就是5。
#include <stdio.h>
int main() {
int target = 7, result; //target是要获取的数，result是结果
//请在这里实现算法
int f1 = 1, f2 = 1;
for (int i = 3; i <= target; ++i) {
result = f1 + f2;
f1 = f2;
f2 = result;
}
//printf("%d\n", result);
printf("%d", result);
}
数组
数组的创建和使用
简单来说，就是存放数据的一个组，所有的数据都统一存放在这一个组中，一个数组可以同时存放多个数据。比如现在想保存12个月的天数，那么只需要创建一个int类型的数组，它可以保存很多个int类型的数据，这些保存在数组中的数据，称为“元素”：
int arr[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; //12个月的数据全部保存在了一起
可以看到，数组的定义方式也比较简单：
类型 数组名称[数组大小] = {数据1, 数据2...}; //后面的数据可以在一开始的时候不赋值，并且数组大小必须是整数
注意数组只能存放指定类型的数据，一旦确定是不能更改的，因为数组声明后，会在内存中开辟一块连续的区域，来存放这些数据，所以类型和长度必须在一开始就明确。
创建数组的方式有很多种：
int a[10]; //直接声明int类型数组，容量为10
int b[10] = {1, 2, 4}; //声明后，可以赋值初始值，使用{}囊括，不一定需要让10个位置都有初始值，比如这里仅仅是为前三个设定了初始值，注意，跟变量一样，如果不设定初始值，数组内的数据并不一定都是0
int c[10] = {1, 2, [4] = 777, [9] = 666}; //也可以通过 [下标] = 的形式来指定某一位的初始值，注意下标是从0开始的，第一个元素就是第0个下标位置，比如这里数组容量为10，那么最多到9
int c[] = {1, 2, 3}; //也可以根据后面的赋值来决定数组长度
基本类型都可以声明数组：
#include <stdio.h>
int main() {
char str[] = {'A', 'B', 'C'}; //多个字符
char str2[] = "ABC"; //实际上字符串就是多个字符的数组形式，有关字符串会在下一节进行讲解
}
使用
#include <stdio.h>
int main() {
int arr[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
for (int i = 0; i < 12; ++i) {
int days = arr[i]; //直接通过数组 名称[下标] 来访问对应的元素值，再次提醒，下标是从0开始的，不是1
printf("2022年 %d 月的天数是：%d 天\n", (i + 1), days);
}
}
对数组中的值进行修改：
#include <stdio.h>
int main() {
int arr[] = {666, 777, 888};
arr[1] = 999; //比如现在想要让第二个元素的值变成999
printf("%d", arr[1]); //打印一下看看是不是变成了999
}
注意，和变量一样，如果只是创建数组但是不赋初始值的话，因为是在内存中随机申请的一块空间，有可能之前其他地方使用过，保存了一些数据，所以数组内部的元素值并不一定都是0：
#include <stdio.h>
int main() {
int arr[10];
for (int i = 0; i < 10; ++i) {
printf("%d, ", arr[i]);
}
}
不要尝试去访问超出数组长度位置的数据，虽然可以编译通过，但是会给警告，这些数据是毫无意义的（索引越界）：
#include <stdio.h>
int main() {
int arr[] = {111, 222, 333};
printf("%d", arr[3]); //不能去访问超出数组长度的元素，很明显这里根本就没有第四个元素
}
多维数组
数组不仅仅只可以有一个维度，可以创建二维甚至多维的数组，存放数组的数组（套娃了属于是）：
int arr[][2] = {{20, 10}, {18, 9}}; //可以看到，数组里面存放的居然是数组
//存放的内层数组的长度是需要确定的，存放数组的数组和之前一样，可以根据后面的值决定
比如现在要存放2020-2022年每个月的天数，那么此时用一维数组肯定是不方便了，就可以使用二维数组来处理：
int arr[3][12] = {{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, //2020年是闰年，2月有29天
{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
这样，就通过二维数组将这三年每个月的天数都保存下来了。
二维数组又该如何去访问
#include <stdio.h>
int main() {
int arr[3][12] = {{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, //2020年是闰年，2月有29天
{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
printf("%d", arr[0][1]); //比如现在想要获取2020年2月的天数，首先第一个是[0]表示存放的第一个数组，第二个[1]表示数组中的第二个元素
}
二维还可以上升到三维、四维：
int arr[2][2][2] = {{{1, 2}, {1, 2}}, {{1, 2}, {1, 2}}};
实战：冒泡排序算法
C语言将数组中的数据按从小到大的顺序进行排列：
#include <stdio.h>
int main() {
int arr[10] = {3, 5, 7, 2, 9, 0, 6, 1, 8, 4}; //乱序的
//请编写代码对以上数组进行排序
_Bool flag = 0;
for (int i = 0; i < 9; ++i) {
for (int j = 0; j < 10 - i; ++j) {
if (arr[j] < arr[i]) {
int swap = arr[j - 1];
arr[j - 1] = arr[j];
arr[j] = swap;
flag = 1;
}
if (flag == 0)break;
}
}
for (int i = 0; i < 10; ++i) {
printf("%d\t", arr[i]);
}
}
这里使用冒泡排序算法来实现，此算法的核心思想是：
- 假设数组长度为N
- 进行N轮循环，每轮循环都选出一个最大的数放到后面。
- 每次循环中，从第一个数开始，让其与后面的数两两比较，如果更大，就交换位置，如果更小，就不动。
动画演示：https://visualgo.net/zh/sorting?slide=2-2
实战：斐波那契数列解法其二
利用数组来计算斐波那契数列，这里采用动态规划的思想。
动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，希望找到具有最优值的解。动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。
可以在一开始创建一个数组，然后从最开始的条件不断向后推导，从斐波那契数列的规律可以得知：
fib[i] = fib[i - 1] + fib[i - 2]（这里fib代表斐波那契数列）
得到这样的一个关系（递推方程）就好办了，要求解数列第i个位置上的数，只需要知道i - 1和i - 2的值即可，这样，一个大问题，就分成了两个小问题，比如现在要求解斐波那契数列的第5个元素：
fib[4] = fib[3] + fib[2]现在只需要知道fib[3]和fib[2]即可，那么接着来看：fib[3] = fib[2] + fib[1]以及fib[2] = fib[1] + fib[0]- 由于
fib[0]和fib[1]已经明确知道是1了，那么现在问题其实已经有结果了，把这些小问题的结果组合起来不就能得到原来大问题的结果了吗？
现在请你设计一个C语言程序，利用动态规划的思想解决斐波那契数列问题。
#include <stdio.h>
int main() {
int target = 7;
int dp[target];
dp[0] = dp[1] = 1;
for (int i = 2; i < target; ++i) {
dp[i] = dp[i - 1] + dp[i - 2];
// printf("%d\n", dp[i]);
}
printf("%d", dp[target - 1]);
}
实战：打家劫舍
继续通过一道简单的算法题来强化动态规划思想。
来源：力扣（LeetCode）No.198 打家劫舍：https://leetcode.cn/problems/house-robber/
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
示例 1：
输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。
示例 2：
输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。
这道题也可以很轻松地按照上面的动态规划思路来处理，首先可以将问题分为子问题，比如现在有[2,7,9,3,1]五个房屋，这个问题看起来比较复杂，不妨先将大问题先简化成小问题，来看看只有N个房屋的情况：
- 假设现在只有
[2]这一个房屋，那么很明显，我可以直接去偷一号房，得到2块钱，所以当有一个房子时最大能偷到2块钱。 - 假设现在有
[2, 7]这两个房屋，那么很明显，我可以直接去偷二号房，得到7块钱，所以当有两个房子时最大能偷到7块钱。 - 假设现在只有
[2, 7, 9]这三个房屋，就要来看看了，是先偷一号房再偷三号房好，还是只偷二号房好，根据前面的结论，如果偷了一号房，那么就可以继续偷三号房，并且得到的钱就是从一号房过来的钱+三号房的钱，也就是2+9块钱，但是如果只偷二号房的话，那么就只能得到7块钱，所以，三号房能够偷到的最大金额有以下关系（dp是求出的第i个房屋的最大偷钱数量，value表示房屋价值，max表示取括号中取最大的一个）：dp[i] = max(dp[i - 1], dp[i - 2] + value[i])-> 递推方程已得到
- 这样就不难求出：
dp[2] = max(dp[1], dp[0] + value[i])=dp[2] = max(7, 2 + 9)=dp[2] = 11，所以有三个房屋时最大的金额是11块钱。 - 所以，实际上只需要关心前面计算出来的盗窃最大值即可，而不需要关心前面到底是怎么在偷。
- 以同样的方式来计算四个房屋
[2, 7, 9, 3]的情况：dp[3] = max(dp[2], dp[1] + value[3])=dp[3] = max(11, 7 + 3)=dp[3] = 11
- 所以，当有四个房屋时，依然采用先偷一后偷三的方案，不去偷四号，得到最大价值11块钱。
好了，现在思路已经出来了，直接上算法吧，现在请你实现下面的C语言程序：
#include <stdio.h>
int main() {
int arr[] = {2,7,9,3,1}, size = 5, result;
int dp[size];
dp[0] = arr[0];
dp[1] = arr[1];
dp[1] = dp[0] > dp[1] ? dp[0] : dp[1];
for (int i = 2; i < size; ++i)
dp[i] = dp[i - 1] > dp[i - 2] + arr[i] ? dp[i - 1] : dp[i - 2] + arr[i];
result = dp[size - 1];
printf("%d", result);
}
力扣提交，建议各位小伙伴学习了函数和指针之后再回来看看，这里暂时可以跳过。
int max(int a, int b) {
return a > b ? a : b;
}
int rob(int* nums, int numsSize){
if(numsSize == 0) return 0;
if(numsSize == 1) return nums[0];
if(numsSize == 2) return max(nums[1], nums[0]);
int dp[numsSize];
dp[0] = nums[0];
dp[1] = max(nums[1], nums[0]);
for (int i = 2; i < numsSize; ++i) {
dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
}
return dp[numsSize - 1];
}
字符串
前面学习了数组，而对于字符类型的数组，比较特殊，它实际上可以作为一个字符串（String）表示，字符串就是一个或多个字符的序列，比如在一开始认识的"Hello World!"，像这样的多个字符形成的一连串数据，就是一个字符串，而printf函数接受的第一个参数也是字符串。
字符串的创建和使用
在C语言中并没有直接提供存储字符串的类型，熟知的能够存储字符的只有char类型，但是它只能存储单个字符，而一连串的字符想要通过变量进行保存，那么就只能依靠数组了，char类型的数组允许存放多个字符，这样的话就可以表示字符串了。
比如现在想要存储Hello这一连串字符：
char str[] = {'H', 'e', 'l', 'l', 'o', '\0'}; //直接保存单个字符，但是注意，无论内容是什么，字符串末尾必须添加一个‘\0’字符（ASCII码为0）表示结束。
printf("%s", str); //用%s来作为一个字符串输出
不过这样写起来实在是太麻烦了，可以使用更加简便的写法：
char str[] = "Hello"; //直接使用双引号将所有的内容囊括起来，并且也不需要补充\0（但是本质上是和上面一样的字符数组）
//也可以添加 const char str[] = "Hello World!"; 双引号囊括的字符串实际上就是一个const char数组类型的值
printf("%s", str);
这下终于明白了，原来一直在写的双引号，其实表示的就是一个字符串。
那么现在请各位小伙伴看看下面的写法有什么不同：
"c"
'c'
发现一个问题，char类型只能保存ASCII编码表中的字符，但是发现实际上中文也是可以正常打印的：
printf("你这瓜保熟吗");
这是什么情况？那么多中文字符（差不多有6000多个），用ASCII编码表那128个肯定是没办法全部表示的，但是现在需要在电脑中使用中文。这时，就需要扩展字符集了。
可以使用两个甚至多个字节来表示一个中文字符，这样能够表示的数量就大大增加了，GB2132方案规定当连续出现两个大于127的字节时（注意不考虑符号位，此时相当于是第一个bit位一直为1了），表示这是一个中文字符（所以为什么常常有人说一个英文字符占一字节，一个中文字符占两个字节），这样就可以表示出超过7000种字符了，不仅仅是中文，甚至中文标点、数学符号等，都可以被正确的表示出来。
10000011 10000110 //这就是一个连续出现都大于127的字节（注意这里是不考虑符号位的）不过这样能够表示的内容还是不太够，除了那些常见的汉字之外，还有很多的生僻字，比如龘、錕、釿、拷这类的汉字，后来干脆直接只要第一个字节大于127，就表示这是一个汉字的开始，无论下一个字节是什么内容（甚至原来的128个字符也被编到新的表中），这就是Windows至今一直在使用的默认GBK编码格式。
虽然这种编码方式能够很好的解决中文无法表示的问题，但是由于全球还有很多很多的国家以及很多很多种语言，所以的最终目标是能够创造一种可以表示全球所有字符的编码方式，整个世界都使用同一种编码格式，这样就可以同时表示全球的语言了。所以这时就出现了一个叫做ISO的（国际标准化组织）组织，来定义一套编码方案来解决所有国家的编码问题，这个新的编码方案就叫做Unicode，规定每个字符必须使用俩个字节，即用16个bit位来表示所有的字符（也就是说原来的那128个字符也要强行用两位来表示）
但是这样的话实际上是很浪费资源的，因为这样很多字符都不会用到两字节来保存，但是又得这样去表示，这就导致某些字符浪费了很多空间。所以最后就有了UTF-8编码格式，区分每个字符的开始是根据字符的高位字节来区分的，比如用一个字节表示的字符，第一个字节高位以“0”开头；用两个字节表示的字符，第一个字节的高位为以“110”开头，后面一个字节以“10开头”；用三个字节表示的字符，第一个字节以“1110”开头，后面俩字节以“10”开头；用四个字节表示的字符，第一个字节以“11110”开头，后面的三个字节以“10”开头：
Unicode符号范围（十六进制） UTF-8编码方式(二进制) 0000 0000 ~ 0000 007F 0xxxxxxx 0000 0080 ~ 0000 07FF 110xxxxx 10xxxxxx 0000 0800 ~ 0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx 0001 0000 ~ 0010 FFFF 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 所以如果的程序需要表示多种语言，最好采用UTF-8编码格式。
简而言之，的中文实际上是依靠多个char来进行表示的。
这样，就了解了字符串的使用。
scanf、gets、puts函数
前面认识了printf函数，实际上这个函数就是用于打印字符串到控制台，只需要填入一个字符串和后续的参数。
#include <stdio.h>
int main() {
const char str[] = "Hello World!"; //注意printf需要填写一个const char数组进去，也就是字符串
printf(str);
}
程序从控制台读取输入的内容，这时就需要使用到scanf函数了：
#include <stdio.h>
int main() {
char str[10];
scanf("%s", str); //使用scanf函数来接受控制台输入，并将输入的结果按照格式，分配给后续的变量
//比如这里想要输入一个字符串，那么依然是使用%s（和输出是一样的占位符），后面跟上要赋值的数组（存放输入的内容）
printf("输入的内容为：%s", str);
}
扫描成字符串之外，直接扫描为一个数字：
#include <stdio.h>
int main() {
int a, b;
scanf("%d", &a); //连续扫描两个int数字
scanf("%d", &b); //注意，如果不是数组类型，那么这里在填写变量时一定要在前面添加一个&符号（至于为什么，下一章在指针小节中会详细介绍）这里的&不是做与运算，而是取地址操作。
printf("a + b = %d", a + b); //扫描成功后，来计算a + b的结果
}
除了使用scanf之外，也可以使用字符串专用的函数来接受字符串类型的输入和输出：
#include <stdio.h>
int main() {
char str[10];
gets(str); //gets也是接收控制台输入，然后将结果丢给str数组中
puts(str); //puts其实就是直接打印字符串到控制台
}
专门用于字符输入输出函数：
#include <stdio.h>
int main() {
int c = getchar();
putchar(c);
}
实战：回文串判断
“回文串”是一个正读和反读都一样的字符串，请你实现一个C语言程序，判断用户输入的字符串（仅出现英文字符）是否为“回文”串。
ABCBA 就是一个回文串，因为正读反读都是一样的
ABCA 就不是一个回文串，因为反着读不一样
#include <stdio.h>
#include <string.h>
int main() {
char str[64];
gets(str);
int len = strlen(str), left = 0, right = len - 1, flag = 1;
while (str[right] > str[left]) {
if (str[right] != str[left]) {
flag = 0;
break;
}
}
puts(flag == 1 ? "yes" : "no");
}
实战：字符串匹配KMP算法
现在有两个字符串：
str1 = "abcdabbc"
str2 = "cda"
现在请你设计一个C语言程序，判断第一个字符串中是否包含了第二个字符串，比如上面的例子中，很明显第一个字符串包含了第二个字符串。
- 暴力解法（挨个匹配）
#include <stdio.h>
#include <string.h>
int main() {
char str1[64], str2[42];
gets(str1);
gets(str2);
unsigned long len1 = strlen(str1), len2 = strlen(str2);
_Bool flag = 0;
for (int i = 0; i < len1; ++i) {
flag = 0;
for (int j = 0; j < len2; ++j) {
if (str1[i + j] != str2[j]) {
flag = 1;
break;
}
}
if (!flag)break;
}
puts(flag ? "no" : "yes");
}
- KMP算法（跳跃匹配过的）
#include <stdio.h>
#include <string.h>
int main() {
char str1[] = "abababcabb";
char str2[] = "abab";
int len1 = strlen(str1), len2 = strlen(str2);
int next[len2];
next[0] = 0;
for (int i = 1; i < len2; ++i) {
int j = i - 1;
while (1) {
if (next[j] == 0 || str2[i - 1] == str2[next[j] - 1]) {
next[i] = next[j] + 1;
break;
}
j = next[j] - 1;
}
}
for (int i = 0; i < len2; ++i) {
printf("%d ", next[i]);
}
int i = 0, j = 0;
while (i < len1) {
if (str1[i] == str2[j]) {
i++;
j++;
} else {
if (j == 0) {
i++;
} else {
j = next[j] - 1;
}
}
if (j == len2)break;
}
printf(j == len2 ? "yes" : "or");
}
辅助链接：
本文来自博客园，作者：李好秀，转载请注明原文链接：https://www.cnblogs.com/lehoso/p/16994674.html
