C 语言笔记

第一次：2023-7-28 ~ 2023-8-27

第二次：2023-8-27 ~ 2023-9-7

第三次：2023-10-19 ~ 2023-12-16

吐槽一下，当时我还这么认真的做笔记……，还整理了这么多次

C 简介

C 语言是一种通用的高级语言

几乎所有的 UNIX 应用程序都是用 C 语言编写的

C 语言是所有编程语言的母语，大多数编译器等都是由 C 语言编写而成的，并且大多遵循 C 语言的语法。如C++，java，c#等

由于 C 语言所产生的代码运行速度与汇编语言编写的代码运行速度几乎一样，所以采用 C 语言作为系统开发语言

通过编辑器创建的文件通常称为源文件，源文件包含程序源代码。C 程序的源文件通常使用扩展名 .c。

可以使用 "vi"、"vim" 或任何其他文本编辑器来编写您的 C 语言程序。

最常用的免费可用的编译器是 GNU 的 C/C++ 编译器（gcc）

计算机思维 ：枚举法、二分法 等等

程序设计的三种基础思想：顺序执行、选择执行(判断）、循环执行 (顺序结构，分支结构，循环结构）

C 语言

• 作为系统编程语言可以编写底层（系统内核，驱动等）；

• 作为程序语言是过程语言（即要一步步写下解决问题的步骤）；

• 作为结构化编程语言（创造函数，将程序模块化）；

• 作为中级编程语言(既支持低层次语言(可转化为汇编代码(机器语言)),又有高级语言的特性)

注：编译语言c++与解释语言java（可类比）

编译型语言相当于提前把你的中国话翻译成一本英语书，你下次运行程序就不要源码了，直接对着英语书就好了。但是换个德国人（换个平台）就看不懂英语书了。

解释型语言相当于个多国翻译官，但是他不给你写书，每次只帮你一句一句翻译，源码不能丢，运行效率低。

面向过程编程与面向对象编程是两种不同的编程范式，它们之间的主要区别在于对待数据和功能的方式。

面向过程编程：
以过程或者函数为中心，按照顺序执行代码。数据和功能分离，通过传递参数来操作数据。
程序由一系列的函数组成，每个函数实现特定的功能。不容易复用和扩展，难以应对复杂的问题。

面向对象编程：
以对象为中心，将数据和功能封装在对象内部，通过对象之间的交互来完成任务。封装、继承、多态是面向对象编程的三大特性。
可以更好地模拟现实世界的情况，提高了代码的可维护性、可重用性和可扩展性。面向对象编程更加符合人类的思维方式，能够更好地表达问题的本质。

总的来说，面向过程和面向对象的区别在于对待数据和功能的方式，面向对象更加注重数据的封装和抽象，以及对象之间的交互，而面向过程更加注重函数的顺序执行和数据的操作。

C 程序结构

C 程序结构

主要包括以下部分：

• 预处理器指令 如：#include <stdio.h>
• 函数
• 变量
• 语句 & 表达式
• 注释

编译 & 执行 C 程序

使用命令行来编译 & 执行 C 程序：

保存文件为 hello.c，进入到保存文件所在的目录，进入到保存文件所在的目录，键入 gcc hello.c，输入回车，编译代码（Windows 生成 a.exe） 可执行文件。键入 a.out 来执行程序

$ gcc hello.c$ ./a.outHello, World!

如果是多个 c 代码的源码文件，编译方法如下：

$ gcc test1.c test2.c -o main.out$ ./main.out

C 基本语法

C 的语句结构

printf("Hello, World! \n");

如上，一个 C 语句包含五个结构

• printf
• (
• "Hello,World! \n"
• )
• ;

分号 ;

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

注释 // /**/

C 语言有两种注释方式：

// 单行注释

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

//后或/* */中的内容是无用的或是注释

标识符

自己给变量、函数、结构等创造的名称叫标识符，其不能等于保留字

命名规则：字母/数字/下划线；其中首字母不能为数字；尽量不超过 31 个字符；要区分大小写；最好有意义

//下面列出几个有效的标识符：mohd       zara    abc   move_name  a_123myname50   _temp   j     a23b9      retVal

关键字（保留字）

保留字不能作为标识符名称。

像是printf等是在 C 语言的标准库函数之一，是个函数

C99 新增关键字

C11 新增关键字

C 中的空格

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

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

int age;

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

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

上文的所有空格字符不是必需的，但是为了增强可读性，您可以根据需要适当增加一些空格。

C 数据类型

用于定义小房子的类型与大小

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

数组类型+结构类型=聚合类型
函数类型=函数返回值的类型

整数类型（整型）

64 位系统中，int 和 long 的范围是一样的

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

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

为了得到某个类型或某个变量在特定平台上的准确大小，可以使用 sizeof 运算符。使用 sizeof(类型) 得到对象或类型的存储字节大小。

//%lu 为 32 位无符号整数printf("int 存储大小 : %lu \n", sizeof(int));

//输出：int 存储大小 : 4

short和long

short 和 long 用于表示较大的数字与较较大的数字

long a;      	/*储存大整数*/    |    short d;  /*储存小整数*/long long b;  	/*储存大整数*/	 |long double c; 	/*储存浮点数*/	 |

signed和unsigned

signed 和 unsigned （有符号的（整数，正数也可以有加号） 和 没符号的（非负数））

unsigned int x;

浮点类型

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

#include <stdio.h>#include <float.h> //%E 为以指数形式输出单、双精度实数printf("float 存储最大字节数 : %lu \n", sizeof(float));printf("float 最小值: %E\n", FLT_MIN );printf("float 最大值: %E\n", FLT_MAX );printf("精度值: %d\n", FLT_DIG );

//输出：float 存储最大字节数 : 4float 最小值: 1.175494E-38float 最大值: 3.402823E+38精度值: 6

void 类型

英文：空白，这里指无类型或空类型（空值）

类型转换

就是改变数据类型，同时也改变值

• **隐式类型转换：**在表达式中自动发生的，常将较小类型转换为较大类型
• **显式类型转换：**使用强制类型转换运算符(类型名称)，

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

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

C 变量

变量：保存可改变的数据的小房子（容器）

变量属于标识符，和它的命名规则一样

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

C 定义变量

用于告诉编译器在何处如何创建小房子

类型 变量名,变量名;		// 类型可以是自己定义的结构呀等对象

实例：

int age;float salary;char grade;int *ptr;int i, j, k;

初始化变量

赋予变量初始值

类型 变量名=值;

实例：

int x = 10;float pi = 3.14;char ch = 'A';// d 和 f 的声明与初始化// 这里是声明有d和f在内存中，但定义在别的文件中extern int d = 3, f = 5;// 定义并初始化 d 和 fint d = 3, f = 5;// 定义并初始化 zbyte z = 22;

给变量赋值：

类型 变量名;    // 定义变量变量名=值;    	// 赋值变量

实例：

float pi;pi = 3.14159;

建议定义局部变量时初始化，因为它没定义前可能包含内存中任意垃圾值

但全局变量或静态变量自带默认初始值，为 0 （0 / 0.0 / '\0' / NULL）

C 声明变量

就是告诉编译器变量以存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。

变量的声明有两种情况：

• 同时声明与定义 int a; (要建立存储空间)

• 通过 extern 只声明 extern int a (不用建立存储空间) 其中变量 a 可以在别的文件中定义的。

  就是没有 extern 都是第一种类型

extern int i; 	//声明不定义int i; 			//声明并定义

实例：

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

//输出：ans 为: 3

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

//add.c 文件代码#include <stdio.h>/*外部变量声明*/extern int x ;extern int y ;int add(){    return x+y;}

//test.c 文件代码#include <stdio.h> /*定义两个全局变量*/int x=1;int y=2;int add();int main(void){    int result;    result = add();    printf("result 为: %d\n",ans);    return 0;}

# 编译：$ gcc addtwonum.c test.c -o main$ ./main# 输出：ans 为: 3

若这两个文件在同一个项目中，编辑器会自动将整个项目编译在一起

C 中的左值和右值

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

1. **左值（lvalue）：**变量 （可被修改的值）
2. **右值（rvalue）：**字面量 （不可被修改的值）

int g;g = 20;		// √ 10 = 20;	// ×

C 常量

常量：不能更改的量，是固定值，在程序执行期间不会改变，也不能进行修改。

这些固定的值，又叫做字面量。
字面量：小房子里的的数，也可直接使用（如1、2.5、'c' ）

• 整数： 十进制: 0, -9, 22

• 八进制: 021, 077, 033 （八进制以 0 开头）

• 十六进制: 0x7f, 0x2a, 0x521 （十六进制以 0x 开头）

• 浮点数：小数或科学计数法的数（如-2.0、-0.22E-5）

注：E-5 = 10-5

• 字符：ascii 字符，要在单引号内（如：'a'、'2'）

• 转义序列：不能通过键盘输入的或有特殊含义的字符（如问号，制表符）

• 字符串字面量（字符串）：用双引号括起来的（如"good"）

int number = 42;			//42是一个整数字面量double pi = 3.14;			//3.14是一个浮点数字面量char letter = 'A';			//'A'是一个字符字面量String greeting = "Hello";	//"Hello"是一个字符串字面量boolean flag = true;		//true是一个布尔字面量Object obj = null;			//null是一个空字面量

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

整数常量 int

（integer 整数) 用以声明一个或多个整数变量 输出整数%d

整数常量可以是十进制、八进制或十六进制的常量。

前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制，当输出时可能不会默认带前缀。

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

实例：

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

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

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

int myInt = 10;long myLong = 100000L;unsigned int myUnsignedInt = 10U; cout<<myInt<<"\n"<<myLong<<"\n"<<myUnsignedInt;// 输出：// 10// 100000// 10

浮点常量 float 和 double

（float 单精度浮点数）（double float 双精度浮点数）（float 浮动 ==> 浮点数，即小数） 输出小数%f 用%lf来输出双精度小数（lf=long float)

用于保存实数与小数

实例：

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

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

float myFloat = 3.14f;double myDouble = 3.14159;

注：常量不是数组，数组是派生类型

字符常量 char

声明字符类型（character 字符）

字符常量可以是：一个普通的 ascii 字符，要在单引号内（例如 'x'）；一个转义序列（例如 '\t'）；或一个通用的字符（例如 '\u02C0'）。

反斜杠\用于打出特殊字符或本身有意义的字符

转义序列：不能通过键盘输入的或有特殊含义的字符（如问号，制表符）

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

#include <stdio.h> int main(){   printf("Hello\tWorld\n\n");    return 0;} //输出：//Hello   World//

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

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

字符串常量

字符串：用" " 括起来的。包含很多单引号字符：普通的字符、转义序列和通用的字符。

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

下面这三种形式所显示的字符串是相同的。

"hello, dear" "hello,\ dear" "hello, " "d" "ear"

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

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

定义常量

习惯将常量用大写字母定义，用以区分

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

#define 预处理器

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

#define 常量名 常量值

如：

#define PI 3.14159

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

实例：

#define NEWLINE '\n' printf("%c123", NEWLINE);  // 输出：//// 123

const

（const 常量）

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

const double PI = 3.14159;

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

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

#define 与 const 区别

const 是声明一个常量，#define 是文本替换

C 存储类

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

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

• auto
• register
• static
• extern

auto 存储类

auto 用于局部变量（只能用在函数内），让这个变量作用域在代码块内。

已被废弃，但作为保留字，auto 仍然存在于 C 语言的语法规范中。以防止用户将其作为标识符来使用。

定义在函数中的变量默认为 auto 存储类。

{   int a; <==> auto int a;    //因为加不加auto都不影响，所以被废弃了}

register 存储类

register 将局部变量定义在寄存器（cpu 中的内存）中,可以让变量的访问速度更快，因为不是在内存（RAM）中，因此也没有了内存地址，无法使用&。

{   register int  miles;}

编译器会自动进行寄存器分配和优化，将频繁使用的变量存储在寄存器中，因此手动使用 register 存储类的效果有限。还有

是否实际将变量存储在寄存器中是由编译器决定的，它可能会根据具体情况忽略 register 关键字。

static 存储类

static：静止的，静态的

使用它声明的变量叫做静态变量

static

• 让一个全局变量/函数在这个程序结束前都不会被销毁，并且只作用于当前文件（这里不讨论 C++的 class）
• 静态局部变量的话，就在这个程序结束前都不会被销毁，并只作用于当前块中）

如：

#include <stdio.h> // 函数声明void func1(void);// 只作用于当前文件中static int count=10; int main(){  while (count--) {      func1();  }  return 0;} void func1(void){  // 只作用于当前块中，但直到程序结束时才会被销毁  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

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

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

 $ gcc main.c support.c

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

// 输出count is 5

C 运算符

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

算术运算符

int A=10,B=20;

关系运算符

int A=10,B=20;

逻辑运算符

int A=1,B=0;

位运算符

位运算就是直接对二进制数按每一位进行操作，而不考虑整体含义，
就是将二进制的 0 或 1 看成逻辑的真或假来向竖式一样进行逻辑运算

C 语言中的位运算符包括：

• 按位与(&)：对两个二进制数的对应位进行与操作，对应位都为 1 时结果为 1，否则为 0。
• 按位或(|)：对两个二进制数的对应位进行或操作，对应位有一个为 1 时结果为 1，否则为 0。
• 异或(^)：对两个二进制数的对应位进行异或操作，对应位相同时结果为 0，不同时结果为 1。
• 取反(~)：对一个二进制数的每一位取反，0 变 1，1 变 0。

此外，还有移位运算符：

• 左移(<<)：对二进制数进行左移操作，左移 n 位相当于乘以 2 的 n 次方。
• 右移(>>)：对二进制数进行右移操作，右移 n 位相当于除以 2 的 n 次方。

例如 1（位运算符）：
对于二进制数a=1010和b=1111，（10 和 15）
其按位与运算的结果为 1010 & 1111 = 1010，（a & b）
按位或运算的结果为 1010 | 1111 = 1111，（a | b）
异或运算的结果为 1010 ^ 1111 = 0101，（a ^ b）（0101：5）
取反运算的结果为 ~1010 = 0101。 （~a）

例如 2（移位运算符）：
对于二进制数a=1010，
其左移 1 位的结果为 10100，（a<<1）（10100：20）
右移 1 位的结果为 101。 （a>>1） （101：5）

注：1. << >> 还是输入输出流的分隔符
2. 其实上面的位移结果在内存中是
0000 0000 0000 0000 0000 0000 0001 0100和
0000 0000 0000 0000 0000 0000 0000 0101
3. 其实
a<<n 就相当于 a×2 的 n 次方，
a>>n 就相当于 a 整除 2 的 n 次方。
4. ~A=-A-1 （这里的 A 是一个二进制数，而非一个像上面一样的变量）

下表显示了 C 语言位运算符。

int A=60,B=13;

| 运算符 | 描述 | 实例 |
| :----- | :--------------------------------------------------------------------------------------------------- | :------------------------------------------------ | ------------ | ------------ | ----- | ---------------------------------- |
| & | 与
运算规则：
0&0=0;
0&1=0;
1&0=0;
1&1=1; | (A & B) 将得到 12，即为 0000 1100 |
| | | 或
运算规则：
0 | 0=0;
0 | 1=1;
1 | 0=1;
1 | 1=1; | (A | B) 将得到 61，即为 0011 1101 |
| ^ | 异或
运算规则：
0^0=0;
0^1=1;
1^0=1;
1^1=0; | (A ^ B) 将得到 49，即为 0011 0001 |
| ~ | 取反
运算规则：
~1=-2;
~0=-1; | (~A ) 将得到 -61，
即为 1100 0011，（补码）。 |
| << | 二进制左移运算符
将一个运算对象的各二进制位全部左移若干位
（左边的二进制位丢弃，右边补 0）。 | A << 2 将得到 240，
即为 1111 0000 |
| >> | 二进制右移运算符
将一个数的各二进制位全部右移若干位，
（正数左补 0，负数左补 1，右边丢弃） | A >> 2 将得到 15，
即为 0000 1111 |

赋值运算符

杂项运算符 ： sizeof & 三元

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

请看下面的实例，了解 C 语言中所有可用的杂项运算符：

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

//输出：Line 1 - 变量 a 的大小 = 4Line 2 - 变量 b 的大小 = 2Line 3 - 变量 c 的大小 = 8a 的值是 4*ptr 是 4b 的值是 30b 的值是 20

C 中的运算符优先级

从高到低的优先级

C 判断

C 语言把任何非零和非空的值假定为 true，把零或 null 假定为 false。

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

st=>start: 开始op=>operation: 条件代码cond=>condition: 条件Ae=>end: 结束st->condcond(no)->econd(yes)->op->e

判断语句

C 语言提供了以下类型的判断语句。点击链接查看每个语句的细节。

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

条件运算符 ? :，可以用来替代 if...else 语句。

条件 ? 真的结果 : 假的结果;

以下实例通过输入一个数字来判断它是否为奇数或偶数

int gcd(int x,int y){return y?gcd(y,x%y):x;}

C if 语句

语法

C 语言中 if 语句的语法：

if(条件){   /* 如果表达式为真将执行的语句 */}

流程图

st=>start: 开始sub=>subroutine: 块内代码cond=>condition: if条件e=>end: 结束st->condcond(no)->econd(yes)->sub->e

C if...else 语句

一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为 false 时执行。

语法

C 语言中 if...else 语句的语法：

if条件){   /* 如果表达式为真将执行的语句 */}else{   /* 如果表达式为假将执行的语句 */}

C 嵌套 if 语句

st=>start: 开始sub1=>subroutine: if代码块Bsub2=>subroutine: else代码块cond=>condition: if条件Ae=>end: 结束st->condcond(no)->sub2->econd(yes)->sub1->e

实例

#include <stdio.h> int main (){   /* 局部变量定义 */   int a = 100;    /* 检查布尔条件 */   if( a < 20 )   {       /* 如果条件为真，则输出下面的语句 */       printf("a 小于 20\n" );   }   else   {       /* 如果条件为假，则输出下面的语句 */       printf("a 大于 20\n" );   }   printf("a 的值是 %d\n", a);    return 0;}

//输出：a 大于 20a 的值是 100

if...else if...else 语句

一个 if 语句后可跟一个可选的 else if...else 语句，这可用于测试多种条件。

当使用 if...else if...else 语句时，以下几点需要注意：

• 一个 if 后可跟零个或一个 else，else 必须在所有 else if 之后。
• 一个 if 后可跟零个或多个 else if，else if 必须在 else 之前。
• 一旦某个 else if 匹配成功，其他的 else if 或 else 将不会被测试。

语法

C 语言中的 if...else if...else 语句的语法：

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

实例

#include <stdio.h> int main (){   /* 局部变量定义 */   int a = 100;    /* 检查布尔条件 */   if( a == 10 )   {       /* 如果 if 条件为真，则输出下面的语句 */       printf("a 的值是 10\n" );   }   else if( a == 20 )   {       /* 如果 else if 条件为真，则输出下面的语句 */       printf("a 的值是 20\n" );   }   else if( a == 30 )   {       /* 如果 else if 条件为真，则输出下面的语句 */       printf("a 的值是 30\n" );   }   else   {       /* 如果上面条件都不为真，则输出下面的语句 */       printf("没有匹配的值\n" );   }   printf("a 的准确值是 %d\n", a );    return 0;}

//输出：没有匹配的值a 的准确值是 100

C switch 语句

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

语法

C 语言中 switch 语句的语法：

switch (day){    case 1:        printf("Monday\n");   // 语句        break;    case 2:        printf("Tuesday\n");  // 语句        break;   		......    default:      printf("Invalid day\n");// 默认语句(Invalid day无效的日期)}

• 先检测小括号“day”的值，若 day=1（小括号的值与 case 的值匹配），
• 则选择 case 为“1”的代码块来执行，以此类推。
• 但如果都没有，则会执行默认的代码块（default 下的）。
• 当然，default 语句是可选的。
• 若 case 的语句最后没加 break；则会按顺序继续执行下一个 case 的代码块，
• 直到结束，这可能会产生意想不到的结果。

流程图

实例

#include <stdio.h> int main (){   /* 局部变量定义 */   char grade = 'B';    switch(grade)   {   case 'A' :      printf("很棒！\n" );      break;   case 'B' :   case 'C' :      printf("做得好\n" );      break;   case 'D' :      printf("您通过了\n" );      break;   case 'F' :      printf("最好再试一下\n" );      break;   default :      printf("无效的成绩\n" );   }   printf("您的成绩是 %c\n", grade );    return 0;}

//输出：做得好您的成绩是 B

C 嵌套 switch 语句

可以把一个 switch 作为一个外部 switch 的语句序列的一部分，即可以在一个 switch 语句内使用另一个 switch 语句。即使内部和外部 switch 的 case 常量包含共同的值，也没有矛盾。

语法

C 语言中 嵌套 switch 语句的语法：

switch(ch1) {   case 'A':      printf("这个 A 是外部 switch 的一部分" );      switch(ch2) {         case 'A':            printf("这个 A 是内部 switch 的一部分" );            break;         case 'B': /* 内部 B case 代码 */      }      break;   case 'B': /* 外部 B case 代码 */}

实例

#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 的准确值是 %d\n", a );   printf("b 的准确值是 %d\n", b );    return 0;}

//输出：这是外部 switch 的一部分这是内部 switch 的一部分a 的准确值是 100b 的准确值是 200

C 循环

有的时候，我们可能需要多次执行同一块代码。一般情况下，语句是按顺序执行的：函数中的第一个语句先执行，接着是第二个语句，依此类推。

编程语言提供了更为复杂执行路径的多种控制结构。

循环语句允许我们多次执行一个语句或语句组，下面是大多数编程语言中循环语句的流程图：

循环类型

C 语言提供了以下几种循环类型。点击链接查看每个类型的细节。

循环控制语句

循环控制语句改变你代码的执行顺序。通过它你可以实现代码的跳转。

C 提供了下列的循环控制语句。点击链接查看每个语句的细节。

无限循环

如果条件永远不为假，则循环将变成无限循环。for 循环在传统意义上可用于实现无限循环。由于构成循环的三个表达式中任何一个都不是必需的，您可以将某些条件表达式留空来构成一个无限循环。

实例

#include <stdio.h> int main (){   for( ; ; )   {      printf("该循环会永远执行下去！\n");   }   return 0;}

当条件表达式不存在时，它被假设为真。或达不到条件也会一直循环下去

**注：**可以按 Ctrl + C 键终止一个无限循环。

C while和do...while`循环

while(   ){    }//当小括号中为真，执行大括号中的内容，否则不执行 //其中int i=1;while (i<=100)      <==>    for(int i=1;i<=100;i++ ){						 	{    内容;						   内容;    i++;					}}

do{   }whlie(   )//先执行，再判断真假，看看是否执行下一次//因此，它与while的区别是它至少会执行一次

流程图

C for 循环

for 循环允许您编写一个执行指定次数的循环控制结构。

语法

for( ; ; ){   }

for

(

初始化语句（仅执行一次）;

评估测试表达式（如果命题为假，则终止循环）;

更新表达式（一般用于改变循环控制变量的值）

)

{先执行测试完为真后，执行大括号中的语句；之后才执行更新表达式（如 i++）}

流程图

C 嵌套循环

循环中套循环

流程图

嵌套 for 循环流程图:

嵌套 while 循环流程图:

C break和continue语句

当读到break，立刻跳出循环（立刻结束当前所在的循环）

当读到continue，跳过当前迭代（的剩余代码），立刻进行下一个迭代（循环）

break 流程图

continue 流程图

C goto语句

goto abc;……abc：

通过goto，将直接跳转到标签abc处，并让程序从abc处开始执行，

标签abc可在goto前，也可在后；

一般用于打破嵌套循环，用到其他地方后，可能会让代码很难理解，最好少用

流程图

C 函数

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

可以把代码划分到不同的函数中,以优化重构代码

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

其包含声明函数，调用函数，定义函数三个方面，其中声明和定义可以一起，只要在前面

C 标准库提供了大量的内置函数。如：printf() scanf()
当然也可以自己定义函数

函数还有很多叫法，比如方法、子例程或程序，等等。

函数定义

• 函数定义：

  如求和函数：

  C

  void sum(int begin,int end) 	//这是函数头//sum是函数名//void是返回类型		（void是”没有“不返回任何东西）//函数头中的括号部分是参数表。若是空的表示不接受任何函数//下面是函数体{	int i;	int sum=0;	for(i=begin; i<=end;i++)    {		sum+=1;	}	printf("%d到%d的和是%d\n",begin,end,sum);}

void:不返回任何东西（其后不能用带值的return（可用return;）或可以没有return)

int ：返回return后的结果（如return i，则返回i中的值）

return后停止这个函数的运行，并返回一个值（一个函数可以出现多个函数）

函数声明

把函数放在int main上面是因为 c 的编译器是自上而下分析代码，它必须要先看到自创的函数才能运用,

或者将函数头复制一遍并搬到前面去并加;，从而对编译器进行一次“原型声明”，告知它有这个代码

如：

void sum(~)；int main(~){~}void sum(~){~}

若调用函数时给的参数类型不匹配，c 语言会悄悄改好，但 c++，java 等不会（如double 2.4 ==>int 2)

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

调用函数

1. 函数名（参数值）；

2. ()起到了表示函数调用的重要作用

3. 即使没有参数也需要()

4. 如果有参数，则需给出正确的数量与顺序，这些值会被按照顺序依次初始化函数中的参数

   注：返回值的类型也要匹配

函数参数

这些变量称为函数的形式参数。

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

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

默认使用传值调用来传递参数，除非传递指针 （传值调用又称值传递）

C 引用方式调用函数

有如下两种方式：

&：    函数（int &a）	main （a） *：	函数（int *a）	main （&a）

使用 & 和 * 的引用传递有以下不同之处：

1. & 引用传递：使用 & 表示引用传递时，函数参数接收的是原始变量的引用。在函数内部对该引用进行操作时，实际上是直接对原始变量进行操作。这意味着对引用的修改会直接反映到原始变量上。
2. * 指针传递：使用 * 表示指针传递时，函数参数接收的是原始变量的指针。在函数内部对该指针进行操作时，需要通过解引用操作 * 来访问原始变量的值。通过指针传递，可以在函数内部修改指针所指向的数据，从而间接修改原始变量的值。

总结起来，& 引用传递直接操作原始变量，而 * 指针传递通过指针间接操作原始变量。引用传递更直观、方便，而指针传递更灵活、具有更多的控制权。

C 作用域规则

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

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

局部变量

只能在代码块{}中使用

全局变量

全局变量在整个程序生命周期内都是有效的，可以被任何函数访问。

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

形式参数

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

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

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

初始化局部变量和全局变量

全局变量或静态变量自带默认初始值,为 0

建议定义局部变量时初始化，因为它没定义前可能包含内存中任意垃圾值

C 数组

C 语言数组

数组是可以储存多个值的变量

（即多个小房子 如a[5]={1,100,2,5,44}等等）

数组的第一个索引（值）为 0，所以要访问最后一个元素，要使用 n-1；

假设起始地址mark[0]是 2120d，则mark[1]的地址将是 2124d，同样的，mark[2]的地址是 2128d 以此类推

声明数组

如下:

double balance[10];

初始化数组

在声明期间可以初始化数组，

如：

int mark[5] = {19, 10, 8, 17, 9};//初始前五个数组，若数值（中括号中的）为5个就初始五个。若大括号的数多余五个，则五个后面的都省略

或：

int mark[] = {19, 10, 8, 17, 9};//虽然没指定大小，但编译器会知道大小是5

访问数组元素

更改数组元素中的值：

用赋值号（等于号）

访问元素超过范围：

若定义a[10]（即定义了 a[0]~a[9]）,但尝试访问了 a[10]呀、a[12]呀等等，就会导致访问错误（栈错误）

获取数组长度

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

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

数组名

在 C 语言中，数组名表示数组的地址，即数组首元素的地址。

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

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

C 中数组详解

在 C 中，数组是非常重要的，我们需要了解更多有关数组的细节。下面列出了 C 程序员必须清楚的一些与数组相关的重要概念：

C 多维数组

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

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

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

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

二维数组

C 语言多维数组

二位数组：如：a[x][y]; 例：

三维数组：如：a[x][y][z];

初始二维数组：

int c[2][3] = {{1, 3, 0}, {-1, 5, 9}};int c[][3] = {{1, 3, 0}, {-1, 5, 9}};int c[2][3] = {1, 3, 0, -1, 5, 9};

初始三维数组：

int test[2][3][4] = {  {{03, 4, 02, 3}, {0, -3, 9, 11}, {23, 12, 23, 2}} ,    		    	   {{13, 4, 56, 3}, {5, 09, 3, 05}, {03, 01, 04, 9}} }; 

int test[2][3][4] = { {{03, 4, 02, 3}, {0, -3, 9, 11}, {23, 12, 23, 2}} ,

{{13, 4, 56, 3}, {5,09, 3, 05}, {03, 01, 04, 9}} };

数组循环方向

// 行是三行排，之前把列与行的定义搞反了// 反正记住二维数组是先竖着多少个，然后横着多少个int main(){	int a[3][4] ={		{1,2,3,4},		{3,4,5,5},		{67,3,9,6}	};	for(int i=0;i<3;i++)	{		for(int j=0;j<4;j++)			cout<<a[i][j]<<' ';		cout<<endl;	}	return 0;}// 输出：1 2 3 43 4 5 567 3 9 6

C 传递数组给函数（作为函数参数）

例：a[10]

若要传递数组的一部分元素，只要传递“数组加中括号内的数”（传a[1]、a[3]等）

若要传递整个数组，直接传递数组名（传a）

当然，函数的值也要是数组，如float calculateSum(float age[])

若是多维数组，也同理

用指针也可以传递（本身名字就是地址,接收指针就行了）

但是，是不能从函数中返回数组的，除非用指针或结构体

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] = %d\n", i, r[i]);   }   return r;} /* 要调用上面定义函数的主函数 */int main (){   /* 一个指向整数的指针 */   int *p;   int i;    p = getRandom();   for ( i = 0; i < 10; i++ )   {       printf( "*(p + %d) : %d\n", i, *(p + i));   }    return 0;}

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

r[0] = 313959809r[1] = 1759055877r[2] = 1113101911r[3] = 2133832223r[4] = 2073354073r[5] = 167288147r[6] = 1827471542r[7] = 834791014r[8] = 1901409888r[9] = 1990469526*(p + 0) : 313959809*(p + 1) : 1759055877*(p + 2) : 1113101911*(p + 3) : 2133832223*(p + 4) : 2073354073*(p + 5) : 167288147*(p + 6) : 1827471542*(p + 7) : 834791014*(p + 8) : 1901409888*(p + 9) : 1990469526

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

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

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

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

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

静态数组

一般使用的数组

动态数组

Ｃ＋＋中已经用｀｀来构建了方便使用的动态数组,以下了解就好了

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

动态数组特点如下：

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

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

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

以上实例中，我们首先声明了一个变量 size 来指定动态数组的大小。

然后使用 malloc 函数为动态数组分配内存，并通过 sizeof 运算符计算所需的内存大小。

接下来，通过循环和 scanf 函数，从用户输入中读取元素值并存储到动态数组中。

最后，使用循环遍历并打印动态数组的元素。在程序结束时，使用 free 函数释放动态数组所占用的内存。

请注意，在使用动态数组时，需要检查内存分配是否成功（即 dynamicArray 是否为 NULL），以避免在内存分配失败时发生错误。

C 枚举（enum）

枚举类型是 int 整数常量的数据类型

语法：

enum 名称		//这个名称又称变量的蓝图{	第一个选项，	第二个选项，	第三个选项//默认每个选项的值为从小到大，从0，1，2，...开始排//但可以人为定义，如对于第二个选项club：“club=0，”};

声明枚举类型：

//和结构体一样，	enum boolean {false, true};	enum boolean check; // 声明一个枚举变量//或	enum boolean {false, true} check;

用法示例：

#include <stdio.h> enum week {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday}; int main(){    //创建枚举week类型的today变量    enum week today;    today = Wednesday;    printf("Day %d",today+1);    return 0;}

为什么要用枚举：

让维护性和可读性提高，文字总比数字清晰呀

枚举变量的定义

可以通过以下三种方式来定义枚举变量

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;

可以使用 for switch 来使用枚举，但如果它对应的数值不是连续的，就不可以用 for

将整数转换为枚举

实例

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

// 输出：weekend:1

C 指针

C 语言指针

指针是 C 语言和 C++中强大的功能 （ptr：pointer：指针）

C 语言地址

对于变量 a，则用&a 给 a 赋予一个地址

(取址符&用于获取变量的地址，并返回指向该对象变量的指针)

C 语言指针

指针（指针变量）是用于储存地址而非值的特殊变量

（用于储存别的小房子的门牌号而非小房子中的数的小房子，所以指针也可以储存指针）

指针语法：

• 如何声明指针：

int *ptr1, *ptr2;int* p;  int *p;//int* p1, p2;声明的是一个指针p1和一个普通变量p2

• 给指针分配地址：

int *a,b=5;  a=&b;  //记住这第二个a没有星号

• 获取指针锁指向的值：

int c;  c=*a;  		//c的值就是5了//星号*相当于让程序获取地址指向的小房子的值而非地址的值

• 改变指针指向的值：

*a=10; 或b=10;	   //这时b的值为10了

• 其他：

//几种错误用法：int c, *pc;pc = c; 		//pc是地址，但c不是*pc = &c; 		//＆c是地址，但* pc不是pc = &c;		//＆c和pc都是地址*pc = c;		//c和*pc值 //但这样是可以的：int *p = &c; //这相当于：int *p;p = &c; //所以，为了避免这种情况，我们常用：int* p=&c;

C 语言指针与数组

数组是一个顺序数据块

其中，a[n]的数组中，a与a[0]的地址相等，因为变量名x指向数组的第一个元素，即x[0]

所以，x[i]的地址等于x+i的

即&x[i]等同于x+i ； x[i]等同于*(x+i)。

指针与数组

例：

#include <stdio.h>				//运行该程序时，输出为：int main() 						//输入6个数字:  2 3 4 4 12 4{								//总和 = 29 	int i, x[6], sum = 0;	printf("输入6个数字:");  	for( =0;i<6 ++i)	{		scanf("%d", x+i);		//等效于scanf("%d", &x[i]);		sum += *(x+i);			//等同于 sum += x[i]  	}  	printf("总和 = %d", sum);  	return 0;}

数组与指针

例：

#include <stdio.h>				//运行该程序时，输出为：int main()						//*ptr = 3{								//*(ptr+1) = 4	int x[5] = {1,2,3,4,5};		//*(ptr-1) = 2    int* ptr;*(ptr-1) = 2     ptr = &x[2]; 				//ptr被分配了第三个元素的地址   	printf("*ptr = %d \n", *ptr);   		//3  	printf("*(ptr+1) = %d \n", *(ptr+1)); 	//4  	printf("*(ptr-1) = %d", *(ptr-1));  	//2   	return 0;}

所以说，*(x-i)也可以

C 语言指针与函数

将地址作为参数传递给函数，有叫“引用调用”

通过引用调用

在主函数中的函数中用&x，在函数中接收*x

如：

#include<stdio.h> void aaaaa(int *n1){    printf("%d",*n1);} int main(){    int num1=5;    aaaaa( &num1);    return 0;} 输出为：5

这个就是直接传递地址

将指针传递给函数

如：

#include<stdio.h> void aaaaa(int *n1){    printf("%d",*n1);} int main(){    int num1=5;	int* p=&num1;    aaaaa( p);    return 0;} 输出为：5

这个就是传递指针变量

C 语言sizeof()运输符

sizeof（size of：~的大小）

用于获取变量，数据类型，数组的大小（以字节为单位）

如：

int a=sizeof(x);printf(“%d”, sizeof(int) );sizeof(a[10]);

注意：输出在不同的机器上可能会有所不同，例如在 32 位操作系统上将显示不同的输出，在 64 位操作系统上将显示相同数据类型的不同输出。

C 语言void指针

指向void的指针便是可以指向任何数据类型的通用指针

因此可以将任何数据类型的地址分配给void指针，并且可以将void指针分配给任何类 型的指针，而无需执行任何显式的类型转换。

malloc和relloc函数返回的指针都是void*类型

由于void指针没有指定的类型信息，因此在使用它时需要进行类型转换，以确保正确地访问指针所指向的内存内容。如可以用（int*等等强制转换）

当使用void指针访问内存时需要小心类型错误和越界访问等问题。

为什么我们使用void指针？

如果函数需要接受多种类型的指针作为参数，可以使用 void 指针来实现

例：

#include<stdio.h>int main() 							  //输出结果：{ 									  //a的值为 : 56  int a=56;    //初始化一个整数变量'a'。 //b的值为 : 4.500000  float b=4.5; //浮点变量'b'的初始化。   //c的值为 : k  char c='k';  //字符变量'c'的初始化。   void *ptr;   //声明空指针。    //为变量“a”分配地址。   ptr=&a;   printf("a的值为 : %d",*((int*)ptr));    //为变量'b'分配地址。   ptr=&b;   printf("\nb的值为 : %f",*((float*)ptr));    //为变量'c'分配地址。   ptr=&c;   printf("\n c的值为 : %c",*((char*)ptr));    return 0;}

132312123312

C 指针运算与比较

在 C 中，有很多指针相关的概念，这些概念都很简单，但是都很重要。下面列出了 C 程序员必须清楚的一些与指针相关的重要概念：

C 指向指针的指针

指向指针的指针是一种多级间接寻址的形式，或者说是一个指针链。通常，一个指针包含一个变量的地址。当我们定义一个指向指针的指针时，第一个指针包含了第二个指针的地址，第二个指针指向包含实际值的位置。

一个指向指针的指针变量必须如下声明，即在变量名前放置两个星号。例如，下面声明了一个指向 int 类型指针的指针：

int **var;

当一个目标值被一个指针间接指向到另一个指针时，访问这个值需要使用两个星号运算符，如下面实例所示：

#include <stdio.h> int main (){   int  V;   int  *Pt1;   int  **Pt2;    V = 100;    /* 获取 V 的地址 */   Pt1 = &V;    /* 使用运算符 & 获取 Pt1 的地址 */   Pt2 = &Pt1;    /* 使用 pptr 获取值 */   printf("var = %d\n", V );   printf("Pt1 = %p\n", Pt1 );   printf("*Pt1 = %d\n", *Pt1 );    printf("Pt2 = %p\n", Pt2 );   printf("**Pt2 = %d\n", **Pt2);    return 0;}

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

var = 100Pt1 = 0x7ffee2d5e8d8*Pt1 = 100Pt2 = 0x7ffee2d5e8d0**Pt2 = 100

C 传递指针给函数

C 语言允许您传递指针给函数，只需要简单地声明函数参数为指针类型即可。

下面的实例中，我们传递一个无符号的 long 型指针给函数，并在函数内改变这个值：

#include <stdio.h>#include <time.h> void getSeconds(unsigned long *par); int main (){   unsigned long sec;     getSeconds( &sec );    /* 输出实际值 */   printf("Number of seconds: %ld\n", sec );    return 0;} void getSeconds(unsigned long *par){   /* 获取当前的秒数 */   *par = time( NULL );   return;}

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

Number of seconds :1294450468

能接受指针作为参数的函数，也能接受数组作为参数，如下所示：

#include <stdio.h> /* 函数声明 */double getAverage(int *arr, int size); int main (){   /* 带有 5 个元素的整型数组  */   int balance[5] = {1000, 2, 3, 17, 50};   double avg;    /* 传递一个指向数组的指针作为参数 */   avg = getAverage( balance, 5 ) ;    /* 输出返回值  */   printf("Average value is: %f\n", avg );      return 0;} double getAverage(int *arr, int size){  int    i, sum = 0;        double avg;             for (i = 0; i < size; ++i)  {    sum += arr[i];  }   avg = (double)sum / size;   return avg;}

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

Average value is: 214.40000

C 从函数返回指针

在上一章中，我们已经了解了 C 语言中如何从函数返回数组，类似地，C 允许您从函数返回指针。为了做到这点，您必须声明一个返回指针的函数，如下所示：

int * myFunction(){...}

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

现在，让我们来看下面的函数，它会生成 10 个随机数，并使用表示指针的数组名（即第一个数组元素的地址）来返回它们，具体如下：

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

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

15231980531187214107110830097843049495914213012769309710841232504841069321401604461820149169022*(p + [0]) : 1523198053*(p + [1]) : 1187214107*(p + [2]) : 1108300978*(p + [3]) : 430494959*(p + [4]) : 1421301276*(p + [5]) : 930971084*(p + [6]) : 123250484*(p + [7]) : 106932140*(p + [8]) : 1604461820*(p + [9]) : 149169022

函数指针 与 回调函数

函数指针

函数指针是指向函数的指针变量。

通常我们说的指针变量是指向一个整型、字符型或数组等变量，而函数指针是指向函数。

函数指针可以像一般函数一样，用于调用函数、传递参数。

函数指针变量的声明：

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

实例

以下实例声明了函数指针变量 p，指向函数 max：

#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

回调函数

函数指针作为某个函数的参数

函数指针变量可以作为某个函数的参数来使用的，回调函数就是一个通过函数指针调用的函数。

简单讲：回调函数是由别人的函数执行时调用你实现的函数。

以下是来自知乎作者常溪玲的解说：

你到一个商店买东西，刚好你要的东西没有货，于是你在店员那里留下了你的电话，过了几天店里有货了，店员就打了你的电话，然后你接到电话后就到店里去取了货。在这个例子里，你的电话号码就叫回调函数，你把电话留给店员就叫登记回调函数，店里后来有货了叫做触发了回调关联的事件，店员给你打电话叫做调用回调函数，你到店里去取货叫做响应回调事件。

实例

实例中 populate_array() 函数定义了三个参数，其中第三个参数是函数的指针，通过该函数来设置数组的值。

实例中我们定义了回调函数 getNextRandomValue()，它返回一个随机值，它作为一个函数指针传递给 populate_array() 函数。

populate_array() 将调用 10 次回调函数，并将回调函数的返回值赋值给数组。

#include <stdlib.h>#include <stdio.h> void populate_array(int *array, size_t arraySize, int (*getNextValue)(void)){    for (size_t i=0; i<arraySize; i++)        array[i] = getNextValue();} // 获取随机值int getNextRandomValue(void){    return rand();} int main(void){    int myarray[10];    /* getNextRandomValue 不能加括号，否则无法编译，因为加上括号之后相当于传入此参数时传入了 int , 而不是函数指针*/    populate_array(myarray, 10, getNextRandomValue);    for(int i = 0; i < 10; i++) {        printf("%d ", myarray[i]);    }    printf("\n");    return 0;}

编译执行，输出结果如下：

16807 282475249 1622650073 984943658 1144108930 470211272 101027544 1457850878 1458777923 2007237709

C 字符串

C 语言字符串

C 语言中，字符串是以null字符（即字符\0）结尾（\0的 ASCII 码为0）

如何声明一个字符串

char s[5]; 		//就是声明一个有五个字符的字符串，包括“\0”

如何初始化字符串

char c[] = "abcd";char c[50] = "abcd";char c[] =  {'a','b','c','d','\0'};char c[5] = {'a','b','c','d','\0'};//若输入char c[4] = "abcd";则会数据溢出

给字符串赋值

C 语言中不支持用赋值运算符（等于号）赋值

但可以用 strcpy，ctrncpy 来复制字符串

从用户处读取字符串

用scanf():

char name[20];scanf(“%s”,name);//当读到空格（空格，换行符，制表符等）就不读了

若要读一整行，用fgets()，并可以用puts()，printf(“%s”,str)来显示字符串

也可以用gets()，但可能让数据溢出，所以不推荐使用(现已被删除)

fgets() （get string from file：从文件中获取字符串）

语法：

fgets(str, sizeof(str), stdin);

puts() （puts: 字符串输出）

语法：

put (str);//它在输出后会返回”字符+\0”的数目，即字符数+1

如：

char str[] = "Hello,world!";int count = puts(str);			//count=13

将字符串传给函数

像数组一样直接传（即直接传字符串名字），接收时也像数组一样用str[]

如：

hanshu(char str[];)

字符串和指针

类似数组，字符串名字就是指针，用法也和数组一样

C 中有大量操作字符串的函数：

• strlwr() 将字符串转换为小写
• strupr() 将字符串转换为大写

C 语言结构体

C 语言结构体：

结构是 C 语言中另一种用户自定义的一种数据类型，可用于储存不同数据类型的数据

定义结构：

要用 struct 关键字，使用方法如下:

语法：

一、    						  |	二、struct 结构体名称 			    |	struct 结构体名称{							   |	{	数据类型 成员1;			   |		数据类型 成员1;	数据类型 成员2;			   |		数据类型 成员2;	// ...					   |		// ...};							   |	}变量名1,变量名2；//这是只声明有一个叫“结构体名称”	  |	   //这是同时声明结构体与变量//之后才声明一个叫xxx的结构体变量	  |struct 结构体名称 变量名1, 变量名2;|

当然结构体中可以嵌套结构体，或指向自己的指针

嵌套结构体用于如：

• 可能需要在结构中存储实体员工的地址。而地址也可以包含其他信 息，例如街道编号，城市，地区和密码。

  如下使用方法:

//此结构体的声明包含了其他的结构体	     |  或以下，等方法struct COMPLEX					    |  struct Employee{								    |  {    char string[100];			    |		int id;    struct SIMPLE a;			    |		char name[20];};								    |		struct Date								    |  {/*此结构体的声明包含了指向自己类型的指针*/|   	   int dd;struct NODE						    | 		int mm;{								    |		int yyyy;     char string[100];			    |		}doj;    struct NODE *next_node;		    |  }e1;};								    |

如果两个结构体相互包含，则要对其中一个结构体进行不完整声明

如：

struct B;    //对结构体B进行不完整声明 //结构体A中包含指向结构体B的指针struct A{    struct B *partner;			//通过此方法创建结构体指针    //other members;}; //结构体B中包含指向结构体A的指针，在A声明完后，B也随之进行声明struct B{    struct A *partner;    //other members;};

初始化结构体变量：

有点像数组的方法

#include <stdio.h>struct Books{   char  title[50];   char  author[50];   char  subject[100];   int   book_id;} book = {"C 语言", "nhooo", "编程语言", 123456};int main(){//若要在函数中声明，按如下来//struct Books book = {"C语言","nhooo","编程语言",123456};    printf(...);}

访问结构成员：

为了访问结构成员，要使用“成员访问运算符（.）”（就是一个英文句号）

使用方法：

结构体变量名+.+成员名

这样就可以访问其中的成员了

#include <stdio.h>#include <string.h>struct Books{   char  title[50];   char  author[50];   char  subject[100];   int   book_id;};int main( ){//方法一：  	 struct Books Book[2];/* 声明 Book数组，类型为 Books */    	 /* Book 详述 */  	 strcpy( Book[1].title, "C语言");   	 strcpy( Book[1].author, "Nuha Ali");   	 strcpy( Book[1].subject, "C语言教程");   	 Book1.book_id = 6495407;    	 strcpy( Book[2].title, "JAVA语言");   	 strcpy( Book[2].author, "Seagull Ali");   	 strcpy( Book[2].subject, "JAVA语言教程");  	 Book[2].book_id = 6495700; //或者：	struct Books Book[2]= {        {"C语言", "Nuha Ali", "C语言教程",6495407},        {"JAVA语言", "Seagull Ali", "JAVA语言教程",6495700};    	return 0;}

结构体作为函数参数：

如：

void printBook( struct Books book ){......};int main(){struct Books Book1;printBook( Book1 );}

指向结构的指针：

定义方法与其他类型相似

如：

//复用的是上上个的代码struct Books *sp;		//定义指针变量sp = &Book1;			//赋予结构体Book1的地址sp->title;				//让指针访问Book1中的”title”这个成员

使用“->”运算符访问结构体中的成员，如上

例：

printBook( &Book1 );		//主函数中传递地址 void printBook( struct Books *book )	//定义指针并接受地址{   printf( "Book 书名： %s\n", book->title);   printf( "Book 编号： %d\n", book->book_id);}

位域（Bit Fields）

又叫“位段”，是一种在结构体中以位为单位分配存储空间的特性，用于节省空间

定义

struct 位域结构名{	类型说明符 位域名：位域长度；}

如：

struct bs{    	int a:8;		// 占8个位（位（bit），一般8个位一字节（byte））    	int b:2;		// 占2个位    	int c:6;		// 占6个位}data;			//data变量，共占两个字节（8+2+6=16）

几点要注意的

一个位域存储在同一个字节中，如一个字节所剩空间不够存放另一位域时，则会从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：

struct bs{   unsigned a:4;   unsigned  :4;     /* 空域 或叫 无名位域，只用来作填充或调整位置，是不能使用的 */   unsigned b:5;     /* 从下一单元开始存放 */   unsigned c:3;}

在这个位域定义中，a 占第一字节的 4 位，后 4 位填 0 表示不使用，b 从第二字节开始，占用 5 位，c 占用 3 位。

由于位域不允许跨两个字节（最长为 8 位，一个字节），如unsigned int flag3 : 10;占 10 各位就不行，因为可能发生溢出错误

从以上分析可以看出，位域在本质上就是一种结构类型，不过其成员是按二进位分配的。

位域的使用方法与结构成员相同

如：

int main(){    struct bs{        unsigned a:1;        unsigned b:3;        unsigned c:4;    } bit,*pbit;    bit.a=1;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */    bit.b=7;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */    bit.c=15;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */    printf("%d,%d,%d\n",bit.a,bit.b,bit.c);    /* 以整型量格式输出三个域的内容 */     pbit=&bit;    /* 把位域变量 bit 的地址送给指针变量 pbit */    pbit->a=0;    /* 用指针方式给位域 a 重新赋值，赋为 0 */    pbit->b&=3;   /* 使用了复合的位运算符 "&="，相当于：pbit->b=pbit->b&3，位域 b 中原有值为 7，与 3 作按位与运算的结果为 3（111&011=011，十进制值为 3） */    pbit->c|=1;    /* 使用了复合位运算符"|="，相当于：pbit->c=pbit->c|1，其结果为 15 */     printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c);    /* 用指针方式输出了这三个域的值 */}//上例程序中定义了位域结构 bs，三个位域为 a、b、c。说明了 bs 类型的变量 bit 和指向 bs 类型的指针变量 pbit。这表示位域也是可以使用指针的