快速掌握C｜Day 1

本篇记录关于 菜鸟教程 中的C语言教程的学习笔记

第一个程序

#include <stdio.h>  // 预处理器指令，告诉 C 编译器在实际编译之前要包含 stdio.h 文件

int main()  // 主函数，程序从这里开始执行
{
	/* my first c program */  
	// /*...*/ 将会被编译器忽略，这里放置程序的注释内容。它们被称为程序的注释
	printf("Hello, world! \n");
	return 0; //终止 main() 函数，并返回值 0
}

实例解析

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

优点：

1. 易于学习。
2. 结构化语言。
3. 它产生高效率的程序。
4. 它可以处理底层的活动。
5. 它可以在多种计算机平台上编译。

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

先用在线编译器好啦

C基本语法

C的令牌（token）

C 程序由各种令牌组成，令牌可以是关键字、标识符、常量、字符串值，或者是一个符号。

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

1. //单行注释
2. /* */这种格式的注释可以单行或多行

// 单行注释
/* 单行注释 */
/* 
 多行注释
 多行注释
 多行注释
 */

不能在注释内嵌套注释，注释也不能出现在字符串或字符值中。

• 标识符
  C 标识符是用来标识变量、函数，或任何其他用户自定义项目的名称。一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）。
  C 标识符内不允许出现标点字符，比如 @、$ 和 %。C 是区分大小写的编程语言。因此，在 C 中，Manpower 和 manpower 是两个不同的标识符。

• 关键字
  C 中的保留字 这些保留字不能作为常量名、变量名或其他标识符名称
  
  
  
  

• C 中的空格
  只包含空格的行，被称为空白行，可能带有注释，C 编译器会完全忽略它。
  在 C 中，空格用于描述空白符、制表符、换行符和注释。空格分隔语句的各个部分，让编译器能识别语句中的某个元素（比如 int）在哪里结束，下一个元素在哪里开始。

C数据类型

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

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

1. 基本类型——整数类型和浮点类型

• 整数类型
  
  注意，各种类型的存储大小与系统位数有关，但目前通用的以64位系统为主。
  以下列出了32位系统与64位系统的存储大小的差别（windows 相同）：
  
  为了得到某个类型或某个变量在特定平台上的准确大小，可以使用 sizeof 运算符。表达式 sizeof(type) 得到对象或类型的存储字节大小。

#include <stdio.h>
#include <limits.h>

int main()
{
	printf("int 存储大小：%lu \n", sizeof(int));
	return 0;
}

%lu 为 32 位无符号整数

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

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

int main()
{
	printf("float 存储最大字节数：%lu \n", sizeof(float));
	printf("float 最小值: %E\n", FLT_MIN );
   	printf("float 最大值: %E\n", FLT_MAX );
   	printf("精度值: %d\n", FLT_DIG );
	return 0;
}

// 运行结果
float 存储最大字节数：4 
float 最小值: 1.175494E-38
float 最大值: 3.402823E+38
精度值: 6

%E 为以指数形式输出单、双精度实数

void 类型

指针指向 void 最难理解

C变量

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

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

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

// type variable_list
int i, j, k; // 声明并定义了变量 i、j 和 k，这指示编译器创建类型为 int 的名为 i、j、k 的变量。
char c, ch;
float f, salary;
doubled d;

// 变量可以在声明的时候被初始化（指定一个初始值）。
// 初始化器由一个等号，后跟一个常量表达式组成
// type variable_name = value;
extern int d = 3, f = 5;  // d 和 f 的声明与初始化，而非定义，即没有建立存储空间
int d = 3, f = 5;  // 定义并初始化 d 和 f
byte z = 22;
char x = 'x';

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

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

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

实例：

#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;
}

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

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

test.c 文件代码：

#include <stdio.h> 
/*定义两个全局变量*/
int x=1;
int y=2;
int addtwonum();
int main(void)
{
    int result;
    result = addtwonum();
    printf("result 为: %d\n",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;

C常量

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

• 整数常量
  整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。
  整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意

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

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

• 浮点常量
  浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。
  当使用小数形式表示时，必须包含整数部分、小数部分，或同时包含两者。当使用指数形式表示时， 必须包含小数点、指数，或同时包含两者。带符号的指数是用 e 或 E 引入的。

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

• 字符常量
  字符常量括在单引号中，例如，‘x’ 可以存储在 char 类型的简单变量中。
  字符常量可以是一个普通的字符（例如 ‘x’）、一个转义序列（例如 ‘\t’），或一个通用的字符（例如 ‘\u02C0’）。
  在 C 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，被用来表示如换行符（\n）或制表符（\t）等。下表列出了一些这样的转义序列码：
  

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

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

1. 使用 #define 预处理器。

// #define identifier value
#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;
}

2. 使用 const 关键字。

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

请注意，把常量定义为大写字母形式，是一个很好的编程习惯。

C存储类

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

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

{
   int mount;
   auto int month;
}

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

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

{
   register int  miles;
}

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

• 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 为 %d\n", thingy, count);
}

结果为

 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

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

• 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 %d\n", count); // count is 5
}

在这里，第二个文件中的 extern 关键字用于声明已经在第一个文件 main.c 中定义的 count

• 这里互相调用看着好乱