C语言文章更新目录
C/C++学习资源（百度云盘链接）

计算机二级资料（过级专用）

C语言学习路线（从入门到实战）

编写C语言程序的7个步骤和编程机制

C语言基础-第一个C程序

C语言基础-简单程序分析

VS2019编写简单的C程序示例

简单示例，VS2019调试C语言程序

C语言基础-基本算法

C语言基础-数据类型

C语言中的输入输出函数

C语言流程控制语句

C语言数组——一维数组

C语言数组——二维数组

C语言数组——字符数组

C语言中常用的6个字符串处理函数

精心收集了60个C语言项目源码，分享给大家

C语言核心技术——函数

C代码是怎样跑起来的？

C语言实现字符串的加密和解密

C语言——文件的基本操作

使用C语言链表创建学生信息并且将信息打印输出

图解C语言冒泡排序算法，含代码分析

实例分析C语言中strlen和sizeof的区别

C语言实例：将人员信息写入磁盘文件并读出显示
环境安装配置
首先我们要在Visual Studio官方网站去下载安装包
https://visualstudio.microsoft.com/zh-hans/vs/
进入官网后会发现有三种版本可供下载，分别是社区版、专业版和企业版，冲哥这里选择的是专业版。


下载完成后，我们双击下载的软件开始安装


在弹出的画面点击继续


等待完成然后我们开始配置开发环境


如果没有别的需求这里我们就只选择：使用C++的桌面开发
如果不想用默认的安装路径（默认是安装在C盘的），可以点击更改来指定安装路径


选择好安装路径后，在右下角安装按钮的左边选择下载时安装（默认就是，这样可以节省安装时间），然后点击安装


等待安装完后，点击以后再说，也可以注册一个账号登录。


开发设置选择Visual C++


根据个人喜欢选择主题，冲哥酷爱深色😍，然后点击启动。

启动后的画面如下：

点击创建新项目


选在空项目，然后点击下一步

填写项目名称，和项目存放的位置，然后点击右下角的创建

下面就是我们编写代码的画面

在源文件上右击添加–>新建项，也可以直接使用快捷键ctrl+shift+A

选择C++文件

填写程序名称并将后缀名改为.c，然后点击添加

接下来就可以写代码了，冲哥这里写了一个变成界都在用的HelloWorld,如果觉得字体小的话，可以按住CTRL按键将鼠标滚轮向上滚，这样字体就变大了。

接下来运行刚刚写的代码，验证一下环境是否OK，点击调试–>开始执行（不调试）或者直接快捷键CTRL+F5

运行结果如下：

至此，环境已经OK，接下来开始你的码农之路
代码调试


代码功能：
求从1加到10的和


代码：


#include<stdio.h>

#define N 10

int main() {
	int result = 0;
	for (size_t i = 1; i <= N; i++)
	{
		result += i;
	}

	printf("result=%d", result);

	return 0;
}


代码调试

添加断点，直接在第7行前面鼠标左击一下

点击调试–>开始调试，或者使用快捷键F5

代码执行到断点处会停下，我们可以将鼠标放在某个变量上查看变量的值，也可以在下方的窗口查看所有变量的值。

调试时可以点击窗口中的按钮，也可以使用快捷键

代码中可以添加多个断点，使用快捷键F5可以直接跳到下一个断点处。

关于环境配置和代码调试就到这了，希望对你有所帮助。

如果您觉得本篇文章对您有帮助，请转发给更多的人

更多干货内容请查看我的个人公众号：C语言中文社区。

【C语言中文社区】是一个C语言/C++视频教程、学习笔记、电子书、计算机二级资料等专注于C语言/C++编程学习者的干货知识分享平台，精选深度文章，分享优秀干货类、技能类的学习资源，帮助学习中的你。

在windows7 系统上面安装Oracle数据库，安装过程中出现此错误
环境变量path的值超过1023字符。无法设置该值。




百度了下，说是将path环境变量里面的一些无用的变量删除掉。
将自己电脑里面的path变量贴出来，发现长度达1225字符。

C:\Program Files (x86)\PC Connectivity Solution\;C:\Program Files (x86)\Intel\iCLS Client\;C:\Program Files\Intel\iCLS Client\;
%SYSTEMROOT%\SYSTEM32;%SYSTEMROOT%;%SYSTEMROOT%\SYSTEM32\WBEM;%SYSTEMROOT%\SYSTEM32\WINDOWSPOWERSHELL\V1.0\;C:\PROGRAM FILES (X86)
\COMMON FILES\LENOVO;C:\PROGRAM FILES (X86)\COMMON FILES\THUNDER NETWORK\KANKAN\CODECS;%JAVA_HOME%\bin;C:\PROGRAM FILES (X86)\INTEL
\SERVICES\IPT\;C:\PROGRAM FILES\THINKPAD\BLUETOOTH SOFTWARE\;C:\PROGRAM FILES\THINKPAD\BLUETOOTH SOFTWARE\SYSWOW64;;C:\PROGRAM FILES 
(X86)\LENOVO\ACCESS CONNECTIONS\;C:\Program Files\Broadcom\WHL\;C:\Program Files\Broadcom\WHL\syswow64;C:\Program Files\Broadcom\WHL\
SysWow64\;C:\Program Files\Broadcom\WHL\SysWow64\syswow64;C:\Program Files\Intel\WiFi\bin\;C:\Program Files\Common Files\Intel\Wireless
Common\;C:\Program Files (x86)\Common Files\Thunder Network\KanKan\Codecs;C:\Program Files\Intel\Intel(R) Management Engine Components\
DAL;C:\Program Files\Intel\Intel(R) Management Engine Components\IPT;C:\Program Files (x86)\Intel\Intel(R) Management Engine Components\
DAL;C:\Program Files (x86)\Intel\Intel(R) Management Engine Components\IPT;D:\MySQL\MySQL Enterprise Backup 3.9.0\;D:\MySQL\
MySQL Utilities 1.3.6\;%MAVEN_HOME%\bin;

将里面的一些重复的环境变量，一些无用的环境变量删除后，长度为803字符。

C:\Program Files (x86)\PC Connectivity Solution\;C:\Program Files (x86)\Intel\iCLS Client\;C:\Program Files\Intel\iCLS Client\;
%SYSTEMROOT%\SYSTEM32;%SYSTEMROOT%;%SYSTEMROOT%\SYSTEM32\WBEM;%SYSTEMROOT%\SYSTEM32\WINDOWSPOWERSHELL\V1.0\;C:\PROGRAM FILES (X86)
\COMMON FILES\LENOVO;%JAVA_HOME%\bin;C:\PROGRAM FILES (X86)\INTEL\SERVICES\IPT\;;C:\PROGRAM FILES (X86)\LENOVO\ACCESS CONNECTIONS\;
C:\Program Files\Broadcom\WHL\;C:\Program Files\Broadcom\WHL\syswow64;C:\Program Files\Broadcom\WHL\SysWow64\;C:\Program Files\Intel
\WiFi\bin\;C:\Program Files\Common Files\Intel\WirelessCommon\;C:\Program Files\Intel\Intel(R) Management Engine Components\DAL;
C:\Program Files\Intel\Intel(R) Management Engine Components\IPT;D:\MySQL\MySQL Enterprise Backup 3.9.0\;D:\MySQL\MySQL Utilities 1.3.6\;
%MAVEN_HOME%\bin;

再次安装时，顺利安装过去。


为何会出现那么多的无用的环境变量呢？


一些软件在安装时都会将自己的启动软件添加在path中，但软件卸载时可能不会及时将path中的路径删除掉；
还有一类软件可能在电脑上重复的安装，这样就会有重复的环境变量在path中，这样就会有无用的环境变量的产生。


这些无用的环境变量都占用了path环境变量的字符，但是却毫无用处，删除就可以了。

已经有大约半年的时间没有碰C语言了，当时学习的时候记录了很多的笔记，但是都是特别混乱，后悔那个时候，不懂得写博客，这里凭借记忆和零零散散的笔记记录，尝试系统性地复习一下C语言。


之前都是在Windows环境下学习，这次把重心放在Linux环境下，这次的复习源于基础，但是要高于基础。

文章目录
工具
gcc编译器
VS2019
C语言编译过程
C语言代码主体
必要内容
C语言数据类型
关键字
常量
变量
进制表示
sizeof 关键字
整型：int
short、int、long、long long
有符号数和无符号数
字符型：char
实型(浮点型)：float、double
类型限定符
字符串常量
C语言常见函数
system函数
printf函数和putchar函数
scanf函数与getchar函数
随机数相关
字符串处理函数
C语言运算符与表达式
类型转换
C语言的数组和字符串
数组相关
字符数组与字符串
C语言函数部分
C语言的多文件编程
C语言的指针
C语言的内存管理
C语言的复合类型（自定义类型）
C语言的文件

工具
Linux环境下一般都是通过gcc来编译C代码的。
gcc编译器
gcc（GNU Compiler Collection，GNU 编译器套件），是由 GNU 开发的编程语言编译器。gcc原本作为GNU操作系统的官方编译器，现已被大多数类Unix操作系统（如Linux、BSD、Mac OS X等）采纳为标准的编译器，gcc同样适用于微软的Windows。
gcc最初用于编译C语言，随着项目的发展gcc已经成为了能够编译C、C++、Java、Ada、fortran、Object C、Object C++、Go语言的编译器大家族。
编译命令格式：
gcc [-option1] ... <filename>
g++ [-option1] ... <filename>


命令、选项和源文件之间使用空格分隔
一行命令中可以有零个、一个或多个选项
文件名可以包含文件的绝对路径，也可以使用相对路径
如果命令中不包含输出可执行文件的文件名，可执行文件的文件名会自动生成一个默认名，Linux平台为a.out，Windows平台为a.exe

gcc、g++编译常用选项说明：




选项
含义




-o file
指定生成的输出文件名为file


-E
只进行预处理


-S(大写)
只进行预处理和编译


-c(小写)
只进行预处理、编译和汇编


C语言是不跨平台的，用Java用习惯的我突然回到C，有点不适应，用SpringBoot完成的Java项目，打成jar包，只要安装了Java的环境，哪个地方都能跑。
对于C来说Linux编译后的可执行程序只能在Linux运行，Windows编译后的程序只能在Windows下运行。64位的Linux编译后的程序只能在64位Linux下运行，32位Linux编译后的程序只能在32位的Linux运行。
VS2019
这个是Windows环境下的工具。

用的是社区版，只装了C++的功能，快捷键用起来比较舒服，反编译还方便，学习了Java才知道有语法糖这个东西（Java的编译器帮我们做了很多的东西），这次重拾C/C++的时候，一定要摸清楚它们的编译器编译的时候做了哪些我们看不到，但是对我们来说很重要的事情
大二上学了一点汇编基础，要是有能力的话，后面看汇编也未尝不可。
C语言编译过程
C程序编译步骤

C代码编译成可执行程序经过4步：

1）预处理：宏定义展开、头文件展开、条件编译等，同时将代码中的注释删除，这里并不会检查语法

2）编译：检查语法，将预处理后文件编译生成汇编文件

3）汇编：将汇编文件生成目标文件(二进制文件)

4）链接：C语言写的程序是需要依赖各种库的，所以编译之后还需要把库链接到最终的可执行程序中去



这里用gcc展示一下编译过程
vim hello.c



分步编译
预处理：gcc -E hello.c -o hello.i
编  译：gcc -S hello.i -o hello.s
汇  编：gcc -c hello.s -o hello.o
链  接：gcc    hello.o -o hello_elf



执行：



可以查看一下程序所依赖的动态库



.so结尾的都是库
libc是c的代码库，linux-gnu是Linux的标准协议，libc.so.6满足这个标准

下面的那个是Linux的平台库




选项
含义




-E
只进行预处理


-S (大写)
只进行预处理和编译


-c (小写)
只进行预处理、编译和汇编


-o file
指定生成的输出文件名为file






文件后缀
含义




.c
C语言文件


.i
预处理后的C语言文件


.s
编译后的汇编文件


.o
编译后的目标文件


注意这里没有贴分步编译后的文件的内容，但是里面的内容很有价值一定要看一看。一定要联系前面C代码编译成可执行程序经过4步的文字描述
一步编译的情况也演示一下吧：



关于执行：

我们的程序文件存在于外存储器，要读到内存中进行执行，这个时候就涉及缓存和寄存器，CPU相关的东西了。计算机组成原理（或者说计算机系统）方面的知识就不多赘述，不然篇幅太长了。


C语言代码主体
必要内容
include头文件

#include< > 与 #include ""的区别：

< > 表示系统直接按系统指定的目录检索
“” 表示系统先在 “” 指定的路径(没写路径代表当前路径)查找头文件，如果找不到，再按系统指定的目录检索

main函数

一个完整的C语言程序，是由一个、且只能有一个main()函数(又称主函数，必须有)和若干个其他函数结合而成（可选）。
main函数是C语言程序的入口，程序是从main函数开始执行。

{} 括号，程序体和代码块

{}叫代码块，一个代码块内部可以有一条或者多条语句
C语言每句可执行代码都是";"分号结尾
所有的#开头的行，都代表预编译指令，预编译指令行结尾是没有分号的
所有的可执行语句必须是在代码块里面

注释

//叫行注释，注释的内容编译器是忽略的，注释主要的作用是在代码中加一些说明和解释，这样有利于代码的阅读
/* */叫块注释
块注释是C语言标准的注释方法
行注释是从C++语言借鉴过来的

return语句

return代表函数执行完毕，返回return代表函数的终止
如果main定义的时候前面是int，那么return后面就需要写一个整数；如果main定义的时候前面是void，那么return后面什么也不需要写
在main函数中return 0代表程序执行成功，return -1代表程序执行失败
int main()和void main()在C语言中是一样的，但C++只接受int main这种定义方式

C语言数据类型
关键字
C语言有32个关键字：

数据类型关键字




分类
名称
描述




基本数据类型 (5个)
void
声明函数无返回值或无参数，声明无类型指针，显式丢弃运算结果。


.
char



.
int
整型数据，通常为编译器指定的机器字长。


.
float
单精度浮点型数据，属于浮点数据的一种，小数点后保存6位。


.
double
双精度浮点型数据，属于浮点数据的一种，比float保存的精度高，小数点后保存15/16位。


类型修饰关键字（4个）
short
修饰int，短整型数据，可省略被修饰的int。


.
long
修饰int，长整形数据，可省略被修饰的int。


.
signed
修饰整型数据，有符号数据类型。


.
unsigned
修饰整型数据，无符号数据类型。


复杂类型关键字（5个）
struct
结构体声明


.
union
共用体声明


.
enum
枚举声明


.
typedef
声明类型别名


.
sizeof
得到特定类型或特定类型变量的大小。


存储级别关键字（6个）
auto
指定为自动变量，由编译器自动分配及释放。通常在栈上分配。


.
static
指定为静态变量，分配在静态变量区，修饰函数时，指定函数作用域为文件内部。


.
register
指定为寄存器变量，建议编译器将变量存储到寄存器中使用，也可以修饰函数形参，建议编译器通过寄存器而不是堆栈传递参数。


.
extern
指定对应变量为外部变量，即在另外的目标文件中定义，可以认为是约定由另外文件声明的。


.
const
与volatile合称“cv特性”，指定变量不可被当前线程/进程改变（但有可能被系统或其他线程/进程改变）


.
volatile
与const合称“cv特性”，指定变量的值有可能会被系统或其他进程/线程改变，强制编译器每次从内存中取得该变量的值


跳转结构（4个）
return
用在函数体中，返回特定值（或者是void值，即不返回值）


.
continue
结束当前循环，开始下一轮循环


.
break
跳出当前循环或switch结构


.
goto
无条件跳转语句。


分支结构（5个）
if
条件语句


.
else
条件语句否定分支（与if连用）


.
switch
开关语句（多重分支语句）


.
case
开关语句中的分支标记


.
default



循环结构（3个）for
for循环结构



.
do
do循环结构


.
while



数据类型的作用：编译器预算对象（变量）分配的内存空间大小。


常量
常量：

在程序运行过程中，其值不能被改变的量
常量一般出现在表达式或赋值语句中

整型常量	100，200，-100，0

实型常量	3.14 ， 0.125，-3.123

字符型常量	‘a’,‘b’,‘1’,‘\n’

字符串常量	“a”,“ab”，“12356”
变量
变量：

在程序运行过程中，其值可以改变
变量在使用前必须先定义，定义变量前必须有相应的数据类型

标识符命名规则：

标识符不能是关键字
标识符只能由字母、数字、下划线组成
第一个字符必须为字母或下划线
标识符中字母区分大小写

变量特点：

变量在编译时为其分配相应的内存空间
可以通过其名字和地址访问相应内存


声明和定义区别

声明变量不需要建立存储空间，如：extern int a;
定义变量需要建立存储空间，如：int b;

#include <stdio.h>
int main()
{
	//extern 关键字只做声明，不能做任何定义
	//声明一个变量a，a在这里没有建立存储空间
	extern int a;
	a = 10;	//err, 没有空间，就不可以赋值
	int b = 10;	//定义一个变量b，b的类型为int，b赋值为10
	return 0;
}

从广义的角度来讲声明中包含着定义，即定义是声明的一个特例，所以并非所有的声明都是定义：

int b 它既是声明，同时又是定义
对于 extern b来讲它只是声明不是定义

一般的情况下，把建立存储空间的声明称之为“定义”，而把不需要建立存储空间的声明称之为“声明”。
进制表示
C语言表示相应进制数：




进制
描述




十进制
以正常数字1-9开头，如123


八进制
以数字0开头，如0123


十六进制
以0x开头，如0x123


二进制
C语言不能直接书写二进制数


sizeof 关键字
sizeof不是函数，所以不需要包含任何头文件，它的功能是计算一个数据类型的大小，单位为字节
sizeof的返回值为size_t
size_t类型在32位操作系统下是unsigned int，是一个无符号的整数
int main()
{
	int a;
	int b = sizeof(a);//sizeof得到指定值占用内存的大小，单位：字节
	printf("b = %d\n", b);

	size_t c = sizeof(a);
	printf("c = %u\n", c);//用无符号数的方式输出c的值

	return 0;
}

整型：int
整型变量的定义和输出




打印格式
含义




%d
输出一个有符号的10进制int类型


%o(字母o)
输出8进制的int类型


%x
输出16进制的int类型，字母以小写输出


%X
输出16进制的int类型，字母以大写写输出


%u
输出一个10进制的无符号数


整型变量的输入
#include <stdio.h>

int main()
{
	int a;
	printf("请输入a的值：");

	//不要加“\n”
	scanf("%d", &a);

	printf("a = %d\n", a); //打印a的值

	return 0;
}

short、int、long、long long




数据类型
占用空间




short(短整型)
2字节


int(整型)
4字节


long(长整形)
Windows为4字节，Linux为4字节(32位)，8字节(64位)


long long(长长整型)
8字节


注意：

需要注意的是，整型数据在内存中占的字节数与所选择的操作系统有关。虽然 C 语言标准中没有明确规定整型数据的长度，但 long 类型整数的长度不能短于 int 类型， short 类型整数的长度不能长于 int 类型。
当一个小的数据类型赋值给一个大的数据类型，不会出错，因为编译器会自动转化。但当一个大的类型赋值给一个小的数据类型，那么就可能丢失高位。






整型常量
所需类型




10
代表int类型


10l, 10L
代表long类型


10ll, 10LL
代表long long类型


10u, 10U
代表unsigned int类型


10ul, 10UL
代表unsigned long类型


10ull, 10ULL
代表unsigned long long类型






打印格式
含义




%hd
输出short类型


%d
输出int类型


%l
输出long类型


%ll
输出long long类型


%hu
输出unsigned short类型


%u
输出unsigned int类型


%lu
输出unsigned long类型


%llu
输出unsigned long long类型


有符号数和无符号数
有符号数

有符号数是最高位为符号位，0代表正数，1代表负数。
无符号数

无符号数最高位不是符号位，而就是数的一部分，无符号数不可能是负数。
当我们写程序要处理一个不可能出现负值的时候，一般用无符号数，这样可以增大数的表达最大值。
有符号和无符号整型取值范围




数据类型
占用空间
取值范围




short
2字节
-32768 到 32767


int
4字节
-2147483648 到 2147483647


long
4字节
-2147483648 到 2147483647


unsigned short
2字节
0 到 65535


unsigned int
4字节
0 到 4294967295


unsigned long
4字节
0 到 4294967295


字符型：char
字符型变量用于存储一个单一字符，在 C 语言中用 char 表示，其中每个字符变量都会占用 1 个字节。在给字符型变量赋值时，需要用一对英文半角格式的单引号(’ ')把字符括起来。
字符变量实际上并不是把该字符本身放到变量的内存单元中去，而是将该字符对应的 ASCII 编码放到变量的存储单元中。char的本质就是一个1字节大小的整型。
#include <stdio.h>

int main()
{
	char ch = 'a';
	printf("sizeof(ch) = %u\n", sizeof(ch));

	printf("ch[%%c] = %c\n", ch); //打印字符
	printf("ch[%%d] = %d\n", ch); //打印‘a’ ASCII的值

	char A = 'A';
	char a = 'a';
	printf("a = %d\n", a);		//97
	printf("A = %d\n", A);	//65

	printf("A = %c\n", 'a' - 32); //小写a转大写A
	printf("a = %c\n", 'A' + 32); //大写A转小写a

	ch = ' ';
	printf("空字符：%d\n", ch); //空字符ASCII的值为32
	printf("A = %c\n", 'a' - ' '); //小写a转大写A
	printf("a = %c\n", 'A' + ' '); //大写A转小写a

	return 0;
}

ASCII表


ASCII 码大致由以下两部分组成：

ASCII 非打印控制字符： ASCII 表上的数字 0-31 分配给了控制字符，用于控制像打印机等一些外围设备。
ASCII 打印字符：数字 32-126 分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。数字 127 代表 Del 命令。

转义字符




转义字符
含义
ASCII码值（十进制）




\a
警报
007


\b
退格(BS) ，将当前位置移到前一列
008


\f
换页(FF)，将当前位置移到下页开头
012


\n
换行(LF) ，将当前位置移到下一行开头
010


\r
回车(CR) ，将当前位置移到本行开头
013


\t
水平制表(HT) （跳到下一个TAB位置）
009


\v
垂直制表(VT)
011


\
代表一个反斜线字符""
092


’
代表一个单引号（撇号）字符
039


"
代表一个双引号字符
034


?
代表一个问号
063


\0
数字0
000


\ddd
8进制转义字符，d范围0~7
3位8进制


\xhh
16进制转义字符，h范围0~9，a~f，A~F
3位16进制


数值溢出

当超过一个数据类型能够存放最大的范围时，数值会溢出。
有符号位最高位溢出的区别：符号位溢出会导致数的正负发生改变，但最高位的溢出会导致最高位丢失。




数据类型
占用空间
取值范围




Char
1字节
-128到 127


unsigned char
1字节
0 到 255


#include <stdio.h>

int main()
{
	char ch;

	//符号位溢出会导致数的正负发生改变
	ch = 0x7f + 2; //127+2
	printf("%d\n", ch);
	//	0111 1111
	//+2后 1000 0001，这是负数补码，其原码为 1111 1111，结果为-127

	//最高位的溢出会导致最高位丢失
	unsigned char ch2;
	ch2 = 0xff+1; //255+1
	printf("%u\n", ch2);
	//	  1111 1111
	//+1后 10000 0000， char只有8位最高位的溢出，结果为0000 0000，十进制为0

	ch2 = 0xff + 2; //255+1
	printf("%u\n", ch2);
	//	  1111 1111
	//+1后 10000 0001， char只有8位最高位的溢出，结果为0000 0001，十进制为1

	return 0;
}

实型(浮点型)：float、double
实型变量也可以称为浮点型变量，浮点型变量是用来存储小数数值的。在C语言中， 浮点型变量分为两种： 单精度浮点数(float)、 双精度浮点数(double)， 但是double型变量所表示的浮点数比 float 型变量更精确。




数据类型
占用空间
有效数字范围




float
4字节
7位有效数字


double
8字节
15～16位有效数字


由于浮点型变量是由有限的存储单元组成的，因此只能提供有限的有效数字。在有效位以外的数字将被舍去，这样可能会产生一些误差。
不以f结尾的常量是double类型，以f结尾的常量(如3.14f)是float类型。

这点很重要哈，我都忘了。
类型限定符




限定符
含义




extern
声明一个变量，extern声明的变量没有建立存储空间。extern int a;


const
定义一个常量，常量的值不能修改。const int a = 10;


volatile
防止编译器优化代码


register
定义寄存器变量，提高效率。register是建议型的指令，而不是命令型的指令，如果CPU有空闲寄存器，那么register就生效，如果没有空闲寄存器，那么register无效。


字符串常量
字符串是内存中一段连续的char空间，以’\0’(数字0)结尾。
字符串常量是由双引号括起来的字符序列，如“china”、“C program”，“$12.5”等都是合法的字符串常量。
字符串常量与字符常量的不同：



每个字符串的结尾，编译器会自动的添加一个结束标志位’\0’，即 “a” 包含两个字符’a’和’\0’。
C语言常见函数
system函数
system函数的使用
#include <stdlib.h>
int system(const char *command);
功能：在已经运行的程序中执行另外一个外部程序
参数：外部可执行程序名字
返回值：
成功：不同系统返回值不一样
失败：通常是 - 1

演示：
#include <stdio.h>
#include <stdlib.h>

int main()
{
	//system("calc"); //windows平台
	system("ls"); //Linux平台, 需要头文件#include <stdlib.h>

	return 0;
}

system返回值不同系统结果不一样
C语言所有的库函数调用，只能保证语法是一致的，但不能保证执行结果是一致的，同样的库函数在不同的操作系统下执行结果可能是一样的，也可能是不一样的。
Linux的发展离不开POSIX标准，只要符合这个标准的函数，在不同的系统下执行的结果就可以一致。
Unix和linux很多库函数都是支持POSIX的，但Windows支持的比较差。

如果将Unix代码移植到Linux一般代价很小，如果把Windows代码移植到Unix或者Linux就比较麻烦。
printf函数和putchar函数
printf是输出一个字符串，putchar输出一个char。
printf格式字符：




打印格式
对应数据类型
含义




%d
int
接受整数值并将它表示为有符号的十进制整数


%hd
short int
短整数


%hu
unsigned short
无符号短整数


%o
unsigned int
无符号8进制整数


%u
unsigned int
无符号10进制整数


%x,%X
unsigned int
无符号16进制整数，x对应的是abcdef，X对应的是ABCDEF


%f
float
单精度浮点数


%lf
double
双精度浮点数


%e,%E
double
科学计数法表示的数，此处"e"的大小写代表在输出时用的"e"的大小写


%c
char	字符型。
可以把输入的数字按照ASCII码相应转换为对应的字符


%s
char *
字符串。输出字符串中的字符直至字符串中的空字符（字符串以’\0‘结尾，这个’\0’即空字符）


%p
void *
以16进制形式输出指针


%%
%
输出一个百分号


printf附加格式：




字符
含义




l(字母l)
附加在d,u,x,o前面，表示长整数


-
左对齐


m(代表一个整数)
数据最小宽度


0(数字0)
将输出的前面补上0直到占满指定列宽为止不可以搭配使用-


m.n(代表一个整数)
m指域宽，即对应的输出项在输出设备上所占的字符数。n指精度，用于说明输出的实型数的小数位数。对数值型的来说，未指定n时，隐含的精度为n=6位。


scanf函数与getchar函数
getchar是从标准输入设备读取一个char。
scanf通过%转义的方式可以得到用户通过标准输入设备输入的数据。


随机数相关
当调用函数时，需要关心5要素：

头文件：包含指定的头文件
函数名字：函数名字必须和头文件声明的名字一样
功能：需要知道此函数能干嘛后才调用
参数：参数类型要匹配
返回值：根据需要接收返回值

#include <time.h>
time_t time(time_t *t);
功能：获取当前系统时间
参数：常设置为NULL
返回值：当前系统时间, time_t 相当于long类型，单位为毫秒

#include <stdlib.h>
void srand(unsigned int seed);
功能：用来设置rand()产生随机数时的随机种子
参数：如果每次seed相等，rand()产生随机数相等
返回值：无

#include <stdlib.h>
int rand(void);
功能：返回一个随机数值
参数：无
返回值：随机数

这里贴一个demo
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int main()
{
	time_t tm = time(NULL);//得到系统时间
	srand((unsigned int)tm);//随机种子只需要设置一次即可

	int r = rand();
	printf("r = %d\n", r);

	return 0;
}

字符串处理函数
gets()
#include <stdio.h>
char *gets(char *s);
功能：从标准输入读入字符，并保存到s指定的内存空间，直到出现换行符或读到文件结尾为止。
参数：
	s：字符串首地址
返回值：
	成功：读入的字符串
	失败：NULL

gets(str)与scanf(“%s”,str)的区别：

gets(str)允许输入的字符串含有空格
scanf(“%s”,str)不允许含有空格

注意：由于scanf()和gets()无法知道字符串s大小，必须遇到换行符或读到文件结尾为止才接收输入，因此容易导致字符数组越界(缓冲区溢出)的情况。

fgets()
#include <stdio.h>
char *fgets(char *s, int size, FILE *stream);
功能：从stream指定的文件内读入字符，保存到s所指定的内存空间，直到出现换行字符、读到文件结尾或是已读了size - 1个字符为止，最后会自动加上字符 '\0' 作为字符串结束。
参数：
	s：字符串
	size：指定最大读取字符串的长度（size - 1）
	stream：文件指针，如果读键盘输入的字符串，固定写为stdin
返回值：
	成功：成功读取的字符串
	读到文件尾或出错： NULL

fgets()在读取一个用户通过键盘输入的字符串的时候，同时把用户输入的回车也做为字符串的一部分。通过scanf和gets输入一个字符串的时候，不包含结尾的“\n”，但通过fgets结尾多了“\n”。fgets()函数是安全的，不存在缓冲区溢出的问题。

puts()
#include <stdio.h>
int puts(const char *s);
功能：标准设备输出s字符串，在输出完成后自动输出一个'\n'。
参数：
	s：字符串首地址
返回值：
	成功：非负数
	失败：-1


fputs()
#include <stdio.h>
int fputs(const char * str, FILE * stream);
功能：将str所指定的字符串写入到stream指定的文件中， 字符串结束符 '\0'  不写入文件。 
参数：
	str：字符串
	stream：文件指针，如果把字符串输出到屏幕，固定写为stdout
返回值：
	成功：0
	失败：-1

fputs()是puts()的文件操作版本，但fputs()不会自动输出一个’\n’。

strlen()
#include <string.h>
size_t strlen(const char *s);
功能：计算指定指定字符串s的长度，不包含字符串结束符‘\0’
参数：
s：字符串首地址
返回值：字符串s的长度，size_t为unsigned int类型

strcpy()
#include <string.h>
char *strcpy(char *dest, const char *src);
功能：把src所指向的字符串复制到dest所指向的空间中，'\0'也会拷贝过去
参数：
	dest：目的字符串首地址
	src：源字符首地址
返回值：
	成功：返回dest字符串的首地址
	失败：NULL

注意：如果参数dest所指的内存空间不够大，可能会造成缓冲溢出的错误情况。

strncpy()
#include <string.h>
char *strncpy(char *dest, const char *src, size_t n);
功能：把src指向字符串的前n个字符复制到dest所指向的空间中，是否拷贝结束符看指定的长度是否包含'\0'。
参数：
	dest：目的字符串首地址
	src：源字符首地址
	n：指定需要拷贝字符串个数
返回值：
	成功：返回dest字符串的首地址
	失败：NULL


strcat()
#include <string.h>
char *strcat(char *dest, const char *src);
功能：将src字符串连接到dest的尾部，‘\0’也会追加过去
参数：
	dest：目的字符串首地址
	src：源字符首地址
返回值：
	成功：返回dest字符串的首地址
	失败：NULL


strncat()
#include <string.h>
char *strncat(char *dest, const char *src, size_t n);
功能：将src字符串前n个字符连接到dest的尾部，‘\0’也会追加过去
参数：
	dest：目的字符串首地址
	src：源字符首地址
	n：指定需要追加字符串个数
返回值：
	成功：返回dest字符串的首地址
	失败：NULL


strcmp()
#include <string.h>
int strcmp(const char *s1, const char *s2);
功能：比较 s1 和 s2 的大小，比较的是字符ASCII码大小。
参数：
	s1：字符串1首地址
	s2：字符串2首地址
返回值：
	相等：0
	大于：>0
	小于：<0


strncmp()
#include <string.h>
int strncmp(const char *s1, const char *s2, size_t n);
功能：比较 s1 和 s2 前n个字符的大小，比较的是字符ASCII码大小。
参数：
	s1：字符串1首地址
	s2：字符串2首地址
	n：指定比较字符串的数量
返回值：
	相等：0
	大于： > 0
	小于： < 0


sprintf()
#include <stdio.h>
int sprintf(char *_CRT_SECURE_NO_WARNINGS, const char *format, ...);
功能：根据参数format字符串来转换并格式化数据，然后将结果输出到str指定的空间中，直到出现字符串结束符 '\0'  为止。
参数：
	str：字符串首地址
	format：字符串格式，用法和printf()一样
返回值：
	成功：实际格式化的字符个数
	失败： - 1


sscanf()
#include <stdio.h>
int sscanf(const char *str, const char *format, ...);
功能：从str指定的字符串读取数据，并根据参数format字符串来转换并格式化数据。
参数：
	str：指定的字符串首地址
	format：字符串格式，用法和scanf()一样
返回值：
	成功：参数数目，成功转换的值的个数
	失败： - 1


strchr()
#include <string.h>
char *strchr(const char *s, int c);
功能：在字符串s中查找字母c出现的位置
参数：
	s：字符串首地址
	c：匹配字母(字符)
返回值：
	成功：返回第一次出现的c地址
	失败：NULL


strstr()
#include <string.h>
char *strstr(const char *haystack, const char *needle);
功能：在字符串haystack中查找字符串needle出现的位置
参数：
	haystack：源字符串首地址
	needle：匹配字符串首地址
返回值：
	成功：返回第一次出现的needle地址
	失败：NULL


strtok()
#include <string.h>
char *strtok(char *str, const char *delim);
功能：来将字符串分割成一个个片段。当strtok()在参数s的字符串中发现参数delim中包含的分割字符时, 则会将该字符改为\0 字符，当连续出现多个时只替换第一个为\0。
参数：
	str：指向欲分割的字符串
	delim：为分割字符串中包含的所有字符
返回值：
	成功：分割后字符串首地址
	失败：NULL

在第一次调用时：strtok()必需给予参数s字符串

往后的调用则将参数s设置成NULL，每次调用成功则返回指向被分割出片段的指针
char a[100] = "adc*fvcv*ebcy*hghbdfg*casdert";
	char *s = strtok(a, "*");//将"*"分割的子串取出
	while (s != NULL)
	{
		printf("%s\n", s);
		s = strtok(NULL, "*");
	}


atoi()
#include <stdlib.h>
int atoi(const char *nptr);
功能：atoi()会扫描nptr字符串，跳过前面的空格字符，直到遇到数字或正负号才开始做转换，而遇到非数字或字符串结束符('\0')才结束转换，并将结果返回返回值。
参数：
	nptr：待转换的字符串
返回值：成功转换后整数

类似的函数有：

atof()：把一个小数形式的字符串转化为一个浮点数。
atol()：将一个字符串转化为long类型

char str1[] = "-10";
	int num1 = atoi(str1);
	printf("num1 = %d\n", num1);

	char str2[] = "0.123";
	double num2 = atof(str2);
	printf("num2 = %lf\n", num2);

C语言运算符与表达式
常用运算符分类




运算符类型
作用




算术运算符
用于处理四则运算


赋值运算符
用于将表达式的值赋给变量


比较运算符
用于表达式的比较，并返回一个真值或假值


逻辑运算符
用于根据表达式的值返回真值或假值


位运算符
用于处理数据的位运算


sizeof运算符
用于求字节数长度


算术运算符与赋值运算符，比较运算符以及逻辑运算符详细信息略
运算符优先级








类型转换
数据有不同的类型，不同类型数据之间进行混合运算时必然涉及到类型的转换问题。
转换的方法有两种：

自动转换(隐式转换)：遵循一定的规则,由编译系统自动完成。
强制类型转换：把表达式的运算结果强制转换成所需的数据类型。

类型转换的原则：占用内存字节数少(值域小)的类型，向占用内存字节数多(值域大)的类型转换，以保证精度不降低。

C语言的数组和字符串
数组相关
数组就是在内存中连续的相同类型的变量空间。 同一个数组所有的成员都是相同的数据类型，同时所有的成员在内存中的地址是连续的。
数组属于构造数据类型：

一个数组可以分解为多个数组元素：这些数组元素可以是基本数据类型或构造类型。
int a[10];  
struct Stu boy[10];

按数组元素类型的不同，数组可分为：数值数组、字符数组、指针数组、结构数组等类别。
int a[10];
char s[10];
char *p[10];

通常情况下，数组元素下标的个数也称为维数，根据维数的不同，可将数组分为一维数组、二维数组、多维数组。
在定义数组的同时进行赋值，称为初始化。全局数组若不初始化，编译器将其初始化为零。局部数组若不初始化，内容为随机值。
数组名是一个地址的常量，代表数组中首元素的地址。
关于二维数组：

二维数组在概念上是二维的：其下标在两个方向上变化，对其访问一般需要两个下标。
在内存中并不存在二维数组，二维数组实际的硬件存储器是连续编址的，也就是说内存中只有一维数组，即放完一行之后顺次放入第二行，和一维数组存放方式是一样的。

字符数组与字符串
字符数组与字符串区别

C语言中没有字符串这种数据类型，可以通过char的数组来替代；
字符串一定是一个char的数组，但char的数组未必是字符串；
数字0(和字符‘\0’等价)结尾的char数组就是一个字符串，但如果char数组没有以数字0结尾，那么就不是一个字符串，只是普通字符数组，所以字符串是一种特殊的char的数组。

C语言函数部分
从函数定义的角度看，函数可分为系统函数和用户定义函数两种：

系统函数，即库函数：这是由编译系统提供的，用户不必自己定义这些函数，可以直接使用它们，如我们常用的打印函数printf()。
用户定义函数：用以解决用户的专门需要。

如果使用用户自己定义的函数，而该函数与调用它的函数（即主调函数）不在同一文件中，或者函数定义的位置在主调函数之后，则必须在调用此函数之前对被调用的函数作声明。
所谓函数声明，就是在函数尚在未定义的情况下，事先将该函数的有关信息通知编译系统，相当于告诉编译器，函数在后面定义，以便使编译能正常进行。
注意：一个函数只能被定义一次，但可以声明多次。
函数定义和声明的区别：

1）定义是指对函数功能的确立，包括指定函数名、函数类型、形参及其类型、函数体等，它是一个完整的、独立的函数单位。

2）声明的作用则是把函数的名字、函数类型以及形参的个数、类型和顺序(注意，不包括函数体)通知编译系统，以便在对包含函数调用的语句进行编译时，据此对其进行对照检查（例如函数名是否正确，实参与形参的类型和个数是否一致）。
C语言的多文件编程
分文件编程

把函数声明放在头文件xxx.h中，在主函数中包含相应头文件
在头文件对应的xxx.c中实现xxx.h声明的函数



防止头文件重复包含
当一个项目比较大时，往往都是分文件，这时候有可能不小心把同一个头文件 include 多次，或者头文件嵌套包含。
为了避免同一个文件被include多次，C/C++中有两种方式，一种是 #ifndef 方式，一种是 #pragma once 方式。
方法一：
#ifndef __SOMEFILE_H__
#define __SOMEFILE_H__

// 声明语句

#endif

方法二：
#pragma once

// 声明语句

C语言的指针
【C/C++】C语言的指针
C语言的内存管理
【C/C++】内存管理
C语言的复合类型（自定义类型）
【C/C++】复合类型(自定义类型)
C语言的文件
【C/C++】文件操作

文章目录
前言
搭建环境
安装 MinGW-W64
选择编辑器
安装编辑器和插件
配置调试环境
编译代码
欢迎关注我的公众号：编程之路从0到1

本专栏已发布配套视频内容，请查看公众号视频专辑《程序员的C》
前言
大多数人在Windows上使用Visual Studio IDE作为C语言学习环境，实际上我认为这是非常错误的做法。每个人都有各自的理由，比如学校是这么教的，要保持和课堂同步，又比如要做毕设等等，还有貌似合理的更高级说法，比如有人喜欢说工具是其次的，只要学好了C语言语法就行，其他任何环境也能快速上手。对不起，如果是针对一门跨平台的高级语言，这个说法成立，但是对于C语言，不成立。使用IDE会最大程度的弱化你对C语言整体的理解程度。
在这里，我提出几个比较通用C语言学习观点

1、C语言语法简单，真正学会C语言的关键不在于语法。

2、C语言不适合零基础学习，应当具备其他高级编程语言的基础再来学习才能事半功倍，有所体悟。

3、在Windows操作系统上是学不好C语言的。从C语言历史上看，C语言原本就是被发明在Unix操作系统上的，回到它真正的语境下才更有助于深刻理解。
最后，本教程针对的是已有其他编程基础的朋友，这也符合以上观点的第二条，因此不适合零基础学习。
搭建环境
基于以上观点，我们不应该选择Windows和IDE作为学习C语言的环境，最好使用Linux系统来学习，推荐Ubuntu操作系统。当然，使用Linux系统本身也需要学习很多知识，不适合小白用户，而且纠结于Linux命令的用法，也脱离了学习C语言的初衷，无端增加了学习障碍，得不偿失。
因此，我们采用一种折中的更灵活的方案，在Windows上使用GCC编译器以及一些GNU工具链来模拟Linux 下的C语言学习体验，这样一来，我们既能使用熟悉的Windows系统，也能利用GNU工具链来学习C语言，熟悉了GNU工具链，就相当于掌握了Linux C的开发环境。
安装 MinGW-W64
下载一个64位Windows版本的GCC——MinGW-W64

下载地址


如上，它有两个版本，sjlj和seh后缀表示异常处理模式，seh 性能较好，但不支持 32位。 sjlj 稳定性好，可支持 32位，推荐下载seh 版本
将编译器安装到自己准备好的目录，完成安装后，还需要配置一下环境变量，将安装目录下的bin目录加入到系统Path环境变量中，bin目录下包含gcc.exe、make.exe等工具链，这些也就是GNU工具链。（相信有过编程经验的人，大都知道环境变量怎么配置，如不知道，请直接去Google搜索 Windows系统如何配置环境变量）
检查环境

配置完成后，检测一下环境是否搭建成功，打开cmd命令行，输入gcc -v、make -v能查看版本号则成功。
选择编辑器
能同时满足简单好用、界面美观、功能强大、轻量级等特点的编辑器并不多，这里推荐最目前最流行人气最高的VS Code编辑器。
安装编辑器和插件
首先下载VSCode编辑器 ，然后安装插件并配置调试环境。官方下载地址
注意，这里是VSCode编辑器，不是Visual Studio IDE，这完全是两个不同的东西，虽然都是微软出品。
有了编辑器，但我们还需要安装一个C/C++插件，它能进行一些代码智能提示、语法检查之类的辅助功能。我们打开编辑器，在插件商店中搜索C/C++插件，点击Install进行安装，安装完成后，可能需要重启编辑器。


配置调试环境
实际上不配置调试环境一点也不影响我们写代码，但是在学习C语言的过程中，借助调试功能可以帮助我们形象的理解很多概念，而且调试功能对于我们查找BUG等问题非常有帮助。
如何配置调试环境呢？实际上VS Code编辑器并不具备任何调试功能，调试功能是GNU工具链提供的，它在我们之前安装MinGW-W64的那个bin文件夹里面，它的名字叫gdb.exe，如果大家之前的环境配置Ok，那么可以在cmd命令行输入gdb -v查看调试器的版本。这其实就是告诉大家，即使你不配置VS Code，也可以直接在命令行输入gdb命令来调试代码，但是这样会显得繁琐和不友好，配置一下VS Code就能通过图形界面的方式来调试程序，体验瞬间提升。
这里给出一个官方提供的配置调试环境的完整指导教程，如果英语好，有耐性还是建议好好看看 官方配置指南
具体步骤如下


创建一个存放代码的文件夹，例如c_code，然后新建一个文本文档，改名为test.c文件


打开VS Code编辑器，在顶部菜单栏中选择【File】=> 【Open Folder】来打开刚刚创建的c_code文件夹


在编辑器左边的资源管理栏中选择test.c文件打开，并输入如下测试代码保存
#include<stdio.h>

int main(){
    int i,j,k;

    i = 10,
    j=8,
    k=2;
    printf("result is %d",i+j+k);
}



按【F5】键调试，这时会弹出一个对话框，选择打开编辑

launch.json配置文件，有时候可能会直接跳出launch.json的配置文件，根据实际情况修改默认配置即可
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "(gdb) Launch",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceRoot}/${fileBasenameNoExtension}.exe",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": true,
            "MIMode": "gdb",
            "miDebuggerPath": "G:\\developer\\mingw64\\MinGW\\bin\\gdb.exe",
            "preLaunchTask": "build c project",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ]
        }
    ]
}

有一个地方需要特别说明，请将如上配置文件中的"miDebuggerPath"值配置成你自己电脑上的gdb.exe路径，其他的直接参照我这份配置即可。


配置调试前的编译任务。我们要想调试代码，首先需要将代码加特定参数编译成可执行程序，这一步就是配置编译任务的。在编辑器中，使用组合快捷键【Ctrl】+【Shift】+【p】打开命令面板，输入Tasks:进行联想，选择如下的Default Build Task



选择如下项，创建一个tasks.json配置文件



选择Others模板


	{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "build c project",
            "type": "shell",
            "command": "gcc",
            "args": [
                "-g",
                "${file}",
                "-o",
                "${fileBasenameNoExtension}.exe"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            }
        }
    ]
}

大家直接参照我这里的配置文件配置即可，有一点说明一下，"label": "build c project"这里是给这个任务起了一个名字，这个名字叫什么不重要，但是它直接对应的是launch.json中的"preLaunchTask": "build c project"这一行，因此两边名字一定要一致，如果你改了这个label名的话。


检测调试环境。给代码加一个断点，例如鼠标单击第6行的行号之前区域



如图，这里就给第6行代码打了一个断点，编辑器里面会呈现出一个红色小点，启动调试时，程序就会在第6行卡住。我们直接按【F5】键开启调试，会发现代码卡在了第6行，该行会变色，观察断点处也有变化



此时代码已处于调试状态，将鼠标移动到断点那行之前的变量上，即可查看此刻变量的值是多少，这就是所谓的调试。要记住，只能查看断点之前的变量，因为断点之后的代码还没有被执行。



如上图，不仅可以用鼠标查看，编辑器左侧面板也会显示出当前已经执行过的代码中的变量情况。此时，如想继续往下一执行，直接按一次【F10】代码就会往下再运行一行。



除了快捷键，也可以使用鼠标点击悬浮菜单中红框的键，它对应【F10】，其他控制键，大家自行探究。


编译代码
如果想直接运行写好的代码，可以使用鼠标右键菜单运行



编辑器会弹出底部面板，显示输出的结果，同时，在当前代码目录下还会生成一个同名可执行文件，本例则生成了test.exe
欢迎关注我的公众号：编程之路从0到1
本专栏已发布配套视频内容，请参看公众号视频专辑《程序员的C》