C语言快速入门

C 基本语法

关键字

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

关键字	说明
auto	声明自动变量
break	跳出当前循环
case	开关语句分支
char	声明字符型变量或函数返回值类型
const	定义常量，如果一个变量被 const 修饰，那么它的值就不能再被改变
continue	结束当前循环，开始下一轮循环
default	开关语句中的”其它”分支
do	循环语句的循环体
double	声明双精度浮点型变量或函数返回值类型
else	条件语句否定分支（与 if 连用）
enum	声明枚举类型
extern	声明变量或函数是在其它文件或本文件的其他位置定义
float	声明浮点型变量或函数返回值类型
for	一种循环语句
goto	无条件跳转语句
if	条件语句
int	声明整型变量或函数返回值类型
long	声明长整型变量或函数返回值类型
register	声明寄存器变量
return	子程序返回语句（可以带参数，也可不带参数）
short	声明短整型变量或函数返回值类型
signed	声明有符号类型变量或函数返回值类型
sizeof	计算数据类型或变量长度（即所占字节数）
static	声明静态变量
struct	声明结构体类型
switch	用于开关语句
typedef	用以给数据类型取别名
unsigned	声明无符号类型变量或函数返回值类型
union	声明共用体类型
void	声明函数无返回值或无参数，声明无类型指针
volatile	说明变量在程序执行中可被隐含地改变
while	循环语句的循环条件

C 数据类型

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

序号	类型与描述
1	基本类型：它们是算术类型，包括两种类型：整数类型和浮点类型。
2	枚举类型：它们也是算术类型，被用来定义在程序中只能赋予其一定的离散整数值的变量。
3	void 类型：类型说明符 void 表明没有可用的值。
4	派生类型：它们包括：指针类型、数组类型、结构类型、共用体类型和函数类型。

整数类型

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

类型	存储大小	值范围
char	1 字节	-128 到 127 或 0 到 255
unsigned char	1 字节	0 到 255
signed char	1 字节	-128 到 127
int	2 或 4 字节	-32,768 到 32,767 或 -2,147,483,648 到 2,147,483,647
unsigned int	2 或 4 字节	0 到 65,535 或 0 到 4,294,967,295
short	2 字节	-32,768 到 32,767
unsigned short	2字节	0 到 65,535
long	4 字节	-2,147,483,648 到 2,147,483,647
unsigned long	4 字节	0 到 4,294,967,295

浮点类型

下表列出了关于标准浮点类型的存储大小、值范围和精度的细节：

类型	存储大小	值范围	精度
float	4 字节	1.2E-38 到 3.4E+38	6 位有效位
double	8 字节	2.3E-308 到 1.7E+308	15 位有效位
long double	16 字节	3.4E-4932 到 1.1E+4932	19 位有效位

void 类型

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

序号	类型与描述
1	函数返回为空: C 中有各种函数都不返回值，或者您可以说它们返回空。不返回值的函数的返回类型为空。例如 void exit (int status);
2	函数参数为空: C 中有各种函数不接受任何参数。不带参数的函数可以接受一个 void。例如 int rand(void);
3	指针指向 void: 类型为 void * 的指针代表对象的地址，而不是类型。例如，内存分配函数 void *malloc( size_t size ); 返回指向 void 的指针，可以转换为任何数据类型。

C 变量

变量其实只不过是程序可操作的存储区的名称。C 中每个变量都有特定的类型，类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中，运算符可应用于变量上。
变量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大写字母和小写字母是不同的，因为 C 是大小写敏感的。基于前一章讲解的基本类型，有以下几种基本的变量类型：

序号	描述
char	通常是一个字节（八位）, 这是一个整数类型。
int	整型，4 个字节，取值范围 -2147483648 到 2147483647。
float	单精度浮点值。单精度是1位符号，8位指数，23位小数。
double	双精度浮点值。双精度是1位符号，11位指数，52位小数。
void	表示类型的缺失。

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

C 中的变量定义

不带初始化的定义：带有静态存储持续时间的变量会被隐式初始化为 NULL（所有字节的值都是 0），其他所有变量的初始值是未定义的。

C 中的变量声明

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

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

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

  C 中有两种类型的表达式：
• 左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。
• 右值（rvalue）：术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。
  变量是左值，因此可以出现在赋值号的左边。数值型的字面值是右值，因此不能被赋值，不能出现在赋值号的左边。

  C 常量

  常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面量。
  常量可以是任何的基本数据类型，比如整数常量、浮点常量、字符常量，或字符串字面值，也有枚举常量。
  常量就像是常规的变量，只不过常量的值在定义后不能进行修改。

  定义常量

  在 C 中，有两种简单的定义常量的方式：
• 使用 #define 预处理器。
• 使用 const 关键字。

  C 储存类

  存储类定义 C 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。下面列出 C 程序中可用的存储类：
• auto
• register
• static
• extern

  auto 存储类

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

  register 存储类

  register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个字），且不能对它应用一元的 ‘&’ 运算符（因为它没有内存位置）。
  寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 ‘register’ 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。
• 寄存器：寄存器的功能是存储二进制代码，它是由具有存储功能的触发器组合起来构成的。寄存器是CPU内部用来存放数据的一些小型存储区域，用来暂时存放参与运算的数据和运算结果。其实寄存器就是一种常用的时序逻辑电路，但这种时序逻辑电路只包含存储电路。
• RAM：随机存取存储器（英语：Random Access Memory，缩写：RAM），也叫主存，是与CPU直接交换数据的内部存储器。它可以随时读写（刷新时除外），而且速度很快，通常作为操作系统或其他正在运行中的程序的临时数据存储介质。RAM工作时可以随时从任何一个指定的地址写入（存入）或读出（取出）信息。它与ROM的最大区别是数据的易失性，即一旦断电所存储的数据将随之丢失。RAM在计算机和数字系统中用来暂时存储程序、数据和中间结果。
• ROM：只读存储器（Read-Only Memory，ROM）以非破坏性读出方式工作，只能读出无法写入信息。信息一旦写入后就固定下来，即使切断电源，信息也不会丢失，所以又称为固定存储器。ROM所存数据通常是装入整机前写入的，整机工作过程中只能读出，不像随机存储器能快速方便地改写存储内容。ROM所存数据稳定 ，断电后所存数据也不会改变，并且结构较简单，使用方便，因而常用于存储各种固定程序和数据。

  static 存储类

  static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。
  static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。
  全局声明的一个 static 变量或方法可以被任何函数或方法调用，只要这些方法出现在跟 static 变量或方法同一个文件中。

  extern 存储类

  extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 extern 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。
  当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。
  extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候。

  C 运算符

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

  杂项运算符

  运算符	描述	实例
  sizeof()	返回变量的大小	sizeof(a) 将返回 4，其中 a 是整数
  &	返回变量的地址	&a; 将给出变量的实际地址
  *	指向一个变量	*a; 将指向一个变量
  ?	条件表达式	如果条件为真 ? 则值为 X : 否则值为 Y

  C 判断

  判断结构要求程序员指定一个或多个要评估或测试的条件，以及条件为真时要执行的语句（必需的）和条件为假时要执行的语句（可选的）。
  C 语言把任何非零和非空的值假定为 true，把零或 null 假定为 false。

  C 循环

  有的时候，我们可能需要多次执行同一块代码。一般情况下，语句是按顺序执行的：函数中的第一个语句先执行，接着是第二个语句，依此类推。
  编程语言提供了更为复杂执行路径的多种控制结构。循环语句允许我们多次执行一个语句或语句组。

  C 函数

  函数是一组一起执行一个任务的语句。每个 C 程序都至少有一个函数，即主函数 main() ，所有简单的程序都可以定义其他额外的函数。
  您可以把代码划分到不同的函数中。如何划分代码到不同的函数中是由您来决定的，但在逻辑上，划分通常是根据每个函数执行一个特定的任务来进行的。
  函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。
  C 标准库提供了大量的程序可以调用的内置函数。例如，函数 strcat() 用来连接两个字符串，函数 memcpy() 用来复制内存到另一个位置。
  函数还有很多叫法，比如方法、子例程或程序，等等。

  函数声明

  函数声明会告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。
  当您在一个源文件中定义函数且在另一个文件中调用函数时，函数声明是必需的。在这种情况下，您应该在调用函数的文件顶部声明函数。

  C 作用域规则

  任何一种编程中，作用域是程序中定义的变量所存在的区域，超过该区域变量就不能被访问。C 语言中有三个地方可以声明变量：
• 在函数或块内部的局部变量
• 在所有函数外部的全局变量
• 在形式参数的函数参数定义中

  局部变量

  在某个函数或块的内部声明的变量称为局部变量。它们只能被该函数或该代码块内部的语句使用。局部变量在函数外部是不可知的。

  全局变量

  全局变量是定义在函数外部，通常是在程序的顶部。全局变量在整个程序生命周期内都是有效的，在任意的函数内部能访问全局变量。
  全局变量可以被任何函数访问。也就是说，全局变量在声明后整个程序中都是可用的。
  在程序中，局部变量和全局变量的名称可以相同，但是在函数内，如果两个名字相同，会使用局部变量值，全局变量不会被使用。

  形式参数

  函数的参数，形式参数，被当作该函数内的局部变量，如果与全局变量同名它们会优先使用。

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

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

  C 数组

  C 语言支持数组数据结构，它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。
  所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。

  C enum(枚举)

  枚举是 C 语言中的一种基本数据类型，它可以让数据更简洁，更易读。

  C 指针

  

  什么是指针？

  指针也就是内存地址，指针变量是用来存放内存地址的变量。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。
  所有实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，对应指针的值的类型都是一样的，都是一个代表内存地址的长的十六进制数。
  不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。

  如何使用指针？

  使用指针时会频繁进行以下几个操作：定义一个指针变量、把变量地址赋值给指针、访问指针变量中可用地址的值。这些是通过使用一元运算符 * 来返回位于操作数所指定地址的变量的值。

  #include <stdio.h>
   
  int main ()
  {
     int  var = 20;   /* 实际变量的声明 */
     int  *ip;        /* 指针变量的声明 */
   
     ip = &var;  /* 在指针变量中存储 var 的地址 */
   
     printf("var 变量的地址: %p\n", &var  );
   
     /* 在指针变量中存储的地址 */
     printf("ip 变量存储的地址: %p\n", ip );
   
     /* 使用指针访问值 */
     printf("*ip 变量的值: %d\n", *ip );
   
     return 0;
  }
  ------------------------------------------------------------
  var 变量的地址: 0x7ffeeef168d8
  ip 变量存储的地址: 0x7ffeeef168d8
  *ip 变量的值: 20

  C 中的 NULL 指针

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

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

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

  函数指针

  函数指针是指向函数的指针变量。
  通常我们说的指针变量是指向一个整型、字符型或数组等变量，而函数指针是指向函数。
  函数指针可以像一般函数一样，用于调用函数、传递参数。
  函数指针变量的声明：

  typedef int (*fun_ptr)(int,int); // 声明一个指向同样参数、返回值的函数指针类型

  实例：

  #include <stdio.h>
   
  int max(int x, int y)
  {
      return x > y ? x : y;
  }
   
  int main(void)
  {
      /* p 是函数指针 */
      int (* p)(int, int) = & max; // &可以省略
      int a, b, c, d;
   
      printf("请输入三个数字:");
      scanf("%d %d %d", & a, & b, & c);
   
      /* 与直接调用函数等价，d = max(max(a, b), c) */
      d = p(p(a, b), c); 
   
      printf("最大的数字是: %d\n", d);
   
      return 0;
  }
  ------------------------------------------------------------
  请输入三个数字:1 2 3
  最大的数字是: 3

  回调函数

  函数指针作为某个函数的参数。
  函数指针变量可以作为某个函数的参数来使用的，回调函数就是一个通过函数指针调用的函数。
  简单讲：回调函数是由别人的函数执行时调用你实现的函数。

  C 字符串

  在 C 语言中，字符串实际上是使用空字符 \0 结尾的一维字符数组。因此，\0 是用于标记字符串的结束。
  空字符（Null character）又称结束符，缩写 NUL，是一个数值为 0 的控制字符，\0 是转义字符，意思是告诉编译器，这不是字符 0，而是空字符。

  C 结构体

  C 数组允许定义可存储相同类型数据项的变量，结构是 C 编程中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。

  指向结构的指针

  您可以定义指向结构的指针，方式与定义指向其他类型变量的指针相似，如下所示：

  struct Books *struct_pointer;

  现在，您可以在上述定义的指针变量中存储结构变量的地址。为了查找结构变量的地址，请把 & 运算符放在结构名称的前面，如下所示：

  struct_pointer = &Book1;

  为了使用指向该结构的指针访问结构的成员，您必须使用 -> 运算符，如下所示：

  struct_pointer->title;

  C 共用体

  共用体是一种特殊的数据类型，允许您在相同的内存位置存储不同的数据类型。您可以定义一个带有多成员的共用体，但是任何时候只能有一个成员带有值。共用体提供了一种使用相同的内存位置的有效方式。

  定义共用体

  为了定义共用体，您必须使用 union 语句，方式与定义结构类似。union 语句定义了一个新的数据类型，带有多个成员。union 语句的格式如下：

  union [union tag]
  {
     member definition;
     member definition;
     ...
     member definition;
  } [one or more union variables];

  union tag 是可选的，每个 member definition 是标准的变量定义，比如 int i; 或者 float f; 或者其他有效的变量定义。在共用体定义的末尾，最后一个分号之前，您可以指定一个或多个共用体变量，这是可选的。

  union Data
  {
     int i;
     float f;
     char  str[20];
  } data;

  现在，Data 类型的变量可以存储一个整数、一个浮点数，或者一个字符串。这意味着一个变量（相同的内存位置）可以存储多个多种类型的数据。您可以根据需要在一个共用体内使用任何内置的或者用户自定义的数据类型。
  共用体占用的内存应足够存储共用体中最大的成员。例如，在上面的实例中，Data 将占用 20 个字节的内存空间，因为在各个成员中，字符串所占用的空间是最大的。

  访问共用体成员

  为了访问共用体的成员，我们使用成员访问运算符（.）。成员访问运算符是共用体变量名称和我们要访问的共用体成员之间的一个句号。您可以使用 union 关键字来定义共用体类型的变量。

  #include <stdio.h>
  #include <string.h>
   
  union Data
  {
     int i;
     float f;
     char  str[20];
  };
   
  int main( )
  {
     union Data data;        
   
     data.i = 10;
     data.f = 220.5;
     strcpy( data.str, "C Programming");
   
     printf( "data.i : %d\n", data.i);
     printf( "data.f : %f\n", data.f);
     printf( "data.str : %s\n", data.str);
   
     return 0;
  }
  ------------------------------------------------------------
  data.i : 1917853763
  data.f : 4122360580327794860452759994368.000000
  data.str : C Programming

  在这里，我们可以看到共用体的 i 和 f 成员的值有损坏，因为最后赋给变量的值占用了内存位置，这也是 str 成员能够完好输出的原因。现在让我们再来看一个相同的实例，这次我们在同一时间只使用一个变量，这也演示了使用共用体的主要目的：

  #include <stdio.h>
  #include <string.h>
   
  union Data
  {
     int i;
     float f;
     char  str[20];
  };
   
  int main( )
  {
     union Data data;        
   
     data.i = 10;
     printf( "data.i : %d\n", data.i);
     
     data.f = 220.5;
     printf( "data.f : %f\n", data.f);
     
     strcpy( data.str, "C Programming");
     printf( "data.str : %s\n", data.str);
   
     return 0;
  }
  ------------------------------------------------------------
  data.i : 10
  data.f : 220.500000
  data.str : C Programming

  C 位域

  如果程序的结构中包含多个开关量，只有 TRUE/FALSE 变量，如下：

  struct
  {
    unsigned int widthValidated;
    unsigned int heightValidated;
  } status;

  这种结构需要 8 字节的内存空间，但在实际上，在每个变量中，我们只存储 0 或 1。在这种情况下，C 语言提供了一种更好的利用内存空间的方式。如果您在结构内使用这样的变量，您可以定义变量的宽度来告诉编译器，您将只使用这些字节。例如，上面的结构可以重写成：

  struct
  {
    unsigned int widthValidated : 1;
    unsigned int heightValidated : 1;
  } status;

  现在，上面的结构中，status 变量将占用 4 个字节的内存空间，但是只有 2 位被用来存储值。如果您用了 32 个变量，每一个变量宽度为 1 位，那么 status 结构将使用 4 个字节，但只要您再多用一个变量，如果使用了 33 个变量，那么它将分配内存的下一段来存储第 33 个变量，这个时候就开始使用 8 个字节。

  位域声明

  有些信息在存储时，并不需要占用一个完整的字节，而只需占几个或一个二进制位。例如在存放一个开关量时，只有 0 和 1 两种状态，用 1 位二进位即可。为了节省存储空间，并使处理简便，C 语言又提供了一种数据结构，称为”位域”或”位段”。
  所谓”位域”是把一个字节中的二进位划分为几个不同的区域，并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。这样就可以把几个不同的对象用一个字节的二进制位域来表示。
  典型的实例：
• 用 1 位二进位存放一个开关量时，只有 0 和 1 两种状态。
• 读取外部文件格式——可以读取非标准的文件格式。例如：9 位的整数。

  位域的定义和位域变量的说明

  位域定义与结构定义相仿，其形式为：

  struct 位域结构名 
  {
   位域列表
  };

  其中位域列表的形式为：

  type [member_name] : width ;

  下面是有关位域中变量元素的描述：

元素	描述
type	只能为 int(整型)，unsigned int(无符号整型)，signed int(有符号整型) 三种类型，决定了如何解释位域的值。
member_name	位域的名称。
width	位域中位的数量。宽度必须小于或等于指定类型的位宽度。

带有预定义宽度的变量被称为位域。位域可以存储多于 1 位的数，例如，需要一个变量来存储从 0 到 7 的值，您可以定义一个宽度为 3 位的位域，如下：

struct
{
  unsigned int age : 3;
} Age;

C typedef

C 语言提供了 typedef 关键字，您可以使用它来为类型取一个新的名字。下面的实例为单字节数字定义了一个术语 BYTE：

typedef unsigned char BYTE;

在这个类型定义之后，标识符 BYTE 可作为类型 unsigned char 的缩写，例如：

BYTE  b1, b2;

*是申明时标记是指针变量

typedef vs #define

#define 是 C 指令，用于为各种数据类型定义别名，与 typedef 类似，但是它们有以下几点不同：

• typedef 仅限于为类型定义符号名称，#define 不仅可以为类型定义别名，也能为数值定义别名，比如您可以定义 1 为 ONE。
• typedef 是由编译器执行解释的，#define 语句是由预编译器进行处理的。

  C 输入 & 输出

  当我们提到输入时，这意味着要向程序填充一些数据。输入可以是以文件的形式或从命令行中进行。C 语言提供了一系列内置的函数来读取给定的输入，并根据需要填充到程序中。
  当我们提到输出时，这意味着要在屏幕上、打印机上或任意文件中显示一些数据。C 语言提供了一系列内置的函数来输出数据到计算机屏幕上和保存数据到文本文件或二进制文件中。