C语言光速入门笔记

C语言是一门面向过程的编译型语言，它的运行速度极快，仅次于汇编语言。C语言是计算机产业的核心语言，操作系统、硬件驱动、关键组件、数据库等都离不开C语言；不学习C语言，就不能了解计算机底层。

C语言介绍

C 语言是一种通用的、面向过程式的计算机程序设计语言。1972 年，为了移植与开发 UNIX 操作系统，丹尼斯·里奇在贝尔电话实验室设计开发了 C 语言。

当前最新的 C 语言标准为 C18 ，在它之前的 C 语言标准有 C17、C11…C99 等。

C语言出现的时候，已经度过了编程语言的拓荒年代，具备了现代编程语言的特性，但是这个时候还没有出现“软件危机”，人们没有动力去开发更加高级的语言，所以也没有太复杂的编程思想。

也就是说，C语言虽然是现代编程语言，但是它涉及到的概念少，词汇少，思想也简单。C语言学习成本小，初学者能够在短时间内掌握编程技能，非常适合入门。

C语言特性

1. 高效性

   C是一种高效的语言。 在设计上它充分利用了当前计算机在能力上的优点。C程序往往很紧凑且运行速度快。事实上，C可以表现出通常只有汇编语言才具有的精细控制能力（汇编语言是特定的CPU设计所采用的一组内部指令的助记符。不同的CPU类型使用不同的汇编语言）。如果愿意，你可以细调程序以获得最大速度或最大内存使用率。

2. 可移植性

   C是一种可移植语言。这意味着，在一个系统上编写的C程序经过很少改动或不经修改就可以其他系统上运行。如果修改是必要的，则通常只须改变伴随主程序的一个头文件中的几项内容即可。多数语言原本都想具有可移植性，但任何曾将IBM PC BASIC程序转换为Apple BASIC程序（它们还是近亲）的人，或者试图在UNIX系统上运行一个IBM大型机FORTRAN程序的人都知道，移植至少是在制造麻烦。C在可移植性方面处于领先地位。C编译器（将C代码转换为计算机内部使用的指令的程序）在大约40多种系统上可用，包括从使用8位微处理器的计算机到Cray超级计算机。不过要知道，程序中为访问特定硬件设备（例如显示器）或操作系统（如Windows XP或OS X）的特殊功能而专门编写的部分，通常是不能移植的。

   由于C与UNIX的紧密联系，UNIX系统通常都带有一个C编译器作为程序包的一部分。Linux中同样也包括一个C编译器。个人计算机，包括运行不同版本的Windows和Macintosh的PC，可使用若干种C编译器。所以不论你使用的是家用计算机，专业工作站还是大型机，都很容易得到针对你特定系统的C编译器。

3. 强大的功能和灵活性

   C强大而又灵活（计算机世界中经常使用的两个词）。例如，强大而灵活的UNIX操作系统的大部分便是用C编写的。其他语言（如FORTRAN，Perl，Python，Pascal，LISP，Logo和BASIC）的许多编译器和解释器也都用C编写的。结果是，当你在一台UNIX机器上使用FORTRAN时，最终是由一个C程序负责生成最后的可执行程序的。C程序已经用于解决物理学和工程学问题，甚至用来为《角斗士》这样的电影制造特殊效果。

4. 面向编程人员

   C面向编程人员的需要。它允许你访问硬件，并可以操纵内存中的特定位。它具有丰富的运算符供选择，让你能够简洁地表达自己的意图。在限制你所能做的事情方面，C不如Pascal这样的语言严格。这种灵活性是优点，同时也是一种危险。优点在于：许多任务（如转换数据形式）在C中都简单得多。危险在于：使用C时，你可能会犯在使用其他一些语言时不可能犯的错误。C给予你更多的自由，但同时也让你承担更大的风险。

上面这些特点，使得 C 语言可以写出性能非常强、完全发挥硬件潜力的程序，而且 C 语言的编译器实现难度相对较低。但是另一方面，C 语言代码容易出错，一般程序员不容易写好。

此外，当代很多流行语言都是以 C 语言为基础，比如 C++、Java、C#、JavaScript 等等。学好 C 语言有助于对这些语言加深理解。

C编译器

首先是如雷贯耳的这几位仁兄，MSVC、GCC、Cygwin、MingW（Cygwin和MingW的英文发音），另外还有些小众和新秀，像ICC（Intel C/C++ Compiler）、BCC（Borland C/C++ Compiler，快销声匿迹了）、RVCT（ARM的汇编/C/C++编译器，内置在ARM的IDE——RVDS中）、Pgi编译器……其实有一大串，我们只要熟悉常用的最强大的几款就可以了。

GCC (GNU Compiler Collection):

特点：

• 开源性： GCC 是自由和开源软件，遵循GNU通用公共许可证（GPL）。
• 跨平台支持： 支持多种平台，包括Linux、Unix、Windows等，可以生成针对不同体系结构的代码。
• 多语言支持： GCC 不仅支持C语言，还支持C++、Fortran、Ada等多种编程语言。
• 丰富的优化选项： 提供广泛的编译器优化选项，可以通过这些选项优化生成的机器代码。
• 广泛应用： 在许多开发环境和项目中被广泛使用，是许多Unix-like系统的默认编译器。

Clang:

特点：

• LLVM基础： Clang 是基于LLVM项目的编译器。LLVM的设计使得Clang可以提供高性能的编译，并且具有灵活的架构。
• 模块化设计： Clang 的设计注重模块化，这使得它更容易嵌入到其他工具和开发环境中。
• 高质量的诊断信息： Clang 提供详细和易读的错误和警告信息，帮助开发者更容易调试和优化代码。
• 兼容性： 与GCC相比，Clang对C++标准的支持更加先进，并在C++11、C++14、C++17等方面表现优秀。

MSVC (Microsoft Visual C++ Compiler):

特点：

• Windows集成： MSVC 是Microsoft Visual Studio集成开发环境的一部分，主要用于Windows平台的应用程序开发。
• Windows API集成： 提供了对Windows API的良好支持，使得Windows平台上的开发更加便捷。
• 调试工具： 集成了强大的调试工具，如Visual Studio Debugger，提供了丰富的调试功能。
• 性能工具： Visual Studio 提供了性能分析工具，帮助开发者优化和调试程序性能。

对比

1. 开源性：

   • GCC 是自由和开源的，用户可以查看和修改其源代码。
   • Clang 也是开源的，基于LLVM项目，允许用户访问和修改源代码。
   • MSVC 是闭源的，用户不能直接访问其源代码。

2. 跨平台支持：

   • GCC 在多个平台上有广泛支持。
   • Clang 也是跨平台的，但在某些平台上可能需要额外的工作。
   • MSVC 主要用于Windows平台。

3. 语言支持：

   • GCC 支持多种编程语言。
   • Clang 支持C、C++等，对C++标准支持较好。
   • MSVC 主要支持C和C++。

4. 性能和优化：

   • GCC 和 Clang 在性能和优化方面具有竞争力，具体表现可能取决于编译器版本和优化选项。
   • MSVC 也提供了一些优化选项，但在某些情况下可能与GCC和Clang有所不同。

5. 集成开发环境：

   • GCC 和 Clang 通常与各种集成开发环境搭配使用。
   • MSVC 集成于Microsoft Visual Studio，提供了全面的开发工具和环境。

在跨平台开发时，GCC 和 Clang 是常见选择，而在Windows平台上，MSVC 是首选。

MinGw一般使用Gcc作为C编译器，可以通过在cmd执行gcc命令来验证：

gcc your_source_code.c -o your_executable.exe

为什么要使用 C？

C 语言最初是用于系统开发工作，特别是组成操作系统的程序。由于 C 语言所产生的代码运行速度与汇编语言编写的代码运行速度几乎一样，所以采用 C 语言作为系统开发语言。下面列举几个使用 C 的实例：

• 操作系统
• 语言编译器
• 汇编器
• 文本编辑器
• 打印机
• 网络驱动器
• 现代程序
• 数据库
• 语言解释器
• 实体工具

C语言的版本

历史上，C 语言有过多个版本。

（1）K＆R C

K&R C指的是 C 语言的原始版本。1978年，C 语言的发明者丹尼斯·里奇（Dennis Ritchie）和布莱恩·柯林汉（Brian Kernighan）合写了一本著名的教材《C 编程语言》（The C programming language）。由于 C 语言还没有成文的语法标准，这本书就成了公认标准，以两位作者的姓氏首字母作为版本简称“K&R C”。

（2）ANSI C（又称 C89 或 C90）

C 语言的原始版本非常简单，对很多情况的描述非常模糊，加上 C 语法依然在快速发展，要求将 C 语言标准化的呼声越来越高。

1989年，美国国家标准协会（ANSI）制定了一套 C 语言标准。1990年，国际标准化组织（ISO）通过了这个标准。它被称为“ANSI C”，也可以按照发布年份，称为“C89 或 C90”。

（3）C95

1995年，美国国家标准协会对1989年的那个标准，进行了补充，加入多字节字符和宽字符的支持。这个版本称为 C95。

（4）C99

C 语言标准的第一次大型修订，发生在1999年，增加了许多语言特性，比如双斜杠（//）的注释语法。这个版本称为 C99，是目前最流行的 C 版本。

（5）C11

2011年，标准化组织再一次对 C 语言进行修订，增加了 Unicode 和多线程的支持。这个版本称为 C11。

（6）C17

C11 标准在2017年进行了修补，但发布是在2018年。新版本只是解决了 C11 的一些缺陷，没有引入任何新功能。这个版本称为 C17。

（7）C2x

标准化组织正在讨论 C 语言的下一个版本，据说可能会在2023年通过，到时就会称为 C23。

C11

C11（也被称为C1X）指ISO标准ISO/IEC 9899:2011。在它之前的C语言标准为C99。

新特性：

• 对齐处理（Alignment）的标准化（包括_Alignas标志符，alignof运算符，aligned_alloc函数以及<stdalign.h>头文件）。
• _Noreturn 函数标记，类似于 gcc 的 attribute((noreturn))。
• _Generic 关键字。
• 多线程（Multithreading）支持，包括：
  • _Thread_local存储类型标识符，<threads.h>头文件，里面包含了线程的创建和管理函数。
  • _Atomic类型修饰符和<stdatomic.h>头文件。
• 增强的Unicode的支持。基于C Unicode技术报告ISO/IEC TR 19769:2004，增强了对Unicode的支持。包括为UTF-16/UTF-32编码增加了char16_t和char32_t数据类型，提供了包含unicode字符串转换函数的头文件<uchar.h>。
• 删除了 gets() 函数，使用一个新的更安全的函数gets_s()替代。
• 增加了边界检查函数接口，定义了新的安全的函数，例如 fopen_s()，strcat_s() 等等。
• 增加了更多浮点处理宏(宏)。
• 匿名结构体/联合体支持。这个在gcc早已存在，C11将其引入标准。
• 静态断言（Static assertions），_Static_assert()，在解释 #if 和 #error 之后被处理。
• 新的 fopen() 模式，(“…x”)。类似 POSIX 中的 O_CREAT|O_EXCL，在文件锁中比较常用。
• 新增 quick_exit() 函数作为第三种终止程序的方式。当 exit() 失败时可以做最少的清理工作。

第一个C程序——hello world

#include <stdio.h>

int main(){
	/* 我的第一个 C 程序 */
	// 我的第一个C程序
    printf("hello world");
    return 0;
}

1. 所有的 C 语言程序都需要包含 main() 函数。 代码从 main() 函数开始执行。
2. /* ... */ 和//用于注释说明。（和go一样）
3. printf() 用于格式化输出到屏幕。printf() 函数在 “stdio.h” 头文件中声明。
4. stdio.h 是一个头文件 (标准输入输出头文件) , #include 是一个预处理命令，用来引入头文件。 当编译器遇到 printf() 函数时，如果没有找到 stdio.h 头文件，会发生编译错误。
5. return 0; 语句用于表示退出程序。

执行下面的命令。

$ gcc hello.c

上面命令使用gcc编译器，将源文件hello.c编译成二进制代码。

运行这个命令以后，默认会在当前目录下生成一个编译产物文件a.out（assembler output 的缩写，Windows 平台为a.exe）。执行该文件，就会在屏幕上输出Hello World。

$ ./a.out
Hello World

GCC 的-o参数（output 的缩写）可以指定编译产物的文件名。

$ gcc -o hello hello.c

上面命令的-o hello指定，编译产物的文件名为hello（取代默认的a.out）。编译后就会生成一个名叫hello的可执行文件，相当于为a.out指定了名称。执行该文件，也会得到同样的结果。

$ ./hello
Hello World

GCC 的-std=参数（standard 的缩写）还可以指定按照哪个 C 语言的标准进行编译。

$ gcc -std=c99 hello.c

上面命令指定按照 C99 标准进行编译。

注意，-std后面需要用=连接参数，而不是像上面的-o一样用空格，并且=前后也不能有多余的空格。

基本语法

分号

C 语言的代码由一行行语句（statement）组成。语句就是程序执行的一个操作命令。C 语言规定，语句必须使用分号结尾，除非有明确规定可以不写分号。

在 C 程序中，分号是语句结束符。也就是说，每个语句必须以分号结束。它表明一个逻辑实体的结束。

例如，下面是两个不同的语句：

printf("Hello, World! n");
return 0;

多个语句可以写在一行。

int x; x = 1;

上面示例是两个语句写在一行。所以，语句之间的换行符并不是必需的，只是为了方便阅读代码。

语句块

与Go语言一样，C 语言也允许多个语句使用一对大括号{}，组成一个块，也称为复合语句（compounded statement）。在语法上，语句块可以视为多个语句组成的一个复合语句。

{
  int x;
  x = 1;
}

上面示例中，大括号形成了一个语句块，大括号的结尾不需要添加分号。

但要注意的是，不管在哪个语言里，语句块算一个作用域，声明在里面的变量声明周期不会超出语句块。

标识符

C 标识符是用来标识变量、函数，或任何其他用户自定义项目的名称。一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）。

C 标识符内不允许出现标点字符，比如 @、$ 和 %。C 是区分大小写的编程语言。因此，在 C 中，Manpower 和 manpower 是两个不同的标识符。下面列出几个有效的标识符：

mohd       zara    abc   move_name  a_123
myname50   _temp   j     a23b9      retVal

关键字

下表列出了 C 中的保留字。这些保留字不能作为常量名、变量名或其他标识符名称。

C99 新增关键字

C11 新增关键字

C 中的空格

只包含空格的行，被称为空白行，可能带有注释，C 编译器会完全忽略它。

在 C 中，空格用于描述空白符、制表符、换行符和注释。空格分隔语句的各个部分，让编译器能识别语句中的某个元素（比如 int）在哪里结束，下一个元素在哪里开始。因此，在下面的语句中：

int age;

在这里，int 和 age 之间必须至少有一个空格字符（通常是一个空白符），这样编译器才能够区分它们。另一方面，在下面的语句中：

fruit = apples + oranges;   // 获取水果的总数

fruit 和 =，或者 = 和 apples 之间的空格字符不是必需的，但是为了增强可读性，您可以根据需要适当增加一些空格。

占位符

printf()的占位符有许多种类，与 C 语言的数据类型相对应。下面按照字母顺序，列出常用的占位符，方便查找。

%a：十六进制浮点数，字母输出为小写。
%A：十六进制浮点数，字母输出为大写。
%c：字符。
%d：十进制整数。
%e：使用科学计数法的浮点数，指数部分的e为小写。
%E：使用科学计数法的浮点数，指数部分的E为大写。
%i：整数，基本等同于%d。
%f：小数（包含float类型和double类型）。
%g：6个有效数字的浮点数。整数部分一旦超过6位，就会自动转为科学计数法，指数部分的e为小写。
%G：等同于%g，唯一的区别是指数部分的E为大写。
%hd：十进制 short int 类型。
%ho：八进制 short int 类型。
%hx：十六进制 short int 类型。
%hu：unsigned short int 类型。
%ld：十进制 long int 类型。
%lo：八进制 long int 类型。
%lx：十六进制 long int 类型。
%lu：unsigned long int 类型。
%lld：十进制 long long int 类型。
%llo：八进制 long long int 类型。
%llx：十六进制 long long int 类型。
%llu：unsigned long long int 类型。
%Le：科学计数法表示的 long double 类型浮点数。
%Lf：long double 类型浮点数。
%n：已输出的字符串数量。该占位符本身不输出，只将值存储在指定变量之中。
%o：八进制整数。
%p：指针。
%s：字符串。
%u：无符号整数（unsigned int）。
%x：十六进制整数。
%zd：size_t类型。
%%：输出一个百分号。

输出格式

printf()可以定制占位符的输出格式。

（1）限定宽度

printf()允许限定占位符的最小宽度。

printf("%5dn", 123); // 输出为 "  123"

上面示例中，%5d表示这个占位符的宽度至少为5位。如果不满5位，对应的值的前面会添加空格。

输出的值默认是右对齐，即输出内容前面会有空格；如果希望改成左对齐，在输出内容后面添加空格，可以在占位符的%的后面插入一个-号。

printf("%-5dn", 123); // 输出为 "123  "

上面示例中，输出内容123的后面添加了空格。

对于小数，这个限定符会限制所有数字的最小显示宽度。

// 输出 "  123.450000"
printf("%12fn", 123.45);

上面示例中，%12f表示输出的浮点数最少要占据12位。由于小数的默认显示精度是小数点后6位，所以123.45输出结果的头部会添加2个空格。

（2）总是显示正负号

默认情况下，printf()不对正数显示+号，只对负数显示-号。如果想让正数也输出+号，可以在占位符的%后面加一个+。

printf("%+dn", 12); // 输出 +12
printf("%+dn", -12); // 输出 -12

上面示例中，%+d可以确保输出的数值，总是带有正负号。

（3）限定小数位数

输出小数时，有时希望限定小数的位数。举例来说，希望小数点后面只保留两位，占位符可以写成%.2f。

// 输出 Number is 0.50
printf("Number is %.2fn", 0.5);

上面示例中，如果希望小数点后面输出3位（0.500），占位符就要写成%.3f。

这种写法可以与限定宽度占位符，结合使用。

// 输出为 "  0.50"
printf("%6.2fn", 0.5);

上面示例中，%6.2f表示输出字符串最小宽度为6，小数位数为2。所以，输出字符串的头部有两个空格。

最小宽度和小数位数这两个限定值，都可以用*代替，通过printf()的参数传入。

printf("%*.*fn", 6, 2, 0.5);

// 等同于
printf("%6.2fn", 0.5);

上面示例中，%*.*f的两个星号通过printf()的两个参数6和2传入。

（4）输出部分字符串

%s占位符用来输出字符串，默认是全部输出。如果只想输出开头的部分，可以用%.[m]s指定输出的长度，其中[m]代表一个数字，表示所要输出的长度。

// 输出 hello
printf("%.5sn", "hello world");

上面示例中，占位符%.5s表示只输出字符串“hello world”的前5个字符，即“hello”。

数据类型——基本数据类型

在 C 语言中，数据类型指的是用于声明不同类型的变量或函数的一个广泛的系统。变量的类型决定了变量存储占用的空间，以及如何解释存储的位模式。

C 中的类型可分为以下几种：

数组类型和结构类型统称为聚合类型。函数的类型指的是函数返回值的类型。

整数类型

下表列出了关于标准整数类型的存储大小和值范围的细节：

注意，各种类型的存储大小与系统位数有关，但目前通用的以64位系统为主。

以下列出了32位系统与64位系统的存储大小的差别（windows 相同）：

为了得到某个类型或某个变量在特定平台上的准确大小，可以使用 sizeof 运算符。表达式 sizeof(type) 得到对象或类型的存储字节大小。下面的实例演示了获取 int 类型的大小：

#include <stdio.h>
#include <limits.h>
 
int main()
{
   printf("int 存储大小 : %lu n", sizeof(int));
   
   return 0;
}

signed，unsigned

C 语言使用signed关键字，表示一个类型带有正负号，包含负值；使用unsigned关键字，表示该类型不带有正负号，只能表示零和正整数。

对于int类型，默认是带有正负号的，也就是说int等同于signed int。由于这是默认情况，关键字signed一般都省略不写，但是写了也不算错。

signed int a;
// 等同于
int a;

int类型也可以不带正负号，只表示非负整数。这时就必须使用关键字unsigned声明变量。

unsigned int a;

整数变量声明为unsigned的好处是，同样长度的内存能够表示的最大整数值，增大了一倍。比如，16位的signed int最大值为32,767，而unsigned int的最大值增大到了65,535。

unsigned int里面的int可以省略，所以上面的变量声明也可以写成下面这样。

unsigned a;

字符类型char也可以设置signed和unsigned。

signed char c; // 范围为 -128 到 127
unsigned char c; // 范围为 0 到 255

注意，C 语言规定char类型默认是否带有正负号，由当前系统决定。这就是说，char不等同于signed char，它有可能是signed char，也有可能是unsigned char。这一点与int不同，int就是等同于signed int。

整数类型的极限值

有时候需要查看，当前系统不同整数类型的最大值和最小值，C 语言的头文件limits.h提供了相应的常量，比如SCHAR_MIN代表 signed char 类型的最小值-128，SCHAR_MAX代表 signed char 类型的最大值127。

为了代码的可移植性，需要知道某种整数类型的极限值时，应该尽量使用这些常量。

• SCHAR_MIN， SCHAR_MAX：signed char 的最小值和最大值。
• SHRT_MIN， SHRT_MAX：short 的最小值和最大值。
• INT_MIN， INT_MAX：int 的最小值和最大值。
• LONG_MIN， LONG_MAX：long 的最小值和最大值。
• LLONG_MIN， LLONG_MAX：long long 的最小值和最大值。
• UCHAR_MAX：unsigned char 的最大值。
• USHRT_MAX：unsigned short 的最大值。
• UINT_MAX：unsigned int 的最大值。
• ULONG_MAX：unsigned long 的最大值。
• ULLONG_MAX：unsigned long long 的最大值。

整数的进制

C 语言的整数默认都是十进制数，如果要表示八进制数和十六进制数，必须使用专门的表示法。

八进制使用0作为前缀，比如017、0377。

int a = 012; // 八进制，相当于十进制的10

十六进制使用0x或0X作为前缀，比如0xf、0X10。

int a = 0x1A2B; // 十六进制，相当于十进制的6699

有些编译器使用0b前缀，表示二进制数，但不是标准。

int x = 0b101010;

注意，不同的进制只是整数的书写方法，不会对整数的实际存储方式产生影响。所有整数都是二进制形式存储，跟书写方式无关。不同进制可以混合使用，比如10 + 015 + 0x20是一个合法的表达式。

printf()的进制相关占位符如下。

• %d：十进制整数。
• %o：八进制整数。
• %x：十六进制整数。
• %#o：显示前缀 0 的八进制整数。
• %#x：显示前缀 0x 的十六进制整数。
• %#X：显示前缀 0X 的十六进制整数。

int x = 100;
printf("dec = %dn", x); // 100
printf("octal = %on", x); // 144
printf("hex = %xn", x); // 64
printf("octal = %#on", x); // 0144
printf("hex = %#xn", x); // 0x64
printf("hex = %#Xn", x); // 0X64

浮点类型

头文件 float.h 定义了宏，在程序中可以使用这些值和其他有关实数二进制表示的细节。下面的实例将输出浮点类型占用的存储空间以及它的范围值：

#include <stdio.h>
#include <float.h>

int main()
{
    // %E 为以指数形式输出单、双精度实数
    printf("float32(float) 存储最大字节数 : %lu n", sizeof(float));
    printf("float64(double) 存储最大字节数 : %lu n",sizeof(double));
    printf("float32(float) 最小值: %En", FLT_MIN );
    printf("float32(float) 最大值: %En", FLT_MAX );
    printf("float64(double) 最小值: %En", DBL_MIN );
    printf("float64(double) 最大值: %En", DBL_MAX );
    printf("float32(float)精度值: %dn", FLT_DIG );
    printf("float64(double)精度值: %dn", DBL_DIG );

    return 0;
}

这里可以对比一下go的：

package main

import (
	"fmt"
	"math"
	"unsafe"
)

func main() {
	nullFloat64 := *new(float64)
	fmt.Println(unsafe.Sizeof(nullFloat64))
	nullFloat32 := *new(float32)
	fmt.Println(unsafe.Sizeof(nullFloat32))
	fmt.Println("float32最大值:", math.MaxFloat32)
	fmt.Println("float64最大值:", math.MaxFloat64)
}

void 类型

void 类型指定没有可用的值。它通常用于以下三种情况下：

字符类型

字符类型指的是单个字符，类型声明使用char关键字。

char c = 'B';

上面示例声明了变量c是字符类型，并将其赋值为字母B。

C 语言规定，字符常量必须放在单引号里面。

在计算机内部，字符类型使用一个字节（8位）存储。C 语言将其当作整数处理，所以字符类型就是宽度为一个字节的整数。每个字符对应一个整数（由 ASCII 码确定），比如B对应整数66。

字符类型在不同计算机的默认范围是不一样的。一些系统默认为-128到127，另一些系统默认为0到255。这两种范围正好都能覆盖0到127的 ASCII 字符范围。

只要在字符类型的范围之内，整数与字符是可以互换的，都可以赋值给字符类型的变量。

char c = 66;
// 等同于
char c = 'B';

上面示例中，变量c是字符类型，赋给它的值是整数66。这跟赋值为字符B的效果是一样的。

两个字符类型的变量可以进行数学运算。

char a = 'B'; // 等同于 char a = 66;
char b = 'C'; // 等同于 char b = 67;

printf("%dn", a + b); // 输出 133

上面示例中，字符类型变量a和b相加，视同两个整数相加。占位符%d表示输出十进制整数，因此输出结果为133。

单引号本身也是一个字符，如果要表示这个字符常量，必须使用反斜杠转义。

char t = ''';

上面示例中，变量t为单引号字符，由于字符常量必须放在单引号里面，所以内部的单引号要使用反斜杠转义。

这种转义的写法，主要用来表示 ASCII 码定义的一些无法打印的控制字符，它们也属于字符类型的值。

• a：警报，这会使得终端发出警报声或出现闪烁，或者两者同时发生。
• b：退格键，光标回退一个字符，但不删除字符。
• f：换页符，光标移到下一页。在现代系统上，这已经反映不出来了，行为改成类似于 v。
• n：换行符。
• r：回车符，光标移到同一行的开头。
• t：制表符，光标移到下一个水平制表位，通常是下一个8的倍数。
• v：垂直分隔符，光标移到下一个垂直制表位，通常是下一行的同一列。
• ：null 字符，代表没有内容。注意，这个值不等于数字0。

转义写法还能使用八进制和十六进制表示一个字符。

• nn：字符的八进制写法，nn为八进制值。
• xnn：字符的十六进制写法，nn为十六进制值。

char x = 'B';
char x = 66;
char x = '102'; // 八进制
char x = 'x42'; // 十六进制

上面示例的四种写法都是等价的。

布尔类型

C 语言原来并没有为布尔值单独设置一个类型，而是使用整数0表示伪，所有非零值表示真。

int x = 1;
if (x) {
  printf("x is true!n");
}

上面示例中，变量x等于1，C 语言就认为这个值代表真，从而会执行判断体内部的代码。

C99 标准添加了类型_Bool，表示布尔值。但是，这个类型其实只是整数类型的别名，还是使用0表示伪，1表示真，下面是一个示例。

_Bool isNormal;

isNormal = 1;
if (isNormal)
  printf("Everything is OK.n");

头文件stdbool.h定义了另一个类型别名bool，并且定义了true代表1、false代表0。只要加载这个头文件，就可以使用这几个关键字。

#include <stdbool.h>

bool flag = false;

上面示例中，加载头文件stdbool.h以后，就可以使用bool定义布尔值类型，以及false和true表示真伪。

溢出

每一种数据类型都有数值范围，如果存放的数值超出了这个范围（小于最小值或大于最大值），需要更多的二进制位存储，就会发生溢出。大于最大值，叫做向上溢出（overflow）；小于最小值，叫做向下溢出（underflow）。

一般来说，编译器不会对溢出报错，会正常执行代码，但是会忽略多出来的二进制位，只保留剩下的位，这样往往会得到意想不到的结果。所以，应该避免溢出。

unsigned char x = 255;
x = x + 1;

printf("%dn", x); // 0

上面示例中，变量x加1，得到的结果不是256，而是0。因为x是unsign char类型，最大值是255（二进制11111111），加1后就发生了溢出，256（二进制100000000）的最高位1被丢弃，剩下的值就是0。

再看下面的例子。

unsigned int ui = UINT_MAX;  // 4,294,967,295
ui++;
printf("ui = %un", ui); // 0
ui--;
printf("ui = %un", ui); // 4,294,967,295

上面示例中，常量UINT_MAX是 unsigned int 类型的最大值。如果加1，对于该类型就会溢出，从而得到0；而0是该类型的最小值，再减1，又会得到UINT_MAX。

溢出很容易被忽视，编译器又不会报错，所以必须非常小心。

for (unsigned int i = n; i >= 0; --i) // 错误

上面代码表面看似乎没有问题，但是循环变量i的类型是 unsigned int，这个类型的最小值是0，不可能得到小于0的结果。当i等于0，再减去1的时候，并不会返回-1，而是返回 unsigned int 的类型最大值，这个值总是大于等于0，导致无限循环。

为了避免溢出，最好方法就是将运算结果与类型的极限值进行比较。

unsigned int ui;
unsigned int sum;

// 错误
if (sum + ui > UINT_MAX) too_big();
else sum = sum + ui;

// 正确
if (ui > UINT_MAX - sum) too_big();
else sum = sum + ui;

上面示例中，变量sum和ui都是 unsigned int 类型，它们相加的和还是 unsigned int 类型，这就有可能发生溢出。但是，不能通过相加的和是否超出了最大值UINT_MAX，来判断是否发生了溢出，因为sum + ui总是返回溢出后的结果，不可能大于UINT_MAX。正确的比较方法是，判断UINT_MAX – sum与ui之间的大小关系。

下面是另一种错误的写法。

unsigned int i = 5;
unsigned int j = 7;

if (i - j < 0) // 错误
  printf("negativen");
else
  printf("positiven");

上面示例的运算结果，会输出positive。原因是变量i和j都是 unsigned int 类型，i – j的结果也是这个类型，最小值为0，不可能得到小于0的结果。正确的写法是写成下面这样。

if (j > i) // ....

sizeof 运算符

sizeof是 C 语言提供的一个运算符，返回某种数据类型或某个值占用的字节数量。它的参数可以是数据类型的关键字，也可以是变量名或某个具体的值。

// 参数为数据类型
int x = sizeof(int);

// 参数为变量
int i;
sizeof(i);

// 参数为数值
sizeof(3.14);

上面的第一个示例，返回得到int类型占用的字节数量（通常是4或8）。第二个示例返回整数变量占用字节数量，结果与前一个示例完全一样。第三个示例返回浮点数3.14占用的字节数量，由于浮点数的字面量一律存储为 double 类型，所以会返回8，因为 double 类型占用的8个字节。

sizeof运算符的返回值，C 语言只规定是无符号整数，并没有规定具体的类型，而是留给系统自己去决定，sizeof到底返回什么类型。不同的系统中，返回值的类型有可能是unsigned int，也有可能是unsigned long，甚至是unsigned long long，对应的printf()占位符分别是%u、%lu和%llu。这样不利于程序的可移植性。

C 语言提供了一个解决方法，创造了一个类型别名size_t，用来统一表示sizeof的返回值类型。该别名定义在stddef.h头文件（引入stdio.h时会自动引入）里面，对应当前系统的sizeof的返回值类型，可能是unsigned int，也可能是unsigned long。

C 语言还提供了一个常量SIZE_MAX，表示size_t可以表示的最大整数。所以，size_t能够表示的整数范围为[0, SIZE_MAX]。

printf()有专门的占位符%zd或%zu，用来处理size_t类型的值。

printf("%zdn", sizeof(int));

上面代码中，不管sizeof返回值的类型是什么，%zd占位符（或%zu）都可以正确输出。

如果当前系统不支持%zd或%zu，可使用%u（unsigned int）或%lu（unsigned long int）代替。

类型转换

类型转换是将一个数据类型的值转换为另一种数据类型的值。

C 语言中有两种类型转换：

1. 隐式类型转换：隐式类型转换是在表达式中自动发生的，无需进行任何明确的指令或函数调用。它通常是将一种较小的类型自动转换为较大的类型，例如，将int类型转换为long类型或float类型转换为double类型。隐式类型转换也可能会导致数据精度丢失或数据截断。

2. 显式类型转换：显式类型转换需要使用强制类型转换运算符（type casting operator），它可以将一个数据类型的值强制转换为另一种数据类型的值。强制类型转换可以使程序员在必要时对数据类型进行更精确的控制，但也可能会导致数据丢失或截断。

隐式类型转换实例：

int i = 10;
float f = 3.14;
double d = i + f; // 隐式将int类型转换为double类型

显式类型转换实例（只要在一个值或变量的前面，使用圆括号指定类型(type)，就可以将这个值或变量转为指定的类型，这叫做“类型指定”（casting）。）：

double d = 3.14159;
int i = (int)d; // 显式将double类型转换为int类型

值得一提的是，Go 中没有隐式类型转换，所有的类型转换都需要显式地进行。

在 Go 中，如果你要将一个值从一种类型转换为另一种类型，你需要使用显式的类型转换语法。例如：

package main

import "fmt"

func main() {
    var x int = 42
    var y float64

    // 显式类型转换
    y = float64(x)

    fmt.Printf("x: %d, y: %fn", x, y)
}

也就是上述C代码在go中会报错：

可移植类型

C 语言的整数类型（short、int、long）在不同计算机上，占用的字节宽度可能是不一样的，无法提前知道它们到底占用多少个字节。

程序员有时控制准确的字节宽度，这样的话，代码可以有更好的可移植性，头文件stdint.h创造了一些新的类型别名。

（1）精确宽度类型(exact-width integer type)，保证某个整数类型的宽度是确定的。

• int8_t：8位有符号整数。
• int16_t：16位有符号整数。
• int32_t：32位有符号整数。
• int64_t：64位有符号整数。
• uint8_t：8位无符号整数。
• uint16_t：16位无符号整数。
• uint32_t：32位无符号整数。
• uint64_t：64位无符号整数。

上面这些都是类型别名，编译器会指定它们指向的底层类型。比如，某个系统中，如果int类型为32位，int32_t就会指向int；如果long类型为32位，int32_t则会指向long。

#include <stdio.h>
#include <stdint.h>

int main(void) {
  int32_t x32 = 45933945;
  printf("x32 = %dn", x32);
  return 0;
}

上面示例中，变量x32声明为int32_t类型，可以保证是32位的宽度。

（2）最小宽度类型（minimum width type），保证某个整数类型的最小长度。

• int_least8_t
• int_least16_t
• int_least32_t
• int_least64_t
• uint_least8_t
• uint_least16_t
• uint_least32_t
• uint_least64_t

上面这些类型，可以保证占据的字节不少于指定宽度。比如，int_least8_t表示可以容纳8位有符号整数的最小宽度的类型。

（3）最快的最小宽度类型（fast minimum width type），可以使整数计算达到最快的类型。

• int_fast8_t
• int_fast16_t
• int_fast32_t
• int_fast64_t
• uint_fast8_t
• uint_fast16_t
• uint_fast32_t
• uint_fast64_t

上面这些类型是保证字节宽度的同时，追求最快的运算速度，比如int_fast8_t表示对于8位有符号整数，运算速度最快的类型。这是因为某些机器对于特定宽度的数据，运算速度最快，举例来说，32位计算机对于32位数据的运算速度，会快于16位数据。

（4）可以保存指针的整数类型。

• intptr_t：可以存储指针（内存地址）的有符号整数类型。
• uintptr_t：可以存储指针的无符号整数类型。

（5）最大宽度整数类型，用于存放最大的整数。

• intmax_t：可以存储任何有效的有符号整数的类型。

• uintmax_t：可以存放任何有效的无符号整数的类型。

  上面的这两个类型的宽度比long long和unsigned long更大。

C 变量

变量其实只不过是程序可操作的存储区的名称。C 中每个变量都有特定的类型，类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中，运算符可应用于变量上。

变量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大写字母和小写字母是不同的，因为 C 是大小写敏感的。基于前一章讲解的基本类型，有以下几种基本的变量类型：

C 语言也允许定义各种其他类型的变量，比如枚举、指针、数组、结构、共用体等等

C 中的变量定义

变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储。变量定义指定一个数据类型，并包含了该类型的一个或多个变量的列表，如下所示：

type variable_list;

type 表示变量的数据类型，可以是整型、浮点型、字符型、指针等，也可以是用户自定义的对象。

variable_list 可以由一个或多个变量的名称组成，多个变量之间用逗号,分隔，变量由字母、数字和下划线组成，且以字母或下划线开头。

下面列出几个有效的声明：

定义整型变量：

int age;

以上代码中，age 被定义为一个整型变量。

定义浮点型变量：

float salary;

以上代码中，salary 被定义为一个浮点型变量。

定义字符型变量：

char grade;

以上代码中，grade 被定义为一个字符型变量。

定义指针变量：

int *ptr;

以上代码中，ptr 被定义为一个整型指针变量。

定义多个变量：

int    i, j, k;

int i, j, k; 声明并定义了变量 i、j 和 k，这指示编译器创建类型为 int 的名为 i、j、k 的变量。

变量初始化

在 C 语言中，变量的初始化是在定义变量的同时为其赋予一个初始值。变量的初始化可以在定义时进行，也可以在后续的代码中进行。

初始化器由一个等号，后跟一个常量表达式组成，如下所示：

type variable_name = value;

其中，type 表示变量的数据类型，variable_name 是变量的名称，value 是变量的初始值。下面列举几个实例：

int x = 10;         // 整型变量 x 初始化为 10
float pi = 3.14;    // 浮点型变量 pi 初始化为 3.14
char ch = 'A';      // 字符型变量 ch 初始化为字符 'A'
extern int d = 3, f = 5;    // d 和 f 的声明与初始化
int d = 3, f = 5;           // 定义并初始化 d 和 f
byte z = 22;                // 定义并初始化 z

后续初始化变量：

在变量定义后的代码中，可以使用赋值运算符 = 为变量赋予一个新的值。

type variable_name;    // 变量定义
variable_name = new_value;    // 变量初始化

实例如下：

int x;          // 整型变量x定义
x = 20;         // 变量x初始化为20
float pi;       // 浮点型变量pi定义
pi = 3.14159;   // 变量pi初始化为3.14159
char ch;        // 字符型变量ch定义
ch = 'B';       // 变量ch初始化为字符'B'

需要注意的是，变量在使用之前应该被初始化。未初始化的变量的值是未定义的，可能包含任意的垃圾值。因此，为了避免不确定的行为和错误，建议在使用变量之前进行初始化。

变量不初始化

在 C 语言中，如果变量没有显式初始化，那么它的默认值将取决于该变量的类型和其所在的作用域。

对于全局变量和静态变量（在函数内部定义的静态变量和在函数外部定义的全局变量），它们的默认初始值为零。

以下是不同类型的变量在没有显式初始化时的默认值：

• 整型变量（int、short、long等）：默认值为0。
• 浮点型变量（float、double等）：默认值为0.0。
• 字符型变量（char）：默认值为’’，即空字符。
• 指针变量：默认值为NULL，表示指针不指向任何有效的内存地址。
• 数组、结构体、联合等复合类型的变量：它们的元素或成员将按照相应的规则进行默认初始化，这可能包括对元素递归应用默认规则。

需要注意的是，局部变量（在函数内部定义的非静态变量）不会自动初始化为默认值，它们的初始值是未定义的（包含垃圾值）。因此，在使用局部变量之前，应该显式地为其赋予一个初始值。

总结起来，C 语言中变量的默认值取决于其类型和作用域。全局变量和静态变量的默认值为 0，字符型变量的默认值为 ，指针变量的默认值为 NULL，而局部变量没有默认值，其初始值是未定义的。

#include <stdio.h>

void myFunction() {
    int x;  // 未初始化的局部变量
    printf("The value of x is: %dn", x);
}


int main() {
    myFunction();
    return 0;
}

C 中的变量声明

变量声明向编译器保证变量以指定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。变量声明只在编译时有它的意义，在程序连接时编译器需要实际的变量声明。

变量的声明有两种情况：

• 1、一种是需要建立存储空间的。例如：int a 在声明的时候就已经建立了存储空间。
• 2、另一种是不需要建立存储空间的，通过使用extern关键字声明变量名而不定义它。 例如：extern int a 其中变量 a 可以在别的文件中定义的。
• 除非有extern关键字，否则都是变量的定义。

extern int i; //声明，不是定义
int i; //声明，也是定义

如下实例，其中，变量在头部就已经被声明，但是定义与初始化在主函数内：

#include <stdio.h>
 
// 函数外定义变量 x 和 y
int x;
int y;
int addtwonum()
{
    // 函数内声明变量 x 和 y 为外部变量
    extern int x;
    extern int y;
    // 给外部变量（全局变量）x 和 y 赋值
    x = 1;
    y = 2;
    return x+y;
}
 
int main()
{
    int result;
    // 调用函数 addtwonum
    result = addtwonum();
    
    printf("result 为: %d",result);
    return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

result 为: 3

如果需要在一个源文件中引用另外一个源文件中定义的变量，我们只需在引用的文件中将变量加上 extern 关键字的声明即可。

addtwonum.c 文件代码：

#include <stdio.h>
/*外部变量声明*/
extern int x ;
extern int y ;
int addtwonum()
{
    return x+y;
}

main.c 文件代码：

#include <stdio.h>
#include "addtwonum.c"
  
/*定义两个全局变量*/
int x=1;
int y=2;
int addtwonum();
int main(void)
{
    int result;
    result = addtwonum();
    printf("result 为: %dn",result);
    return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

$ gcc addtwonum.c test.c -o main
$ ./main
result 为: 3

C 中的左值（Lvalues）和右值（Rvalues）

C 中有两种类型的表达式：

1. 左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。
2. 右值（rvalue）：术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。

变量是左值，因此可以出现在赋值号的左边。数值型的字面值是右值，因此不能被赋值，不能出现在赋值号的左边。下面是一个有效的语句：

int g = 20;

但是下面这个就不是一个有效的语句，会生成编译时错误：

10 = 20;

变量的作用域

作用域（scope）指的是变量生效的范围。C 语言的变量作用域主要有两种：文件作用域（file scope）和块作用域（block scope）。

文件作用域（file scope）指的是，在源码文件顶层声明的变量，从声明的位置到文件结束都有效。

int x = 1;

int main(void) {
  printf("%in", x);
}

上面示例中，变量x是在文件顶层声明的，从声明位置开始的整个当前文件都是它的作用域，可以在这个范围的任何地方读取这个变量，比如函数main()内部就可以读取这个变量。

块作用域（block scope）指的是由大括号（{}）组成的代码块，它形成一个单独的作用域。凡是在块作用域里面声明的变量，只在当前代码块有效，代码块外部不可见。

int a = 12;

if (a == 12) {
  int b = 99;
  printf("%d %dn", a, b);  // 12 99
}

printf("%dn", a);  // 12
printf("%dn", b);  // 出错

上面例子中，变量b是在if代码块里面声明的，所以对于大括号外面的代码，这个变量是不存在的。

代码块可以嵌套，即代码块内部还有代码块，这时就形成了多层的块作用域。它的规则是：内层代码块可以使用外层声明的变量，但外层不可以使用内层声明的变量。如果内层的变量与外层同名，那么会在当前作用域覆盖外层变量。

{
  int i = 10;

  {
    int i = 20;
    printf("%dn", i);  // 20
  }

  printf("%dn", i);  // 10
}

上面示例中，内层和外层都有一个变量i，每个作用域都会优先使用当前作用域声明的i。

最常见的块作用域就是函数，函数内部声明的变量，对于函数外部是不可见的。for循环也是一个块作用域，循环变量只对循环体内部可见，外部是不可见的。

for (int i = 0; i < 10; i++)
  printf("%dn", i);

printf("%dn", i); // 出错

上面示例中，for循环省略了大括号，但依然是一个块作用域，在外部读取循环变量i，编译器就会报错。

C 常量

常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面量。

常量可以是任何的基本数据类型，比如整数常量、浮点常量、字符常量，或字符串字面值，也有枚举常量。

常量就像是常规的变量，只不过常量的值在定义后不能进行修改。

常量可以直接在代码中使用，也可以通过定义常量来使用。

整数常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。

整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。

下面列举几个整数常量的实例：

212         /* 合法的 */
215u        /* 合法的 */
0xFeeL      /* 合法的 long类型的16进制数字 */
078         /* 非法的：8 不是八进制的数字 */
032UU       /* 非法的：不能重复后缀 */

以下是各种类型的整数常量的实例：

85         /* 十进制 */
0213       /* 八进制 */
0x4b       /* 十六进制 */
30         /* 整数 */
30u        /* 无符号整数 */
30l        /* 长整数 */
30ul       /* 无符号长整数 */

整数常量可以带有一个后缀表示数据类型，例如：

int myInt = 10;
long myLong = 100000L;
unsigned int myUnsignedInt = 10U;

浮点常量

浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。

当使用小数形式表示时，必须包含整数部分、小数部分，或同时包含两者。当使用指数形式表示时， 必须包含小数点、指数，或同时包含两者。带符号的指数是用 e 或 E 引入的。

下面列举几个浮点常量的实例：

3.14159       /* 合法的 */
314159E-5L    /* 合法的 */
510E          /* 非法的：不完整的指数 */
210f          /* 非法的：没有小数或指数 */
.e55          /* 非法的：缺少整数或分数 */

浮点数常量可以带有一个后缀表示数据类型，例如：

float myFloat = 3.14f;
double myDouble = 3.14159;

314159e-5 是科学计数法表示的数值，它可以解释为 314159 乘以 10 的负 5 次方（或者除以 10 的 5 次方）。

具体地说，这个数值等于：

因此，314159e-5 的值就是 3.14159。科学计数法通常用于表示非常大或非常小的数，以便更容易理解和书写。

字符常量

字符常量是括在单引号中，例如，‘x’ 可以存储在 char 类型的简单变量中。

字符常量可以是一个普通的字符（例如 ‘x’）、一个转义序列（例如 ‘t’），或一个通用的字符（例如 ‘u02C0’）。

在 C 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，被用来表示如换行符（n）或制表符（t）等。下表列出了一些这样的转义序列码：

下面的实例显示了一些转义序列字符：

#include <stdio.h>
 
int main()
{
   printf("HellotWorldnn");
 
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Hello   World

字符常量的 ASCII 值可以通过强制类型转换转换为整数值。

char myChar = 'a';
int myAsciiValue = (int) myChar; // 将 myChar 转换为 ASCII 值 97

字符串常量

字符串字面值或常量是括在双引号 ” ” 中的。一个字符串包含类似于字符常量的字符：普通的字符、转义序列和通用的字符。

您可以使用空格做分隔符，把一个很长的字符串常量进行分行。

下面的实例显示了一些字符串常量。下面这三种形式所显示的字符串是相同的。

"hello, dear"

"hello, 

dear"

"hello, " "d" "ear"

字符串常量在内存中以 null 终止符 结尾。例如：

char myString[] = "Hello, world!"; //系统对字符串常量自动加一个 ''

定义常量

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

1. 使用 #define 预处理器： #define 可以在程序中定义一个常量，它在编译时会被替换为其对应的值。
2. 使用 const 关键字：const 关键字用于声明一个只读变量，即该变量的值不能在程序运行时修改。

#define 预处理器

下面是使用 #define 预处理器定义常量的形式：

#define 常量名 常量值

下面的代码定义了一个名为 PI 的常量：

#define PI 3.14159在程序中使用该常量时，编译器会将所有的 PI 替换为 3.14159。

#include <stdio.h>
 
#define LENGTH 10   
#define WIDTH  5
#define NEWLINE 'n'
 
int main()
{
 
   int area;  
  
   area = LENGTH * WIDTH;
   printf("value of area : %d", area);
   printf("%c", NEWLINE);
 
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

value of area : 50

const 关键字

可以使用 const 前缀声明指定类型的常量，如下所示：

const 数据类型 常量名 = 常量值;

下面的代码定义了一个名为MAX_VALUE的常量：

const int MAX_VALUE = 100;

在程序中使用该常量时，其值将始终为100，并且不能被修改。

const 声明常量要在一个语句内完成：

#define 与 const 区别

#define 与 const 这两种方式都可以用来定义常量，选择哪种方式取决于具体的需求和编程习惯。通常情况下，建议使用 const 关键字来定义常量，因为它具有类型检查和作用域的优势，而 #define 仅进行简单的文本替换，可能会导致一些意外的问题。

#define 预处理指令和 const 关键字在定义常量时有一些区别：

1. 替换机制：#define 是进行简单的文本替换，而 const 是声明一个具有类型的常量。#define 定义的常量在编译时会被直接替换为其对应的值，而 const 定义的常量在程序运行时会分配内存，并且具有类型信息。

2. 类型检查：#define 不进行类型检查，因为它只是进行简单的文本替换。而 const 定义的常量具有类型信息，编译器可以对其进行类型检查。这可以帮助捕获一些潜在的类型错误。

3. 作用域：#define 定义的常量没有作用域限制，它在定义之后的整个代码中都有效。而 const 定义的常量具有块级作用域，只在其定义所在的作用域内有效。

4. 调试和符号表：使用 #define 定义的常量在符号表中不会有相应的条目，因为它只是进行文本替换。而使用 const 定义的常量会在符号表中有相应的条目，有助于调试和可读性。

C 存储类（变量说明符）

存储类定义 C 程序中变量/函数的存储位置、生命周期和作用域。

这些说明符放置在它们所修饰的类型之前。

下面列出 C 程序中可用的存储类：

1. const
2. static
3. auto
4. extern
5. register
6. volatile
7. restrict

const

const说明符表示变量是只读的，不得被修改。

const double PI = 3.14159;
PI = 3; // 报错

上面示例里面的const，表示变量PI的值不应改变。如果改变的话，编译器会报错。

对于数组，const表示数组成员不能修改。

const int arr[] = {1, 2, 3, 4};
arr[0] = 5; // 报错

上面示例中，const使得数组arr的成员无法修改。

对于指针变量，const有两种写法，含义是不一样的。如果const在*前面，表示指针指向的值不可修改。

// const 表示指向的值 *x 不能修改
int const * x
// 或者
const int * x

下面示例中，对x指向的值进行修改导致报错。

int p = 1
const int* x = &p;

(*x)++; // 报错

如果const在*后面，表示指针包含的地址不可修改。

// const 表示地址 x 不能修改
int* const x

下面示例中，对x进行修改导致报错。

int p = 1
int* const x = &p;

x++; // 报错

这两者可以结合起来。

const char* const x;

上面示例中，指针变量x指向一个字符串。两个const意味着，x包含的内存地址以及x指向的字符串，都不能修改。

const的一个用途，就是防止函数体内修改函数参数。如果某个参数在函数体内不会被修改，可以在函数声明时，对该参数添加const说明符。这样的话，使用这个函数的人看到原型里面的const，就知道调用函数前后，参数数组保持不变。

void find(const int* arr, int n);

上面示例中，函数find的参数数组arr有const说明符，就说明该数组在函数内部将保持不变。

有一种情况需要注意，如果一个指针变量指向const变量，那么该指针变量也不应该被修改。

const int i = 1;
int* j = &i;
*j = 2; // 报错

上面示例中，j是一个指针变量，指向变量i，即j和i指向同一个地址。j本身没有const说明符，但是i有。这种情况下，j指向的值也不能被修改。

auto 存储类

auto 存储类是所有局部变量默认的存储类。

定义在函数中的变量默认为 auto 存储类，这意味着它们在函数开始时被创建，在函数结束时被销毁。

{
   int mount;
   auto int month;
}

上面的实例定义了两个带有相同存储类的变量，auto 只能用在函数内，即 auto 只能修饰局部变量。

这属于默认行为，所以该说明符没有实际作用，一般都省略不写。

register 存储类

register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个字），且不能对它应用一元的 ‘&’ 运算符（因为它没有内存位置）。

register 存储类定义存储在寄存器，所以变量的访问速度更快，但是它不能直接取地址，因为它不是存储在 RAM 中的。在需要频繁访问的变量上使用 register 存储类可以提高程序的运行速度。

{
   register int  miles;
}

寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 ‘register’ 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

static 存储类

static说明符对于全局变量和局部变量有不同的含义。

（1）用于局部变量（位于块作用域内部）。

static用于函数内部声明的局部变量时，表示该变量的值会在函数每次执行后得到保留，下次执行时不会进行初始化，就类似于一个只用于函数内部的全局变量。由于不必每次执行函数时，都对该变量进行初始化，这样可以提高函数的执行速度，详见《函数》一章。

（2）用于全局变量（位于块作用域外部）。

static用于函数外部声明的全局变量时，表示该变量只用于当前文件，其他源码文件不可以引用该变量，即该变量不会被链接（link）。

static修饰的变量，初始化时，值不能等于变量，必须是常量。

static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。

static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

全局声明的一个 static 变量或方法可以被任何函数或方法调用，只要这些方法出现在跟 static 变量或方法同一个文件中。

静态变量在程序中只被初始化一次，即使函数被调用多次，该变量的值也不会重置。

以下实例演示了 static 修饰全局变量和局部变量的应用：

#include <stdio.h>
 
/* 函数声明 */
void func1(void);
 
static int count=10;        /* 全局变量 - static 是默认的 */
 
int main()
{
  while (count--) {
      func1();
  }
  return 0;
}
 
void func1(void)
{
/* 'thingy' 是 'func1' 的局部变量 - 只初始化一次
 * 每次调用函数 'func1' 'thingy' 值不会被重置。
 */                
  static int thingy=5;
  thingy++;
  printf(" thingy 为 %d ， count 为 %dn", thingy, count);
}

实例中 count 作为全局变量可以在函数内使用，thingy 使用 static 修饰后，不会在每次调用时重置。

 thingy 为 6 ， count 为 9
 thingy 为 7 ， count 为 8
 thingy 为 8 ， count 为 7
 thingy 为 9 ， count 为 6
 thingy 为 10 ， count 为 5
 thingy 为 11 ， count 为 4
 thingy 为 12 ， count 为 3
 thingy 为 13 ， count 为 2
 thingy 为 14 ， count 为 1
 thingy 为 15 ， count 为 0

extern 存储类

extern说明符表示，该变量在其他文件里面声明，没有必要在当前文件里面为它分配空间。通常用来表示，该变量是多个文件共享的。

extern int a;

上面代码中，a是extern变量，表示该变量在其他文件里面定义和初始化，当前文件不必为它分配存储空间。

但是，变量声明时，同时进行初始化，extern就会无效。

// extern 无效
extern int i = 0;

// 等同于
int i = 0;

上面代码中，extern对变量初始化的声明是无效的。这是为了防止多个extern对同一个变量进行多次初始化。

函数内部使用extern声明变量，就相当于该变量是静态存储，每次执行时都要从外部获取它的值。

函数本身默认是extern，即该函数可以被外部文件共享，通常省略extern不写。如果只希望函数在当前文件可用，那就需要在函数前面加上static。

extern int f(int i);
// 等同于
int f(int i);

extern 存储类用于定义在其他文件中声明的全局变量或函数。当使用 extern 关键字时，不会为变量分配任何存储空间，而只是指示编译器该变量在其他文件中定义。

extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 extern 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。

当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。

extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候，如下所示：

第一个文件：main.c

#include <stdio.h>
 
int count ;
extern void write_extern();
 
int main()
{
   count = 5;
   write_extern();
}

第二个文件：support.c

#include <stdio.h>
 
extern int count;
 
void write_extern(void)
{
   printf("count is %dn", count);
}

在这里，第二个文件中的 extern 关键字用于声明已经在第一个文件 main.c 中定义的 count。现在 ，编译这两个文件，如下所示：

 $ gcc main.c support.c

这会产生 a.out 可执行程序，当程序被执行时，它会产生下列结果：

count is 5

volatile

volatile说明符表示所声明的变量，可能会预想不到地发生变化（即其他程序可能会更改它的值），不受当前程序控制，因此编译器不要对这类变量进行优化，每次使用时都应该查询一下它的值。硬件设备的编程中，这个说明符很常用。

volatile int foo;
volatile int* bar;

volatile的目的是阻止编译器对变量行为进行优化，请看下面的例子。

int foo = x;
// 其他语句，假设没有改变 x 的值
int bar = x;

上面代码中，由于变量foo和bar都等于x，而且x的值也没有发生变化，所以编译器可能会把x放入缓存，直接从缓存读取值（而不是从 x 的原始内存位置读取），然后对foo和bar进行赋值。如果x被设定为volatile，编译器就不会把它放入缓存，每次都从原始位置去取x的值，因为在两次读取之间，其他程序可能会改变x。

restrict

restrict说明符允许编译器优化某些代码。它只能用于指针，表明该指针是访问数据的唯一方式。

int* restrict pt = (int*) malloc(10 * sizeof(int));

上面示例中，restrict表示变量pt是访问 malloc 所分配内存的唯一方式。

下面例子的变量foo，就不能使用restrict修饰符。

int foo[10];
int* bar = foo;

上面示例中，变量foo指向的内存，可以用foo访问，也可以用bar访问，因此就不能将foo设为 restrict。

如果编译器知道某块内存只能用一个方式访问，可能可以更好地优化代码，因为不用担心其他地方会修改值。

restrict用于函数参数时，表示参数的内存地址之间没有重叠。

void swap(int* restrict a, int* restrict b) {
  int t;
  t = *a;
  *a = *b;
  *b = t;
}

上面示例中，函数参数声明里的restrict表示，参数a和参数b的内存地址没有重叠。

C 运算符

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

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

算术运算符

下表显示了 C 语言支持的所有算术运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：

以下实例演示了 a++ 与 ++a 的区别：

#include <stdio.h>
 
int main()
{
   int c;
   int a = 10;
   c = a++; 
   printf("先赋值后运算：n");
   printf("Line 1 - c 的值是 %dn", c );
   printf("Line 2 - a 的值是 %dn", a );
   a = 10;
   c = a--; 
   printf("Line 3 - c 的值是 %dn", c );
   printf("Line 4 - a 的值是 %dn", a );
 
   printf("先运算后赋值：n");
   a = 10;
   c = ++a; 
   printf("Line 5 - c 的值是 %dn", c );
   printf("Line 6 - a 的值是 %dn", a );
   a = 10;
   c = --a; 
   printf("Line 7 - c 的值是 %dn", c );
   printf("Line 8 - a 的值是 %dn", a );
 
}

以上程序执行输出结果为：

先赋值后运算：
Line 1 - c 的值是 10
Line 2 - a 的值是 11
Line 3 - c 的值是 10
Line 4 - a 的值是 9
先运算后赋值：
Line 5 - c 的值是 11
Line 6 - a 的值是 11
Line 7 - c 的值是 9
Line 8 - a 的值是 9

Go里面不存在这样++,--的用法，只是简单的认为a++等价于a+=1或a=a+1。

关系运算符

下表显示了 C 语言支持的所有关系运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：

逻辑运算符

下表显示了 C 语言支持的所有关系逻辑运算符。假设变量 A 的值为 1，变量 B 的值为 0，则：

位运算符

位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：

假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

下表显示了 C 语言支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：

0&0=0;   
0&1=0;    
1&0=0;     
1&1=1;

0|0=0;   
0|1=1;   
1|0=1;    
1|1=1;

0^0=0;   
0^1=1;   
1^0=1;  
1^1=0;

~1=-2;   
~0=-1;

值得一提的是，Go的按位取反和异或的符号是一样的，因为按位取反是单目运算，异或是双目运算，不会造成混淆，所以干脆就一样了：

package main

import "fmt"

func main() {
    // 1的按位反 和 2进行位与运算
	fmt.Println(^1 ^ 2)
	fmt.Println(^1)
	fmt.Println(-2 ^ 2)
}

赋值运算符

杂项运算符 ↦ sizeof & 三元

下表列出了 C 语言支持的其他一些重要的运算符，包括 sizeof 和 ? :。

#include <stdio.h>
 
int main()
{
   int a = 4;
   short b;
   double c;
   int* ptr;
 
   /* sizeof 运算符实例 */
   printf("Line 1 - 变量 a 的大小 = %lun", sizeof(a) );
   printf("Line 2 - 变量 b 的大小 = %lun", sizeof(b) );
   printf("Line 3 - 变量 c 的大小 = %lun", sizeof(c) );
 
   /* & 和 * 运算符实例 */
   ptr = &a;    /* 'ptr' 现在包含 'a' 的地址 */
   printf("a 的值是 %dn", a);
   printf("*ptr 是 %dn", *ptr);
 
   /* 三元运算符实例 */
   a = 10;
   b = (a == 1) ? 20: 30;
   printf( "b 的值是 %dn", b );
 
   b = (a == 10) ? 20: 30;
   printf( "b 的值是 %dn", b );
}

C 中的运算符优先级

运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。

例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算乘法 3*2，然后再加上 7。

下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。

终极大招：加括号。

C 判断

判断结构要求程序员指定一个或多个要评估或测试的条件，以及条件为真时要执行的语句（必需的）和条件为假时要执行的语句（可选的）。

C 语言把任何非零和非空的值假定为 true，把零或 null 假定为 false。（Go中由于没有隐式类型转换，所以分支语句只允许填bool值）

下面是大多数编程语言中典型的判断结构的一般形式：

if 语句

语法：

if(boolean_expression 1){
   /* 当布尔表达式 1 为真时执行 */
}else if( boolean_expression 2){
   /* 当布尔表达式 2 为真时执行 */
}else if( boolean_expression 3){
   /* 当布尔表达式 3 为真时执行 */
}else {
   /* 当上面条件都不为真时执行 */
}

int main(void){
    int a;

    a = change();

    if (a == 1){
        printf("hello");
    }else if (a==2){
        printf("world");
    }else{
        printf(".");
    }
    return 0;
}

switch语句

一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case，且被测试的变量会对每个 switch case 进行检查。

语法：

switch(expression){
    case constant-expression  :
       statement(s);
       break; /* 可选的 */
    case constant-expression  :
       statement(s);
       break; /* 可选的 */
  
    /* 您可以有任意数量的 case 语句 */
    default : /* 可选的 */
       statement(s);
}

switch 语句必须遵循下面的规则：

1. switch 语句中的 expression 是一个常量表达式，必须是一个整型或枚举类型。
2. 在一个 switch 中可以有任意数量的 case 语句。每个 case 后跟一个要比较的值和一个冒号。
3. case 的 constant-expression 必须与 switch 中的变量具有相同的数据类型，且必须是一个常量或字面量。
4. 当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。
5. 当遇到 break 语句时，switch 终止，控制流将跳转到 switch 语句后的下一行。
6. 不是每一个 case 都需要包含 break。如果 case 语句不包含 break，控制流将会 继续 后续的 case，直到遇到 break 为止。
7. 一个 switch 语句可以有一个可选的 default case，出现在 switch 的结尾。default case 可用于在上面所有 case 都不为真时执行一个任务。default case 中的 break 语句不是必需的。

#include <stdio.h>
 
int main ()
{
   /* 局部变量定义 */
   int a = 100;
   int b = 200;
 
   switch(a) {
      case 100: 
         printf("这是外部 switch 的一部分n");
         switch(b) {
            case 200:
               printf("这是内部 switch 的一部分n");
         }
   }
   printf("a 的准确值是 %dn", a );
   printf("b 的准确值是 %dn", b );
 
   return 0;
}

int main(void){
    int a = 3;
    switch (a) {
        case 2:
        case 3:
            printf("3");
        default:
            printf("2");
    }
}

注意！！！！！！！

Go 中的 switch 语句和 C 中的有一些不同之处，其中之一就是在 case 匹配成功后，不需要使用 break 语句来显式终止 switch。在 Go 中，一旦匹配到一个 case，就会自动退出 switch。

func main() {
	a := 3

	switch a {
	case 2, 3, 4:
		fmt.Println(3)
	default:
		fmt.Println("2")
	}
}

? : 运算符(三元运算符)

语法：

Exp1 ? Exp2 : Exp3;

其中，Exp1、Exp2 和 Exp3 是表达式。请注意，冒号的使用和位置。

? 表达式的值是由 Exp1 决定的。如果 Exp1 为真，则计算 Exp2 的值，结果即为整个表达式的值。如果 Exp1 为假，则计算 Exp3 的值，结果即为整个表达式的值。

goto 语句

goto 语句用于跳到指定的标签名。这会破坏结构化编程，建议不要轻易使用。

char ch;

top: ch = getchar();

if (ch == 'q')
  goto top;

上面示例中，top是一个标签名，可以放在正常语句的前面，相当于为这行语句做了一个标记。程序执行到goto语句，就会跳转到它指定的标签名。

infinite_loop:
  print("Hello, world!n");
  goto infinite_loop;

上面的代码会产生无限循环。

goto 的一个主要用法是跳出多层循环。

for(...) {
  for (...) {
    while (...) {
      do {
        if (some_error_condition)
          goto bail;    
      } while(...);
    }
  }
}
    
bail:
// ... ...

上面代码有很复杂的嵌套循环，不使用 goto 的话，想要完全跳出所有循环，写起来很麻烦。

goto 的另一个用途是提早结束多重判断。

if (do_something() == ERR)
  goto error;
if (do_something2() == ERR)
  goto error;
if (do_something3() == ERR)
  goto error;
if (do_something4() == ERR)
  goto error;

上面示例有四个判断，只要有一个发现错误，就使用 goto 跳过后面的判断。

注意，goto 只能在同一个函数之中跳转，并不能跳转到其他函数。

C 循环

Go 语言提供了一种简单而强大的循环结构：for 循环。虽然 Go 没有像其他一些语言（如 C 语言）提供的 while 或 do-while 循环，但通过 for 循环的灵活性和功能强大的特性，能够很好地满足大多数循环需求。

Go 的 for 循环有多种形式，它可以用来实现各种不同的循环模式：

1. 基本的 for 循环：

   for i := 0; i < 5; i++ {
       // 循环体
   }
   

2. 无限循环：

   for {
       // 无限循环体
   }
   

3. for 循环的替代形式：

   sum := 0
   numbers := []int{1, 2, 3, 4, 5}
   for _, num := range numbers {
       sum += num
   }
   

4. for 循环的条件部分为空：

   i := 0
   for i < 5 {
       // 循环体
       i++
   }
   

通过提供灵活的 for 循环，Go 语言鼓励简洁、清晰的代码，并避免了其他语言中可能出现的循环结构的混乱和冗余。此外，Go 还提供了 range 关键字，用于遍历数组、切片、映射等数据结构，使得循环更加简洁和易读。

虽然 Go 没有像 while 或 do-while 这样的循环语句，但通过 for 循环的各种变体以及其他语言特性，Go 提供了足够的工具来处理各种循环场景。这符合 Go 语言设计的一个原则：简洁性和清晰性胜过冗余和复杂性。

其实C语言的for也能实现类似功能，基本语法：

for ( init; condition; increment )
{
   statement(s);
}

基本循环：

for (int i=0;i<10;i++){

}

无限循环：

for (;;){
}

for 循环的条件部分为空：

for (;i<10;){

}

循环控制语句

C 函数

函数是一组一起执行一个任务的语句。每个 C 程序都至少有一个函数，即主函数 main() ，所有简单的程序都可以定义其他额外的函数。

函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。

C 标准库提供了大量的程序可以调用的内置函数。例如，函数 strcat() 用来连接两个字符串，函数 memcpy() 用来复制内存到另一个位置。

main()

C 语言规定，main()是程序的入口函数，即所有的程序一定要包含一个main()函数。程序总是从这个函数开始执行，如果没有该函数，程序就无法启动。其他函数都是通过它引入程序的。

main()的写法与其他函数一样，要给出返回值的类型和参数的类型，就像下面这样。

int main(void) {
  printf("Hello Worldn");
  return 0;
}

上面示例中，最后的return 0;表示函数结束运行，返回0。

C 语言约定，返回值0表示函数运行成功，如果返回其他非零整数，就表示运行失败，代码出了问题。系统根据main()的返回值，作为整个程序的返回值，确定程序是否运行成功。

正常情况下，如果main()里面省略return 0这一行，编译器会自动加上，即main()的默认返回值为0。所以，写成下面这样，效果完全一样。

int main(void) {
  printf("Hello Worldn");
}

由于 C 语言只会对main()函数默认添加返回值，对其他函数不会这样做，所以建议总是保留return语句，以便形成统一的代码风格。

定义函数

C 语言中的函数定义的一般形式如下：

return_type function_name( parameter list )
{
   body of the function
}

在 C 语言中，函数由一个函数头和一个函数主体组成。下面列出一个函数的所有组成部分：

1. 返回类型：一个函数可以返回一个值。return_type 是函数返回的值的数据类型。有些函数执行所需的操作而不返回值，在这种情况下，return_type 是关键字 void。
2. 函数名称：这是函数的实际名称。函数名和参数列表一起构成了函数签名。
3. 参数：参数就像是占位符。当函数被调用时，您向参数传递一个值，这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。参数是可选的，也就是说，函数可能不包含参数。
4. 函数主体：函数主体包含一组定义函数执行任务的语句。

函数声明

函数声明会告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。

函数声明包括以下几个部分：

return_type function_name( parameter list );

针对上面定义的函数 max()，以下是函数声明：

int max(int num1, int num2);

在函数声明中，参数的名称并不重要，只有参数的类型是必需的，因此下面也是有效的声明：

int max(int, int);

当您在一个源文件中定义函数且在另一个文件中调用函数时，函数声明是必需的。在这种情况下，您应该在调用函数的文件顶部声明函数。

函数参数

如果函数要使用参数，则必须声明接受参数值的变量。这些变量称为函数的形式参数。

形式参数就像函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁。

当调用函数时，有两种向函数传递参数的方式：

1. 传值调用：该方法把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数不会影响实际参数。
2. 引用调用：通过指针传递方式，形参为指向实参地址的指针，当对形参的指向操作时，就相当于对实参本身进行的操作。

/* 函数定义 */
void swap(int *x, int *y)
{
   int temp;
   temp = *x;    /* 保存地址 x 的值 */
   *x = *y;      /* 把 y 赋值给 x */
   *y = temp;    /* 把 temp 赋值给 y */
  
   return;
}

默认情况下，C 使用传值调用来传递参数。一般来说，这意味着函数内的代码不能改变用于调用函数的实际参数。

函数指针

函数本身就是一段内存里面的代码，C 语言允许通过指针获取函数。

void print(int a) {
  printf("%dn", a);
}

void (*print_ptr)(int) = &print;

上面示例中，变量print_ptr是一个函数指针，它指向函数print()的地址。函数print()的地址可以用&print获得。注意，(*print_ptr)一定要写在圆括号里面，否则函数参数(int)的优先级高于*，整个式子就会变成void* print_ptr(int)。

有了函数指针，通过它也可以调用函数。

(*print_ptr)(10);
// 等同于
print(10);

比较特殊的是，C 语言还规定，函数名本身就是指向函数代码的指针，通过函数名就能获取函数地址。也就是说，print和&print是一回事。

if (print == &print) // true

因此，上面代码的print_ptr等同于print。

void (*print_ptr)(int) = &print;
// 或
void (*print_ptr)(int) = print;

if (print_ptr == print) // true

所以，对于任意函数，都有五种调用函数的写法。

// 写法一
print(10)

// 写法二
(*print)(10)

// 写法三
(&print)(10)

// 写法四
(*print_ptr)(10)

// 写法五
print_ptr(10)

为了简洁易读，一般情况下，函数名前面都不加*和&。

这种特性的一个应用是，如果一个函数的参数或返回值，也是一个函数，那么函数原型可以写成下面这样。

int compute(int (*myfunc)(int), int, int);

上面示例可以清晰地表明，函数compute()的第一个参数也是一个函数。

注意：Go里面的函数指针与C不同，不需要复杂的计算：

package main

import (
	"fmt"
)

// 定义一个函数
func add(a, b int) int {
	return a + b
}

// 函数类型为 func(int, int) int
type addFunction func(int, int) int

func main() {
	// 创建一个函数指针并赋值为 add 函数的地址
	var addPointer addFunction
	addPointer = add
	fmt.Println(addPointer)

	addPointer2 := add
	fmt.Println(addPointer2)
}
// 0xc0ef60
// 0xc0ef60

函数原型

C语言中，函数必须先声明，后使用。由于程序总是先运行main()函数，导致所有其他函数都必须在main()函数之前声明。（仅C语言，python和go都不受限制）

C 语言提供的解决方法是，只要在程序开头处给出函数原型，函数就可以先使用、后声明。所谓函数原型，就是提前告诉编译器，每个函数的返回类型和参数类型。其他信息都不需要，也不用包括函数体，具体的函数实现可以后面再补上。

int twice(int);

int main(int num) {
  return twice(num);
}

int twice(int num) {
  return 2 * num;
}

exit()

exit()函数用来终止整个程序的运行。一旦执行到该函数，程序就会立即结束。该函数的原型定义在头文件stdlib.h里面。

exit()可以向程序外部返回一个值，它的参数就是程序的返回值。一般来说，使用两个常量作为它的参数：EXIT_SUCCESS（相当于 0）表示程序运行成功，EXIT_FAILURE（相当于 1）表示程序异常中止。这两个常数也是定义在stdlib.h里面。

// 程序运行成功
// 等同于 exit(0);
exit(EXIT_SUCCESS);

// 程序异常中止
// 等同于 exit(1);
exit(EXIT_FAILURE);

在main()函数里面，exit()等价于使用return语句。其他函数使用exit()，就是终止整个程序的运行，没有其他作用。

C 语言还提供了一个atexit()函数，用来登记exit()执行时额外执行的函数，用来做一些退出程序时的收尾工作。该函数的原型也是定义在头文件stdlib.h。

int atexit(void (*func)(void));

atexit()的参数是一个函数指针。注意，它的参数函数（下例的print）不能接受参数，也不能有返回值。

void print(void) {
  printf("something wrong!n");
}

atexit(print);
exit(EXIT_FAILURE);

上面示例中，exit()执行时会先自动调用atexit()注册的print()函数，然后再终止程序。

函数说明符

C 语言提供了一些函数说明符，让函数用法更加明确。

extern 说明符

对于多文件的项目，源码文件会用到其他文件声明的函数。这时，当前文件里面，需要给出外部函数的原型，并用extern说明该函数的定义来自其他文件。

extern int foo(int arg1, char arg2);

int main(void) {
  int a = foo(2, 3);
  // ...
  return 0;
}

上面示例中，函数foo()定义在其他文件，extern告诉编译器当前文件不包含该函数的定义。

由于函数原型默认就是extern，所以这里不加extern，效果是一样的。

static 说明符

默认情况下，每次调用函数时，函数的内部变量都会重新初始化，不会保留上一次运行的值。static说明符可以改变这种行为。

static用于函数内部声明变量时，表示该变量只需要初始化一次，不需要在每次调用时都进行初始化。也就是说，它的值在两次调用之间保持不变。

#include <stdio.h>

void counter(void) {
  static int count = 1;  // 只初始化一次
  printf("%dn", count);
  count++;
}

int main(void) {
  counter();  // 1
  counter();  // 2
  counter();  // 3
  counter();  // 4
}

上面示例中，函数counter()的内部变量count，使用static说明符修饰，表明这个变量只初始化一次，以后每次调用时都会使用上一次的值，造成递增的效果。

注意，static修饰的变量初始化时，只能赋值为常量，不能赋值为变量。

int i = 3;
static int j = i; // 错误

上面示例中，j属于静态变量，初始化时不能赋值为另一个变量i。

另外，在块作用域中，static声明的变量有默认值0。

static int foo;
// 等同于
static int foo = 0;

static可以用来修饰函数本身。

static int Twice(int num) {
  int result = num * 2;
  return(result);
}

上面示例中，static关键字表示该函数只能在当前文件里使用，如果没有这个关键字，其他文件也可以使用这个函数（通过声明函数原型）。

static也可以用在参数里面，修饰参数数组。

int sum_array(int a[static 3], int n) {
  // ...
}

上面示例中，static对程序行为不会有任何影响，只是用来告诉编译器，该数组长度至少为3，某些情况下可以加快程序运行速度。另外，需要注意的是，对于多维数组的参数，static仅可用于第一维的说明。

generalzy: 挺神奇的,在go和python中都没有整个功能，不过python用下划线实现了是否可视，go用大小写实现了是否可见，
然后再加上用外部变量就可以代替实现`保留上一次运行的值`。

const 说明符

函数参数里面的const说明符，表示函数内部不得修改该参数变量。

void f(int* p) {
  // ...
}

上面示例中，函数f()的参数是一个指针p，函数内部可能会改掉它所指向的值*p，从而影响到函数外部。

为了避免这种情况，可以在声明函数时，在指针参数前面加上const说明符，告诉编译器，函数内部不能修改该参数所指向的值。

void f(const int* p) {
  *p = 0; // 该行报错
}

上面示例中，声明函数时，const指定不能修改指针p指向的值，所以*p = 0就会报错。

但是上面这种写法，只限制修改p所指向的值，而p本身的地址是可以修改的。

void f(const int* p) {
  int x = 13;
  p = &x; // 允许修改
}

上面示例中，p本身是可以修改，const只限定*p不能修改。

如果想限制修改p，可以把const放在p前面。

void f(int* const p) {
  int x = 13;
  p = &x; // 该行报错
}

如果想同时限制修改p和*p，需要使用两个const。

void f(const int* const p) {
  // ...
}

个人感觉const用在函数中比较鸡肋，不想修改就传值的copy不就行了，传入地址的copy做什么？

可变参数

有些函数的参数数量是不确定的，声明函数的时候，可以使用省略号…表示可变数量的参数。

int printf(const char* format, ...);

上面示例是printf()函数的原型，除了第一个参数，其他参数的数量是可变的，与格式字符串里面的占位符数量有关。这时，就可以用…表示可变数量的参数。

注意，…符号必须放在参数序列的结尾，否则会报错。

头文件stdarg.h定义了一些宏，可以操作可变参数。

（1）va_list：一个数据类型，用来定义一个可变参数对象。它必须在操作可变参数时，首先使用。

（2）va_start：一个函数，用来初始化可变参数对象。它接受两个参数，第一个参数是可变参数对象，第二个参数是原始函数里面，可变参数之前的那个参数，用来为可变参数定位。

（3）va_arg：一个函数，用来取出当前那个可变参数，每次调用后，内部指针就会指向下一个可变参数。它接受两个参数，第一个是可变参数对象，第二个是当前可变参数的类型。

（4）va_end：一个函数，用来清理可变参数对象。

double average(int i, ...) {
  double total = 0;
  va_list ap;
  va_start(ap, i);
  for (int j = 1; j <= i; ++j) {
    total += va_arg(ap, double);
  }
  va_end(ap);
  return total / i;
}

上面示例中，va_list ap定义ap为可变参数对象，va_start(ap, i)将参数i后面的参数统一放入ap，va_arg(ap, double)用来从ap依次取出一个参数，并且指定该参数为 double 类型，va_end(ap)用来清理可变参数对象。

C语言可变参数的支持远远不如后期的高级语言，Go语言会将...转为切片，python则会将*args转为列表，**kwargs转为字典。

C 作用域规则

任何一种编程中，作用域是程序中定义的变量所存在的区域，超过该区域变量就不能被访问。C 语言中有三个地方可以声明变量：

1. 在函数或块内部的局部变量
2. 在所有函数外部的全局变量
3. 在形式参数的函数参数定义中

局部变量

在某个函数或块的内部声明的变量称为局部变量。它们只能被该函数或该代码块内部的语句使用。局部变量在函数外部是不可知的。下面是使用局部变量的实例。在这里，所有的变量 a、b 和 c 是 main() 函数的局部变量。

#include <stdio.h>
 
int main ()
{
  /* 局部变量声明 */
  int a, b;
  int c;
 
  /* 实际初始化 */
  a = 10;
  b = 20;
  c = a + b;
 
  printf ("value of a = %d, b = %d and c = %dn", a, b, c);
 
  return 0;
}

全局变量

全局变量是定义在函数外部，通常是在程序的顶部。全局变量在整个程序生命周期内都是有效的，在任意的函数内部能访问全局变量。

全局变量可以被任何函数访问。也就是说，全局变量在声明后整个程序中都是可用的。下面是使用全局变量和局部变量的实例：

#include <stdio.h>
 
/* 全局变量声明 */
int g;
 
int main ()
{
  /* 局部变量声明 */
  int a, b;
 
  /* 实际初始化 */
  a = 10;
  b = 20;
  g = a + b;
 
  printf ("value of a = %d, b = %d and g = %dn", a, b, g);
 
  return 0;
}

在程序中，局部变量和全局变量的名称可以相同，但是在函数内，如果两个名字相同，会使用局部变量值，全局变量不会被使用。下面是一个实例：

#include <stdio.h>
 
/* 全局变量声明 */
int g = 20;
 
int main ()
{
  /* 局部变量声明 */
  int g = 10;
 
  printf ("value of g = %dn",  g);
 
  return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

value of g = 10

形式参数

函数的参数，形式参数，被当作该函数内的局部变量，如果与全局变量同名它们会优先使用。下面是一个实例：

#include <stdio.h>
 
/* 全局变量声明 */
int a = 20;
 
int main ()
{
  /* 在主函数中的局部变量声明 */
  int a = 10;
  int b = 20;
  int c = 0;
  int sum(int, int);
 
  printf ("value of a in main() = %dn",  a);
  c = sum( a, b);
  printf ("value of c in main() = %dn",  c);
 
  return 0;
}
 
/* 添加两个整数的函数 */
int sum(int a, int b)
{
    printf ("value of a in sum() = %dn",  a);
    printf ("value of b in sum() = %dn",  b);
 
    return a + b;
}

当上面的代码被编译和执行时，它会产生下列结果：

value of a in main() = 10
value of a in sum() = 10
value of b in sum() = 20
value of c in main() = 30

全局变量与局部变量在内存中的区别：

1. 全局变量保存在内存的全局存储区中，占用静态的存储单元；
2. 局部变量保存在栈中，只有在所在函数被调用时才动态地为变量分配存储单元。

C 数组

C 语言支持数组数据结构，它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。

数组的声明并不是声明一个个单独的变量，比如 runoob0、runoob1、…、runoob99，而是声明一个数组变量，比如 runoob，然后使用 runoob[0]、runoob[1]、…、runoob[99] 来代表一个个单独的变量。

所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。

数组中的特定元素可以通过索引访问，第一个索引值为 0。

声明数组

在 C 中要声明一个数组，需要指定元素的类型和元素的数量，如下所示：

type arrayName [ arraySize ];

这叫做一维数组。arraySize 必须是一个大于零的整数常量，type 可以是任意有效的 C 数据类型。例如，要声明一个类型为 double 的包含 10 个元素的数组 balance，声明语句如下：

double balance[10];

现在 balance 是一个可用的数组，可以容纳 10 个类型为 double 的数字。

初始化数组

在 C 中，可以逐个初始化数组，也可以使用一个初始化语句，如下所示：

double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};

大括号 { } 之间的值的数目不能大于在数组声明时在方括号 [ ] 中指定的元素数目。

**如果省略掉了数组的大小，数组的大小则为初始化时元素的个数。**因此，如果：

double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};

您将创建一个数组，它与前一个实例中所创建的数组是完全相同的。下面是一个为数组中某个元素赋值的实例：

balance[4] = 50.0;

上述的语句把数组中第五个元素的值赋为 50.0。

如果要将整个数组的每一个成员都设置为零，最简单的写法就是下面这样。

int a[100] = {0};

访问数组元素

数组元素可以通过数组名称加索引进行访问。元素的索引是放在方括号内，跟在数组名称的后边。例如：

double salary = balance[9];

获取数组长度

数组长度可以使用 sizeof 运算符来获取数组的长度，例如：

int numbers[] = {1, 2, 3, 4, 5};
int length = sizeof(numbers) / sizeof(numbers[0]);

使用宏定义：

#include <stdio.h>

#define LENGTH(array) (sizeof(array) / sizeof(array[0]))

int main() {
	// int在C里面是32位 4字节
	// sizeof(array) = 20字节
	// sizeof(array[0]) = 4字节
    int array[] = {1, 2, 3, 4, 5};
    int length = LENGTH(array);

    printf("数组长度为: %dn", length);

    return 0;
}

以上实例输出结果为：

数组长度为: 5

数组名

在 C 语言中，数组名表示数组的地址，即数组首元素的地址。当我们在声明和定义一个数组时，该数组名就代表着该数组的地址。

例如，在以下代码中：

int myArray[5] = {10, 20, 30, 40, 50};

在这里，myArray 是数组名，它表示整数类型的数组，包含 5 个元素。myArray 也代表着数组的地址，即第一个元素的地址。

数组名本身是一个常量指针，意味着它的值是不能被改变的，一旦确定，就不能再指向其他地方。

我们可以使用&运算符来获取数组的地址，如下所示：

int myArray[5] = {10, 20, 30, 40, 50};
int *ptr = &myArray[0]; // 或者直接写作 int *ptr = myArray;

在上面的例子中，ptr 指针变量被初始化为 myArray 的地址，即数组的第一个元素的地址。

需要注意的是，虽然数组名表示数组的地址，但在大多数情况下，数组名会自动转换为指向数组首元素的指针。这意味着我们可以直接将数组名用于指针运算，例如在函数传递参数或遍历数组时：

void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]); // 数组名arr被当作指针使用
    }
}

int main() {
    int myArray[5] = {10, 20, 30, 40, 50};
    printArray(myArray, 5); // 将数组名传递给函数
    return 0;
}

注： 以上操作在go里面属于unsafe.

变长数组

数组声明的时候，数组长度除了使用常量，也可以使用变量。这叫做变长数组（variable-length array，简称 VLA）。

int n = x + y;
int arr[n];

上面示例中，数组arr就是变长数组，因为它的长度取决于变量n的值，编译器没法事先确定，只有运行时才能知道n是多少。

变长数组的根本特征，就是数组长度只有运行时才能确定。它的好处是程序员不必在开发时，随意为数组指定一个估计的长度，程序可以在运行时为数组分配精确的长度。

任何长度需要运行时才能确定的数组，都是变长数组。

int i = 10;

int a1[i];
int a2[i + 5];
int a3[i + k];

上面示例中，三个数组的长度都需要运行代码才能知道，编译器并不知道它们的长度，所以它们都是变长数组。

变长数组也可以用于多维数组。

int m = 4;
int n = 5;
int c[m][n];

上面示例中，c[m][n]就是二维变长数组。

数组的复制

由于数组名是指针，所以复制数组不能简单地复制数组名。

int* a;
int b[3] = {1, 2, 3};

a = b;

上面的写法，结果不是将数组b复制给数组a，而是让a和b指向同一个数组。

复制数组最简单的方法，还是使用循环，将数组元素逐个进行复制。

for (i = 0; i < N; i++)
  a[i] = b[i];

上面示例中，通过将数组b的成员逐个复制给数组a，从而实现数组的赋值。

另一种方法是使用memcpy()函数（定义在头文件string.h），直接把数组所在的那一段内存，再复制一份。

memcpy(a, b, sizeof(b));

上面示例中，将数组b所在的那段内存，复制给数组a。这种方法要比循环复制数组成员要快。

C 多维数组

C 语言支持多维数组。多维数组声明的一般形式如下：

type name[size1][size2]...[sizeN];

例如，下面的声明创建了一个三维 5 . 10 . 4 整型数组：

int threedim[5][10][4];

初始化二维数组

多维数组可以通过在括号内为每行指定值来进行初始化。下面是一个带有 3 行 4 列的数组。

int a[3][4] = {  
 {0, 1, 2, 3} ,   /*  初始化索引号为 0 的行 */
 {4, 5, 6, 7} ,   /*  初始化索引号为 1 的行 */
 {8, 9, 10, 11}   /*  初始化索引号为 2 的行 */
};

内部嵌套的括号是可选的，下面的初始化与上面是等同的：

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

但还是建议加上内部嵌套的括号。

C 传递数组给函数

如果想要在函数中传递一个一维数组作为参数，必须以下面三种方式来声明函数形式参数，这三种声明方式的结果是一样的，因为每种方式都会告诉编译器将要接收一个整型指针。同样地，也可以传递一个多维数组作为形式参数。

// 方式1
void myFunction(int *param)
{
.
.
.
}

// 方式2
void myFunction(int param[10])
{
.
.
.
}

// 方式3
void myFunction(int param[])
{
.
.
.
}

现在，让我们来看下面这个函数，它把数组作为参数，同时还传递了另一个参数，根据所传的参数，会返回数组中元素的平均值：

double getAverage(int arr[], int size)
{
  int    i;
  double avg;
  double sum;
 
  for (i = 0; i < size; ++i)
  {
    sum += arr[i];
  }
 
  avg = sum / size;
 
  return avg;
}

下面这个函数，它把数组作为参数，同时还传递了另一个参数，根据所传的参数，会返回数组中元素的平均值：

double getAverage(int arr[], int size)
{
  int    i;
  double avg;
  double sum;
 
  for (i = 0; i < size; ++i)
  {
    sum += arr[i];
  }
 
  avg = sum / size;
 
  return avg;
}

变长数组作为参数

变长数组作为函数参数时，写法略有不同。

int sum_array(int n, int a[n]) {
  // ...
}

int a[] = {3, 5, 7, 3};
int sum = sum_array(4, a);

上面示例中，数组a[n]是一个变长数组，它的长度取决于变量n的值，只有运行时才能知道。所以，变量n作为参数时，顺序一定要在变长数组前面，这样运行时才能确定数组a[n]的长度，否则就会报错。

因为函数原型可以省略参数名，所以变长数组的原型中，可以使用*代替变量名，也可以省略变量名。

int sum_array(int, int [*]);
int sum_array(int, int []);

上面两种变长函数的原型写法，都是合法的。

变长数组作为函数参数有一个好处，就是多维数组的参数声明，可以把后面的维度省掉了。

// 原来的写法
int sum_array(int a[][4], int n);

// 变长数组的写法
int sum_array(int n, int m, int a[n][m]);

上面示例中，函数sum_array()的参数是一个多维数组，按照原来的写法，一定要声明第二维的长度。但是使用变长数组的写法，就不用声明第二维长度了，因为它可以作为参数传入函数。

数组字面量作为参数

C 语言允许将数组字面量作为参数，传入函数。

// 数组变量作为参数
int a[] = {2, 3, 4, 5};
int sum = sum_array(a, 4);

// 数组字面量作为参数
int sum = sum_array((int []){2, 3, 4, 5}, 4);

上面示例中，两种写法是等价的。第二种写法省掉了数组变量的声明，直接将数组字面量传入函数。{2, 3, 4, 5}是数组值的字面量，(int [])类似于强制的类型转换，告诉编译器怎么理解这组值。

C 从函数返回数组

C 语言不允许返回一个完整的数组作为函数的参数。但是，可以通过指定不带索引的数组名来返回一个指向数组的指针。

int * myFunction()
{
.
.
.
}

另外，C 不支持在函数外返回局部变量的地址，除非定义局部变量为 static 变量。

下面的函数，它会生成 10 个随机数，并使用数组来返回它们，具体如下：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
/* 要生成和返回随机数的函数 */
int * getRandom( )
{
  static int  r[10];
  int i;
 
  /* 设置种子 */
  srand( (unsigned)time( NULL ) );
  for ( i = 0; i < 10; ++i)
  {
     r[i] = rand();
     printf( "r[%d] = %dn", i, r[i]);
 
  }
 
  return r;
}
 
/* 要调用上面定义函数的主函数 */
int main ()
{
   /* 一个指向整数的指针 */
   int *p;
   int i;
 
   p = getRandom();
   for ( i = 0; i < 10; i++ )
   {
       printf( "*(p + %d) : %dn", i, *(p + i));
   }
 
   return 0;
}

C 指向数组的指针

数组名本身是一个常量指针，意味着它的值是不能被改变的，一旦确定，就不能再指向其他地方。

因此，在下面的声明中：

double balance[50];

balance 是一个指向 &balance[0] 的指针，即数组 balance 的第一个元素的地址。因此，下面的程序片段把 p 赋值为 balance 的第一个元素的地址：

double *p;
double balance[10];

p = balance;

使用数组名作为常量指针是合法的，反之亦然。因此，*(balance + 4) 是一种访问 balance[4] 数据的合法方式。

一旦把第一个元素的地址存储在 p 中，就可以使用 *p、*(p+1)、*(p+2) 等来访问数组元素。下面的实例演示了上面讨论到的这些概念：

#include <stdio.h>
 
int main ()
{
   /* 带有 5 个元素的整型数组 */
   double balance[5] = {1000.0, 2.0, 3.4, 17.0, 50.0};
   double *p;
   int i;
 
   p = balance;
 
   /* 输出数组中每个元素的值 */
   printf( "使用指针的数组值n");
   for ( i = 0; i < 5; i++ )
   {
       printf("*(p + %d) : %fn",  i, *(p + i) );
   }
 
   printf( "使用 balance 作为地址的数组值n");
   for ( i = 0; i < 5; i++ )
   {
       printf("*(balance + %d) : %fn",  i, *(balance + i) );
   }
 
   return 0;
}

C 语言静态数组与动态数组

在 C 语言中，有两种类型的数组：

1. 静态数组：编译时分配内存，大小固定。
2. 动态数组：运行时手动分配内存，大小可变。

静态数组的生命周期与作用域相关，而动态数组的生命周期由程序员控制。

在使用动态数组时，需要注意合理地分配和释放内存，以避免内存泄漏和访问无效内存的问题。

静态数组

静态数组是在编译时声明并分配内存空间的数组。

静态数组具有固定的大小，在声明数组时需要指定数组的长度。

静态数组的特点包括：

1. 内存分配：在程序编译时，静态数组的内存空间就被分配好了，存储在栈上或者全局数据区。
2. 大小固定：静态数组的大小在声明时确定，并且无法在运行时改变。
3. 生命周期：静态数组的生命周期与其作用域相关。如果在函数内部声明静态数组，其生命周期为整个函数执行期间；如果在函数外部声明静态数组，其生命周期为整个程序的执行期间。

静态数组的声明和初始化示例：

int staticArray[5]; // 静态数组声明
int staticArray[] = {1, 2, 3, 4, 5}; // 静态数组声明并初始化

对于静态数组，可以使用 sizeof 运算符来获取数组长度，例如：

int array[] = {1, 2, 3, 4, 5};
int length = sizeof(array) / sizeof(array[0]);

以上代码中 sizeof(array) 返回整个数组所占用的字节数，而 sizeof(array[0]) 返回数组中单个元素的字节数，将两者相除，就得到了数组的长度。

动态数组

动态数组是在运行时通过动态内存分配函数（如 malloc 和 calloc）手动分配内存的数组。

动态数组特点如下：

1. 内存分配：动态数组的内存空间在运行时通过动态内存分配函数手动分配，并存储在堆上。需要使用 malloc、calloc 等函数来申请内存，并使用 free 函数来释放内存。
2. 大小可变：动态数组的大小在运行时可以根据需要进行调整。可以使用 realloc 函数来重新分配内存，并改变数组的大小。
3. 生命周期：动态数组的生命周期由程序员控制。需要在使用完数组后手动释放内存，以避免内存泄漏。

动态数组的声明、内存分配和释放实例：

int size = 5;
int *dynamicArray = (int *)malloc(size * sizeof(int)); // 动态数组内存分配
// 使用动态数组
free(dynamicArray); // 动态数组内存释放

动态分配的数组，可以在动态分配内存时保存数组长度，并在需要时使用该长度，例如：

int size = 5; // 数组长度
int *array = malloc(size * sizeof(int));

// 使用数组

free(array); // 释放内存

以上代码我们使用 malloc 函数动态分配了一个整型数组，并将长度保存在变量 size 中。然后可以根据需要使用这个长度进行操作，在使用完数组后，使用 free 函数释放内存。

注意：动态数组的使用需要注意内存管理的问题，确保在不再需要使用数组时释放内存，避免内存泄漏和访问无效的内存位置。

#include <stdio.h>
#include <stdlib.h>

int main() {
    int size = 5;
    int *dynamicArray = (int *)malloc(size * sizeof(int)); // 动态数组内存分配

    if (dynamicArray == NULL) {
        printf("Memory allocation failed.n");
        return 1;
    }

    printf("Enter %d elements: ", size);
    for (int i = 0; i < size; i++) {
        scanf("%d", &dynamicArray[i]);
    }

    printf("Dynamic Array: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", dynamicArray[i]);
    }
    printf("n");

    free(dynamicArray); // 动态数组内存释放

    return 0;
}

C enum(枚举)

枚举是 C 语言中的一种基本数据类型，用于定义一组具有离散值的常量，它可以让数据更简洁，更易读。

枚举类型通常用于为程序中的一组相关的常量取名字，以便于程序的可读性和维护性。

定义一个枚举类型，需要使用 enum 关键字，后面跟着枚举类型的名称，以及用大括号 {} 括起来的一组枚举常量。每个枚举常量可以用一个标识符来表示，也可以为它们指定一个整数值，如果没有指定，那么默认从 0 开始递增。

枚举语法定义格式为：

enum　枚举名　{枚举元素1,枚举元素2,……};

比如：一星期有 7 天，如果不用枚举，需要使用 #define 来为每个整数定义一个别名：

#define MON  1
#define TUE  2
#define WED  3
#define THU  4
#define FRI  5
#define SAT  6
#define SUN  7

这个看起来代码量就比较多（我咋感觉不多呢），使用枚举的方式：

enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};

注意：第一个枚举成员的默认值为整型的 0，后续枚举成员的值在前一个成员上加 1。在这个实例中把第一个枚举成员的值定义为 1，第二个就为 2，以此类推。

可以在定义枚举类型时改变枚举元素的值：

enum season {spring, summer=3, autumn, winter};

没有指定值的枚举元素，其值为前一元素加 1。也就说 spring 的值为 0，summer 的值为 3，autumn 的值为 4，winter 的值为 5

枚举变量的定义

前面只是声明了枚举类型，可以通过以下三种方式来定义枚举变量：
1、先定义枚举类型，再定义枚举变量

enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};
enum DAY day;

2、定义枚举类型的同时定义枚举变量

enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;

3、省略枚举名称，直接定义枚举变量

enum
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;

#include <stdio.h>
 
enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};
 
int main()
{
    enum DAY day;
    day = WED;
    printf("%d",day);
    return 0;
}

在C 语言中，枚举类型是被当做 int 或者 unsigned int 类型来处理的，所以按照 C 语言规范是没有办法遍历枚举类型的。

不过在一些特殊的情况下，枚举类型必须连续是可以实现有条件的遍历。（没人会闲的无聊遍历枚举吧）

#include <stdio.h>
 
enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;
int main()
{
    // 遍历枚举元素
    for (day = MON; day <= SUN; day++) {
        printf("枚举元素：%d n", day);
    }
}

由于Enum 会自动编号，因此可以不必为常量赋值。C 语言会自动从0开始递增，为常量赋值。但是，C 语言也允许为 ENUM 常量指定值，不过只能指定为整数，不能是其他类型。因此，任何可以使用整数的场合，都可以使用 Enum 常量。

enum { ONE = 1, TWO = 2 };

printf("%d %d", ONE, TWO);  // 1 2

Enum 常量可以是不连续的值。

enum { X = 2, Y = 18, Z = -2 };

Enum 常量也可以是同一个值。

enum { X = 2, Y = 2, Z = 2 };

如果一组常量之中，有些指定了值，有些没有指定。那么，没有指定值的常量会从上一个指定了值的常量，开始自动递增赋值。 （ Go语言只有iota具有递增的功能，否则const枚举出来的下一个变量与上一个相同）

enum {
  A,    // 0
  B,    // 1
  C = 4,  // 4
  D,    // 5
  E,    // 6
  F = 3,   // 3
  G,    // 4
  H     // 5
};

Enum 的作用域与变量相同。如果是在顶层声明，那么在整个文件内都有效；如果是在代码块内部声明，则只对该代码块有效。如果与使用int声明的常量相比，Enum 的好处是更清晰地表示代码意图。

将整数转换为枚举

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
 
    enum day
    {
        saturday,
        sunday,
        monday,
        tuesday,
        wednesday,
        thursday,
        friday
    } workday;
 
    int a = 1;
    enum day weekend;
    weekend = ( enum day ) a;  //类型转换
    //weekend = a; //错误
    printf("weekend:%d",weekend);
    return 0;
}

对比go和C的枚举形态

在go中可以通过const和iota定义枚举，类型可以使用type定义：

package main

import "fmt"

type Weekend int

const (
	Mon Weekend = iota + 1
	Tues
	Wed
	Thurs
	Fri
	Sat
	Sun
)

func (w Weekend) String() string {
	return fmt.Sprintln("Today is", int(w), ".")
}

func main() {
	week := Mon
	fmt.Println(week)
}

C代码：

#include <stdio.h>

enum Weekend{
    Mon = 1,
    Thus,
    Wed,
    Thurs,
    Fri,
    Sat,
    Sun,
};

int main(void){
    enum Weekend week = Mon;
    printf("Today is %d.",week);
}

C 指针

通过指针，可以简化一些 C 编程任务的执行，还有一些任务，如动态内存分配，没有指针是无法执行的。

每一个变量都有一个内存位置，每一个内存位置都定义了可使用 & 运算符访问的地址，它表示了在内存中的一个地址。

#include <stdio.h>
 
int main ()
{
    int var_runoob = 10;
    int *p;              // 定义指针变量
    p = &var_runoob;
 
   printf("var_runoob 变量的地址： %pn", p);
   return 0;
}

怎么理解*p

我感觉C里面的指针声明很奇怪，*代表它是个指针，那按理说应该是int* ptr才对，int*代表是int类型的指针。

这点在Go里面就体现出来了：var a *int，*和类型是在一起的。

后来反应过来，C里面这样声明可以理解为：对ptr取值（*运算）后是个int.

C 中的 NULL 指针

在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值是一个良好的编程习惯。赋为 NULL 值的指针被称为空指针。

NULL 指针是一个定义在标准库中的值为零的常量。请看下面的程序：

#include <stdio.h>
 
int main ()
{
   int  *ptr = NULL;
 
   printf("ptr 的地址是 %pn", ptr  );
 
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

ptr 的地址是 0x0
在大多数的操作系统上，程序不允许访问地址为 0 的内存，因为该内存是操作系统保留的。然而，内存地址 0 有特别重要的意义，它表明该指针不指向一个可访问的内存位置。但按照惯例，如果指针包含空值（零值），则假定它不指向任何东西。

如需检查一个空指针，您可以使用 if 语句，如下所示：

if(ptr)     /* 如果 p 非空，则完成 */
if(!ptr)    /* 如果 p 为空，则完成 */

C 指针的算术运算

C 指针是一个用数值表示的地址。因此，可以对指针执行算术运算。可以对指针进行四种算术运算：++、–、+、-。

假设 ptr 是一个指向地址 1000 的整型指针，是一个 32 位的整数，让我们对该指针执行下列的算术运算：

ptr++

在执行完上述的运算之后，ptr 将指向位置 1004，因为 ptr 每增加一次，它都将指向下一个整数位置，即当前位置往后移 4 字节。这个运算会在不影响内存位置中实际值的情况下，移动指针到下一个内存位置。如果 ptr 指向一个地址为 1000 的字符，上面的运算会导致指针指向位置 1001，因为下一个字符位置是在 1001。

概括一下：

1. 指针的每一次递增，它其实会指向下一个元素的存储单元。
2. 指针的每一次递减，它都会指向前一个元素的存储单元。
3. 指针在递增和递减时跳跃的字节数取决于指针所指向变量数据类型长度，比如 int 就是 4 个字节。

递增一个指针

在程序中使用指针代替数组，因为变量指针可以递增，而数组不能递增，数组可以看成一个指针常量。下面的程序递增变量指针，以便顺序访问数组中的每一个元素：

#include <stdio.h>
 
const int MAX = 3;
 
int main ()
{
   int  var[] = {10, 100, 200};
   int  i, *ptr;
 
   /* 指针中的数组地址 */
   ptr = var;
   for ( i = 0; i < MAX; i++)
   {
 
      printf("存储地址：var[%d] = %pn", i, ptr );
      printf("存储值：var[%d] = %dn", i, *ptr );
 
      /* 指向下一个位置 */
      ptr++;
   }
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

存储地址：var[0] = e4a298cc
存储值：var[0] = 10
存储地址：var[1] = e4a298d0
存储值：var[1] = 100
存储地址：var[2] = e4a298d4
存储值：var[2] = 200

递减一个指针

同样地，对指针进行递减运算，即把值减去其数据类型的字节数，如下所示：

#include <stdio.h>
 
const int MAX = 3;
 
int main ()
{
   int  var[] = {10, 100, 200};
   int  i, *ptr;
 
   /* 指针中最后一个元素的地址 */
   ptr = &var[MAX-1];
   for ( i = MAX; i > 0; i--)
   {
 
      printf("存储地址：var[%d] = %pn", i-1, ptr );
      printf("存储值：var[%d] = %dn", i-1, *ptr );
 
      /* 指向下一个位置 */
      ptr--;
   }
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

存储地址：var[2] = 518a0ae4
存储值：var[2] = 200
存储地址：var[1] = 518a0ae0
存储值：var[1] = 100
存储地址：var[0] = 518a0adc
存储值：var[0] = 10

指针的比较

指针可以用关系运算符进行比较，如 ==、< 和 >。如果 p1 和 p2 指向两个相关的变量，比如同一个数组中的不同元素，则可对 p1 和 p2 进行大小比较。

下面的程序修改了上面的实例，只要变量指针所指向的地址小于或等于数组的最后一个元素的地址 &var[MAX – 1]，则把变量指针进行递增：

#include <stdio.h>
 
const int MAX = 3;
 
int main ()
{
   int  var[] = {10, 100, 200};
   int  i, *ptr;
 
   /* 指针中第一个元素的地址 */
   ptr = var;
   i = 0;
   while ( ptr <= &var[MAX - 1] )
   {
 
      printf("存储地址：var[%d] = %pn", i, ptr );
      printf("存储值：var[%d] = %dn", i, *ptr );
 
      /* 指向上一个位置 */
      ptr++;
      i++;
   }
   return 0;
}

C 指针数组

C 指针数组是一个数组，其中的每个元素都是指向某种数据类型的指针。

指针数组存储了一组指针，每个指针可以指向不同的数据对象。

指针数组通常用于处理多个数据对象，例如字符串数组或其他复杂数据结构的数组。

#include <stdio.h>
 
const int MAX = 3;
 
int main ()
{
   int  var[] = {10, 100, 200};
   int i;
 
   for (i = 0; i < MAX; i++)
   {
      printf("Value of var[%d] = %dn", i, var[i] );
   }
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Value of var[0] = 10
Value of var[1] = 100
Value of var[2] = 200

可能有一种情况，我们想要让数组存储指向 int 或 char 或其他数据类型的指针。

下面是一个指向整数的指针数组的声明：

int *ptr[MAX];

在这里，把 ptr 声明为一个数组，由 MAX 个整数指针组成。因此，ptr 中的每个元素，都是一个指向 int 值的指针。下面的实例用到了三个整数，它们将存储在一个指针数组中，如下所示：

#include <stdio.h>
 
const int MAX = 3;
 
int main ()
{
   int  var[] = {10, 100, 200};
   int i, *ptr[MAX];
 
   for ( i = 0; i < MAX; i++)
   {
      ptr[i] = &var[i]; /* 赋值为整数的地址 */
   }
   for ( i = 0; i < MAX; i++)
   {
      printf("Value of var[%d] = %dn", i, *ptr[i] );
   }
   return 0;
}