C语言从入门到高级教程

C语言应该是学习编程的第一门语言

哔哩哔哩：https://www.bilibili.com/video/BV1EWFreBEoL/

初始C语言

1、C语言简介

什么是编程语言

简单理解就是：跟计算机沟通的语言就是编程语言，通过特定的语法和结构来表达计算机执行的指令。

编程语言可以分为多种类型，包括：

低级语言：如汇编语言，更接近计算机硬件，程序员需要直接操作硬件资源。
高级语言：如Python、Java、C++等，更接近自然语言，提供了更高层次的抽象，使程序员能够更专注于解决问题而不是硬件细节。

C和C++都是非常强大的编程语言，C++ 是在C语言的基础上发展起来的，它们在系统级编程、高性能计算和复杂应用程序开发方面有着不可替代的地位。
Java是一种功能强大且灵活的编程语言，从企业级应用到移动开发，从大数据处理到金融服务，Java都发挥着重要作用。
C# 目前主要用于 Windows 平台的软件开发和游戏开发等
Python是一种通用编程语言，广泛用于Web开发、数据分析、人工智能、科学计算、自动化脚本、游戏开发等多个领域。
JavaScript是一种主要用于Web开发的脚本语言，广泛用于前端交互、后端开发（通过Node.js）、移动应用开发（如React Native）和游戏开发（如Unity）等领域。
Go是一种静态类型的编程语言，主要用于构建高性能、高并发的网络服务和系统软件，如Web服务器、分布式系统、云服务和命令行工具等。

C语言的重要性

C语言应该是学习编程的第一门语言
编程语言排行：TIOBE Index – TIOBE
C语言是计算机产业的核心语言，操作系统、硬件驱动、关键组件、数据库等都离不开C语言

2、C语言历史

C语言是一种通用的编程语言，广泛用于系统编程和应用程序开发。它的发展历史可以追溯到20世纪60年代末和70年代初。以下是C语言发展的主要里程碑：

B语言和BCPL语言：
- 1969年，美国贝尔实验室的肯·汤普森（Ken Thompson）为了开发UNIX操作系统，设计了一种名为B的语言。B语言是基于BCPL（Basic Combined Programming Language）语言的简化版本。
C语言的诞生：
- 1972年，丹尼斯·里奇（Dennis Ritchie）在B语言的基础上开发了C语言。C语言最初是为了重新实现UNIX操作系统而设计的。
第一个C语言编译器：
- 1973年，第一个C语言编译器诞生，UNIX操作系统的大部分代码被用C语言重写。
K&R C：
- 1978年，布莱恩·柯林汉（Brian Kernighan）和丹尼斯·里奇（Dennis Ritchie）出版了《C程序设计语言》一书，这本书中描述的C语言版本被称为“K&R C”（Kernighan and Ritchie C）。
ANSI C和ISO C：
- 1989年，美国国家标准协会（ANSI）发布了第一个C语言标准，称为ANSI C。
- 1990年，国际标准化组织（ISO）采纳了ANSI C标准，并对其进行了一些小的修改，形成了ISO C标准。
C99标准：
- 1999年，ISO发布了C语言的新标准，称为C99。C99引入了一些新的特性，如支持更长的整数类型、复数和虚数类型、变长数组等。
C11标准：
- 2011年，ISO发布了C语言的最新标准，称为C11。C11引入了一些新的特性，如多线程支持、泛型选择、匿名结构和联合等。
C17标准：
- 2018年，ISO发布了C17标准，这是一个技术修正版，没有引入新的语言特性，主要是对现有标准的错误和模糊之处进行修正。

C语言因其高效、灵活和可移植性强的特点，成为了许多操作系统和应用程序开发的首选语言。它的设计哲学影响了后来的许多编程语言，如C++、Java和C#等。

3、C语言能做什么

C语言是一种通用的、过程式的计算机编程语言，广泛应用于各种领域。以下是C语言的一些主要应用领域及其举例：

操作系统开发：
- Linux内核：Linux操作系统的大部分代码是用C语言编写的。
- Windows内核：Windows操作系统的内核部分也是用C语言编写的。
嵌入式系统：
- 智能家居设备：如智能插座、智能灯泡等，其固件通常用C语言编写。
- 汽车电子系统：现代汽车的电子控制单元（ECU）通常用C语言编写。
游戏开发：
- 游戏引擎：如Unity3D和Unreal Engine的部分底层代码是用C语言编写的。
- 经典游戏：如《DOOM》和《Quake》等游戏的早期版本是用C语言编写的。
数据库系统：
- MySQL：MySQL数据库的底层代码是用C语言编写的。
- SQLite：SQLite是一个轻量级的数据库，其核心代码也是用C语言编写的。
网络设备和协议：
- 路由器和交换机：网络设备的操作系统和协议栈通常用C语言编写。
- TCP/IP协议栈：许多操作系统的TCP/IP协议栈是用C语言实现的。
科学计算：
- 数值计算库：如BLAS（Basic Linear Algebra Subprograms）和LAPACK（Linear Algebra Package）等库是用C语言编写的。
编译器和解释器：
- GCC：GNU编译器集合（GCC）的很多部分是用C语言编写的。
- Python解释器：CPython，即Python的官方解释器，其部分代码是用C语言编写的。
图形处理：
- 图像处理库：如OpenCV（Open Source Computer Vision Library）是用C语言编写的。
金融科技：
- 高频交易系统：一些高频交易系统的底层代码是用C语言编写的，以确保高效和低延迟。
物联网（IoT）：
- 传感器节点：许多物联网设备和传感器节点的固件是用C语言编写的。

总之，C语言因其高效、灵活和接近硬件的特性，在许多对性能要求较高的领域得到了广泛应用。

4、C语言开发流程

定义程序目标
设计程序
编写代码（源代码）
编译
运行程序
测试和调试
维护和更新

5、编译原理

6、编译器

C语言编译器有很多种，以下是一些常见的C语言编译器：

GCC (GNU Compiler Collection)：
- GCC是一个广泛使用的开源编译器套件，支持多种编程语言，包括C语言。它可以在多种操作系统上运行，如Linux、Windows和macOS。
Clang：
- Clang是另一个开源的C语言编译器，属于LLVM项目的一部分。它以快速编译速度和良好的错误报告而闻名。
Microsoft Visual C++ (MSVC)：
- MSVC是微软提供的C语言编译器，主要用于Windows平台上的开发。它是Visual Studio集成开发环境的一部分。
Intel C++ Compiler (ICC)：
- ICC是英特尔提供的编译器，针对英特尔处理器进行了优化，可以生成高效的代码。
Tiny C Compiler (TCC)：
- TCC是一个非常小巧且快速的C语言编译器，适合嵌入式系统和资源受限的环境。
Pelles C：
- Pelles C是一个免费的C语言开发工具包，主要用于Windows平台。
Cygwin/MinGW：
- Cygwin和MinGW是用于Windows平台的工具集，提供了类Unix环境，可以使用GCC编译器进行C语言开发。

这些编译器各有特点，适用于不同的开发需求和平台。选择合适的编译器可以提高开发效率和代码性能。

7、安装MinGW

什么是 MinGW-w64 ？ MinGW 的全称是：Minimalist GNU on Windows 。它实际上是将经典的开源 C语言编译器 GCC 移植到了 Windows 平台下，并且包含了 Win32API ，因此可以将源代码编译为可在 Windows 中运行的可执行程序。而且还可以使用一些 Windows 不具备的，Linux平台下的开发工具。

一句话来概括：MinGW 就是 GCC 的 Windows 版本。

以上是 MinGW 的介绍，MinGW-w64 与 MinGW 的区别在于 MinGW 只能编译生成32位可执行程序，而 MinGW-w64 则可以编译生成 64位或 32位可执行程序。

正因为如此，MinGW 现已被 MinGW-w64 所取代

官网：MinGW-w64

下载地址：MinGW-w64 – for 32 and 64 bit Windows – Browse /mingw-w64/mingw-w64-release at SourceForge.net

github:Releases · niXman/mingw-builds-binaries (github.com)

查看gcc版本

gcc -v

8、第一个C程序

#include <stdio.h>
 
int main()
{
    /* 我的第一个 C 程序 */
    printf("Hello, World! \n");
 
    return 0;
}

步骤：

打开记事本
写入代码(输入法调整到英文状态)
后缀名改成.c
使用gcc编译（设置环境变量）gcc hello.c -o hello
编译源码
执行可执行程序

快速入门

1. 开发环境

代码编辑器

代码编辑器是一种用于编写、编辑和管理计算机程序代码的软件工具。它们通常提供语法高亮、代码补全、版本控制集成、调试工具等功能，以提高开发者的生产力和代码质量。以下是一些流行的代码编辑器：

Visual Studio Code (VS Code)：由微软开发，是一个轻量级但功能强大的源代码编辑器，支持多种编程语言，并且可以通过扩展进行功能增强。
Sublime Text：一个高度可定制的文本编辑器，以其速度和灵活性而闻名。
Atom：由GitHub开发，是一个开源的、可高度定制的文本编辑器，支持多种编程语言。
Notepad++：一个免费的源代码编辑器和文本编辑器，支持多种编程语言，适用于Windows平台。

IDE(集成开发环境)

C语言开发常用的集成开发环境（IDE）有很多，以下是一些流行的选择：

Visual Studio：
- 微软开发的强大IDE，支持多种编程语言，包括C和C++。
- 提供了丰富的功能，如代码补全、调试工具、版本控制集成等。
Code::Blocks：
- 一个免费、开源、跨平台的C/C++ IDE。
- 支持多种编译器，如GCC、Clang等。
- 提供了项目管理、代码补全、调试等功能。
Eclipse CDT：
- Eclipse平台上的C/C++开发工具（CDT）。
- 提供了强大的代码编辑、调试和项目管理功能。
- 支持多种编译器和平台。
CLion：
- JetBrains开发的C/C++ IDE，提供了智能代码补全、代码分析、调试工具等功能。
- 支持CMake项目管理。
Xcode（仅限macOS）：
- 苹果公司开发的IDE，主要用于iOS和macOS应用开发，但也支持C和C++开发。
- 提供了集成调试器、代码编辑器和界面构建器。
Dev-C++：
- 一个简单、易用的C/C++ IDE，适合初学者使用。
- 基于GCC编译器，提供了基本的代码编辑和调试功能。
CodeLite：
- 一个免费、开源、跨平台的C/C++ IDE。
- 支持多种编译器，提供了代码补全、调试、版本控制集成等功能。
Qt Creator：
- 主要用于Qt框架开发的IDE，但也支持纯C和C++项目。
- 提供了代码编辑、调试、界面设计等功能。

vscode编辑器

卸载vscode

删除个人配置：win+r => %appdata% >>> code

删除插件：win+r => %userprofile% >>> .vscode

安装vscdoe

官网地址：https://code.visualstudio.com/

下载地址：https://code.visualstudio.com/Download

选择user64位

字体：22
自动保存
汉化插件：chinese
插件：code runner、c/c++

2. AI编程助手

Fitten：官网

Fitten Code是由非十大模型驱动的AI编程助手，它可以自动生成代码，提升开发效率，帮您调试Bug，节省您的时间。还可以对话聊天，解决您编程碰到的问题。免费且支持80多种语言：Python、C++、Javascript、Typescript、Java等。

安装步骤

搜索插件Fitten
注册并登录
使用方法
- ctrl+ 右箭头：接受单个词
- ctrl+alt+c : 打开对话
- 选中代码进行对话
- ctrl+alt+g : 生成代码
- 选中代码+右键
- 右下角图标进行设置

3. Hello World

创建第一个C程序 HelloWorld.c

打开VSCode
创建文件夹
创建源码文件 => HelloWorld.c
编写代码#include <stdio.h>

int main()
{
/* 我的第一个 C 程序 */
printf(“Hello, World! \n”);

return 0;
}
运行代码
- 右上角开始按钮

4、基本语法

预处理指令

在C语言中，预处理指令是在编译过程之前由预处理器处理的指令。预处理指令以井号（#）开头，用于对源代码进行一些预处理操作，如包含头文件、定义宏、条件编译等。预处理指令不会被编译器编译，而是在编译之前由预处理器处理。

// 包含头文件
// #include 指令用于包含头文件，将头文件的内容插入到当前文件中。
// 示例：

#include <stdio.h>  // 包含标准输入输出库头文件
#include "myheader.h"  // 包含自定义头文件

入口函数

在C语言中，程序的入口点是main函数。main函数是程序执行的起点，操作系统在启动程序时会调用main函数，从而开始执行程序的代码。main函数的定义形式如下：

int main(void) {
    // 程序代码
    return 0; // 正常返回0 
}

printf()函数

printf是C标准库中的一个函数，用于格式化输出。它定义在<stdio.h>头文件中，因此在调用printf之前需要包含该头文件。

当程序运行时，printf("Hello World! \n"); 这行代码会在控制台上输出以下内容：

Hello World!

并且光标会移动到下一行的开始位置。

字面量

在C语言中，字面量（Literal）是直接出现在代码中的固定值。它们是源代码的一部分，用于表示常量数据。C语言支持多种类型的字面量，包括整数、浮点数、字符和字符串。

字符串字面量：
用双引号括起来的字符序列："Hello, World!", "C Programming"

语句

在C语言中，语句（Statement）是执行特定操作的指令。每条语句都以分号（;）结尾，表示语句的结束。C语言中的语句可以分为多种类型，包括表达式语句、控制语句、复合语句等。

printf("Hello World! \n"); // 表达式语句
return 0; // 返回语句

注释

单行注释（C++风格）：//
多行注释（C风格）：/* */ 不可嵌套

VSCode快捷键 ctrl + /

5、数据类型

5-1、计算机如何处理数据

前置知识：

计算机要处理的数据（诸如数字、文字、符号、图形、音频、视频等）是以二进制的形式存放在内存中的；
数据的最小单位是比特（bit）,基本单位是字节（byte）,一个字节是8个比特位

5-2、什么是数据类型

数据类型（Data Types）用于定义变量的类型和大小，决定了变量可以存储的数据种类和范围。

C语言提供的多种数据类型让程序更加灵活和高效，同时也增加了学习成本。

而有些编程语言，例如Python、JavaScript等，在定义变量时不需要指明数据类型，编译器会根据赋值情况自动推演出数据类型，更加智能。

除了C语言Java、C++、C#等在定义变量时也必须指明数据类型，这样的编程语言称为强类型语言。

而Python、JavaScript等在定义变量时不必指明数据类型，编译系统会自动推演，这样的编程语言称为弱类型语言。

5-3、基本数据类型

基本数据类型

整数类型：
- char：字符类型，通常占用1字节，可以表示字符和小的整数。
- short：短整型，通常占用2字节。
- int：整型，通常占用2或4字节，具体取决于编译器和平台。
- long：长整型，通常占用4或8字节。
- long long：更长的整型，通常占用8字节。
浮点类型：
- float：单精度浮点型，通常占用4字节。
- double：双精度浮点型，通常占用8字节。
- long double：扩展精度浮点型，占用字节数不定，通常大于8字节。
布尔类型：
- _Bool：布尔类型，表示真（1）或假（0），在C99及以后的标准中引入，需要包含<stdbool.h>头文件以使用bool类型。

6、变量

6-1、创建变量

变量是用于存储数据的容器；常量用于保存不变的量；

int localVar = 50;
char myChar = 'A';
float myFloat = 3.14;

1. 声明（创建）变量

向内存中申请一块存储空间，语法：

数据类型 变量名;  
// 例如
int a;

2. 初始化

向申请的空间赋值，如：

a = 10;

最佳实践

声明变量的同时进行初始化

int a = 10; // 声明变量a并赋值10
a = 20;     // 更新

批量声明

一次声明多个变量，使用逗号隔开

int a = 10,b = 20;
// 不可以批量赋同一个值，需要分别赋值
int x,y,z = 1;
// 有效，但是不推荐

6-2、查看变量

1、使用printf函数打印变量

在C语言中，printf函数是一个非常常用的函数，用于在控制台打印输出。它可以用来打印各种类型的变量，包括整数、浮点数、字符、字符串等。printf函数的原型如下：

#include <stdio.h>

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

其中，format是一个格式字符串，包含了要打印的文本以及格式说明符。格式说明符以百分号（%）开头，用于指定后续参数的类型和格式。

以下是一些常见的格式说明符及其用法：

%d 或 %i：用于打印有符号十进制整数。
%u：用于打印无符号十进制整数。
%f：用于打印浮点数。
%c：用于打印字符。
%s：用于打印字符串。
%p：用于打印指针地址。

2、使用sizeof 输出变量长度

在C语言中，sizeof是一个运算符，用于获取数据类型或变量在内存中所占的字节数。sizeof运算符的语法如下：

sizeof(type)
sizeof(variable)

其中，type是一个数据类型，variable是一个变量。sizeof运算符返回一个size_t类型的值，通常是一个无符号整数

7、标识符

在C语言中，标识符是用于命名变量、函数、数组、结构体、联合体、枚举、宏等实体的名称。标识符必须遵循一定的命名规则：

组成规则：
- 标识符只能由字母（大写A-Z或小写a-z）、数字（0-9）和下划线（_）组成。
- 标识符的第一个字符必须是字母或下划线，不能是数字。
长度限制：
- C标准规定标识符的有效长度是前31个字符（对于C89标准），但对于不同的编译器和平台，这个限制可能会有所不同。
区分大小写：
- C语言是区分大小写的，因此myVar和myvar是两个不同的标识符
保留字：
- 标识符不能是C语言的保留字（如int、float、return等）

以下是一些合法的标识符示例：

int myVariable; // 小驼峰命名法
float _anotherVar; 
char this_is_a_long_variable_name;

以下是一些非法的标识符示例：

int 123variable;  // 以数字开头
float my-variable;  // 包含非法字符 '-'
char int;  // 使用保留字作为标识符

标识符的命名应该具有一定的描述性，以便于代码的阅读和维护。

良好的命名习惯可以提高代码的可读性和可维护性。

8、运算符

在C语言中，运算符用于执行各种操作，如算术运算、逻辑运算、位运算等。运算符可以分为以下几类：

算术运算符：用于执行基本的数学运算。
关系运算符：用于比较两个值。
逻辑运算符：用于执行逻辑操作。
位运算符：用于对二进制位进行操作。
赋值运算符：用于给变量赋值。
其他运算符：包括条件运算符、逗号运算符、sizeof运算符等。

以下是各类运算符的详细说明和示例：

1. 算术运算符

运算符	描述	示例
`+`	加法	`a + b`
`-`	减法	`a - b`
`*`	乘法	`a * b`
`/`	除法	`a / b`
`%`	取模（求余）	`a % b`

示例：

int a = 10, b = 3;
int sum = a + b;  // 13
int diff = a - b; // 7
int prod = a * b; // 30
int quot = a / b; // 3
int rem = a % b;  // 1

2. 关系运算符

运算符	描述	示例
==	等于	a == b
!=	不等于	a != b
>	大于	a > b
<	小于	a < b
>=	大于等于	a >= b
<=	小于等于	a <= b

示例：

int a = 10, b = 3;
int result;
result = (a == b); // 0 (false)
result = (a != b); // 1 (true)
result = (a > b);  // 1 (true)
result = (a < b);  // 0 (false)
result = (a >= b); // 1 (true)
result = (a <= b); // 0 (false)

3. 逻辑运算符

运算符	描述	示例
`&&`	逻辑与	`a && b`
`\|\|`	逻辑或	`a \|\| b`
`!`	逻辑非	`!a`

示例：

int a = 1, b = 0;
int result;
result = (a && b); // 0 (false)
result = (a || b); // 1 (true)
result = !a;       // 0 (false)

4. 位运算符

运算符	描述	示例
`&`	按位与	`a & b`
`\|`	按位或	`a \| b`
`^`	按位异或	`a ^ b`
`~`	按位取反	`~a`
`<<`	左移	`a << b`
`>>`	右移	`a >> b`

示例：

int a = 5, b = 3;
int result;
result = a & b;  // 1 (0101 & 0011 = 0001)
result = a | b;  // 7 (0101 | 0011 = 0111)
result = a ^ b;  // 6 (0101 ^ 0011 = 0110)
result = ~a;     // -6 (1's complement of 0101)
result = a << 1; // 10 (0101 << 1 = 1010)
result = a >> 1; // 2 (0101 >> 1 = 0010)

5. 赋值运算符

运算符	描述	示例
`=`	简单赋值	`a = b`
`+=`	加并赋值	`a += b`
`-=`	减并赋值	`a -= b`
`*=`	乘并赋值	`a *= b`
`/=`	除并赋值	`a /= b`
`%=`	取模并赋值	`a %= b`
`&=`	按位与并赋值	`a &= b`
`\|=`	按位或并赋值	`a \|= b`
`^=`	按位异或并赋值	`a ^= b`
`<<=`	左移并赋值	`a <<= b`
`>>=`	右移并赋值	`a >>= b`

示例：

int a = 10, b = 3;
a += b;  // a = 13
a -= b;  // a = 10
a *= b;  // a = 30
a /= b;  // a = 10
a %= b;  // a = 1

6. 其他运算符

条件运算符 (?:)：用于执行条件表达式。int a = 10, b = 3;
int max = (a > b) ? a : b; // max = 10
逗号运算符 (,)：用于分隔多个表达式，并返回最后一个表达式的值。int a = 1, b = 2;
int result = (a++, b++, a + b); // result = 4
sizeof运算符：用于计算数据类型或变量的大小。int a = 10;
printf(“Size of int: %zu bytes\n”, sizeof(int)); // 输出：Size of int: 4 bytes
printf(“Size of a: %zu bytes\n”, sizeof(a)); // 输出：Size of a: 4 bytes

通过合理使用这些运算符，可以在C语言中实现各种复杂的操作和逻辑。

9、表达式和语句

9-1、表达式

在C语言中，表达式是由操作数和运算符组成的序列，用于计算一个值。表达式可以是简单的，也可以是复杂的，它们可以包含变量、常量、函数调用和运算符。表达式的结果可以是一个值、一个变量或一个函数返回值。

以下是一些表达式的示例：

1. 常量表达式

常量表达式是由常量组成的表达式，其值在编译时就可以确定。

5
3.14
'A'

2. 变量表达式

变量表达式是由变量组成的表达式，其值在运行时可以改变。

int a = 10;
a

3. 算术表达式

算术表达式是由算术运算符和操作数组成的表达式，用于执行基本的数学运算。

int a = 10, b = 3;
a + b  // 13
a - b  // 7
a * b  // 30
a / b  // 3
a % b  // 1

4. 关系表达式

关系表达式是由关系运算符和操作数组成的表达式，用于比较两个值。

int a = 10, b = 3;
a == b  // 0 (false)
a != b  // 1 (true)
a > b   // 1 (true)
a < b   // 0 (false)
a >= b  // 1 (true)
a <= b  // 0 (false)

5. 逻辑表达式

逻辑表达式是由逻辑运算符和操作数组成的表达式，用于执行逻辑操作。

int a = 1, b = 0;
a && b  // 0 (false)
a || b  // 1 (true)
!a      // 0 (false)

6. 赋值表达式

赋值表达式是由赋值运算符和操作数组成的表达式，用于给变量赋值。

int a = 10, b = 3;
a = b;  // a 的值变为 3
a += b; // a 的值变为 6
a -= b; // a 的值变为 3
a *= b; // a 的值变为 9
a /= b; // a 的值变为 3
a %= b; // a 的值变为 0

7. 条件表达式

条件表达式是由条件运算符和操作数组成的表达式，用于执行条件判断。

int a = 10, b = 3;
int max = (a > b) ? a : b;  // max 的值为 10

8. 函数调用表达式

函数调用表达式是由函数名和参数列表组成的表达式，用于调用函数并返回结果。

#include <stdio.h>

int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(3, 4);  // result 的值为 7
    printf("Result: %d\n", result);
    return 0;
}

9. 复杂表达式

复杂表达式可以包含多个运算符和操作数，通过合理的运算符优先级和结合性来计算最终结果。

int a = 10, b = 3, c = 5;
int result = (a + b) * c / 2;  // result 的值为 35

通过组合不同的操作数和运算符，可以构建各种复杂的表达式，以实现各种计算和逻辑操作。理解表达式的组成和计算规则是掌握C语言编程的关键之一。

9-2、语句

在C语言中，语句是执行特定操作的指令。语句是程序的基本构建块，用于控制程序的执行流程和操作数据。C语言中的语句可以分为以下几类：

1. 表达式语句

表达式语句是由表达式组成的语句，通常以分号（;）结尾。表达式语句可以执行计算、赋值、函数调用等操作。

示例：

int a = 10;  // 赋值语句
a = a + 5;   // 算术表达式语句
printf("Hello, World!\n");  // 函数调用语句

2. 控制语句

控制语句用于控制程序的执行流程，包括条件判断和循环。

2.1 条件语句

条件语句用于根据条件执行不同的代码块。

if语句：int a = 10;
if (a > 5) {
printf(“a is greater than 5\n”);
}
if-else语句：int a = 10;
if (a > 5) {
printf(“a is greater than 5\n”);
} else {
printf(“a is not greater than 5\n”);
}
switch语句：int a = 2;
switch (a) {
case 1:
printf(“a is 1\n”);
break;
case 2:
printf(“a is 2\n”);
break;
default:
printf(“a is neither 1 nor 2\n”);
break;
}

2.2 循环语句

循环语句用于重复执行某段代码。

for循环：for (int i = 0; i < 5; i++) {
printf(“i is %d\n”, i);
}
while循环：int i = 0;
while (i < 5) {
printf(“i is %d\n”, i);
i++;
}
do-while循环：int i = 0;
do {
printf(“i is %d\n”, i);
i++;
} while (i < 5);

3. 跳转语句

跳转语句用于改变程序的执行流程，包括跳出循环、跳过当前迭代或跳转到指定位置。

break语句：用于跳出循环或switch语句。for (int i = 0; i < 10; i++) {
if (i == 5) {
break;
}
printf(“i is %d\n”, i);
}
continue语句：用于跳过当前循环迭代，继续下一次迭代。for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
continue;
}
printf(“i is %d\n”, i);
}
return语句：用于从函数中返回值并结束函数的执行。int add(int a, int b) {
return a + b;
}
goto语句：用于无条件跳转到程序中的标签位置（不推荐使用，容易导致代码难以维护）。int i = 0;
start:
if (i < 5) {
printf(“i is %d\n”, i);
i++;
goto start;
}

4. 复合语句

复合语句是由大括号（{}）包围的一组语句，也称为代码块。复合语句可以包含多个语句，并且在控制语句中常用。

示例：

int a = 10;
if (a > 5) {
    printf("a is greater than 5\n");
    a = a - 5;
}

5. 空语句

空语句只包含一个分号（;），用于表示没有操作。

示例：

;  // 空语句

通过合理使用这些语句，可以在C语言中实现各种复杂的逻辑和操作，构建功能强大的程序。

10、流程控制

10-1、什么是流程控制

流程：就是程序代码执行顺序

控制：通过规定的语句让程序代码有条件的按照一定的方式执行

流程分类：

顺序结构：从上到下，从左到右执行的顺序，就叫做顺序结构，程序默认就是由上到下顺序执行的。
分支结构：根据不同的情况，执行对应代码。
循环结构：重复做一件事情

流程控制语句分为：条件（判断）语句和循环语句

常见的条件语句：

if (条件) {
    // 条件为真时执行的代码
} else {
    // 条件为假时执行的代码
}

条件可以是任何表达式，表达式就是一种可以产生一个值的代码片段，产生的值不一定是布尔值。

#include <stdio.h>

int main() {
    int number = 3;

    if (number > 5) {
        printf("Number is greater than 5\n");
    } else {
        printf("Number is not greater than 5\n");
    }

    return 0;
}

常见的循环语句

while(条件表达式){
    循环体
}

10-2、布尔值

在C语言中，布尔值（Boolean values）用于表示真（true）或假（false）。然而，C语言标准在C99之前并没有内置的布尔类型。为了处理布尔值，C语言提供了以下几种方式：

1. 使用整数类型

在C99之前，通常使用整数类型来表示布尔值：

0 表示假（false）
非零值表示真（true）

示例：

#include <stdio.h>

int main() {
    int isTrue = 1; // 1 表示真
    int isFalse = 0; // 0 表示假

    if (isTrue) {
        printf("This is true\n");
    } else {
        printf("This is false\n");
    }

    if (isFalse) {
        printf("This is true\n");
    } else {
        printf("This is false\n");
    }

    return 0;
}

2. 使用C99标准引入的_Bool类型

C99标准引入了_Bool类型，专门用于表示布尔值。_Bool类型的变量只能存储0或1。

示例：

#include <stdio.h>

int main() {
    _Bool isTrue = 1; // 1 表示真
    _Bool isFalse = 0; // 0 表示假

    if (isTrue) {
        printf("This is true\n");
    } else {
        printf("This is false\n");
    }

    if (isFalse) {
        printf("This is true\n");
    } else {
        printf("This is false\n");
    }

    return 0;
}

3. 使用C99标准引入的stdbool.h头文件

为了更方便地使用布尔类型，C99标准还引入了stdbool.h头文件，其中定义了bool、true和false宏。

bool 宏展开为 _Bool
true 宏展开为 1
false 宏展开为 0

示例：

#include <stdio.h>
#include <stdbool.h>

int main() {
    bool isTrue = true; // true 表示真
    bool isFalse = false; // false 表示假

    if (isTrue) {
        printf("This is true\n");
    } else {
        printf("This is false\n");
    }

    if (isFalse) {
        printf("This is true\n");
    } else {
        printf("This is false\n");
    }

    return 0;
}

注意事项

兼容性：在C99之前的标准中，使用整数类型来表示布尔值是最常见的方法。
可读性：使用stdbool.h头文件可以使代码更具可读性，明确表示布尔类型的使用。
条件表达式：在条件语句中，任何非零值都被视为真，零值被视为假。

通过这些方法，C语言可以有效地处理布尔值，实现条件判断和逻辑控制。

10-3、条件语句

在C语言中，条件语句用于根据条件的真假来执行不同的代码块。主要的条件语句包括if语句、if-else语句、if-else if-else语句和switch语句。下面详细介绍这些条件语句的使用方法。

1. if语句

if语句用于在条件为真时执行特定的代码块。

if (条件) {
    // 条件为真时执行的代码
}

示例：

#include <stdio.h>

int main() {
    int number = 10;

    if (number > 5) {
        printf("Number is greater than 5\n");
    }

    return 0;
}

2. if-else语句

if-else语句在条件为真时执行一个代码块，在条件为假时执行另一个代码块。

if (条件) {
    // 条件为真时执行的代码
} else {
    // 条件为假时执行的代码
}

示例：

#include <stdio.h>

int main() {
    int number = 3;

    if (number > 5) {
        printf("Number is greater than 5\n");
    } else {
        printf("Number is not greater than 5\n");
    }

    return 0;
}

3. if-else if-else语句

if-else if-else语句用于在多个条件中选择一个执行。

if (条件1) {
    // 条件1为真时执行的代码
} else if (条件2) {
    // 条件2为真时执行的代码
} else {
    // 所有条件都为假时执行的代码
}

示例：

#include <stdio.h>

int main() {
    int number = 7;

    if (number > 10) {
        printf("Number is greater than 10\n");
    } else if (number > 5) {
        printf("Number is greater than 5 but not greater than 10\n");
    } else {
        printf("Number is not greater than 5\n");
    }

    return 0;
}

4. switch语句

switch语句用于根据一个表达式的值来选择执行不同的代码块。

switch (表达式) {
    case 常量1:
        // 代码块1
        break;
    case 常量2:
        // 代码块2
        break;
    default:
        // 默认代码块
}

示例：

#include <stdio.h>

int main() {
    int day = 3;

    switch (day) {
        case 1:
            printf("Monday\n");
            break;
        case 2:
            printf("Tuesday\n");
            break;
        case 3:
            printf("Wednesday\n");
            break;
        default:
            printf("Unknown day\n");
    }

    return 0;
}

注意事项

条件表达式：条件表达式必须返回一个布尔值（0表示假，非0表示真）。
代码块：如果if、else if或else后面只有一条语句，可以省略花括号{}，但不推荐这样做，因为容易引起误解和错误。
switch语句中的break：在switch语句中，每个case后面的break语句用于防止“fall-through”，即防止执行完一个case后继续执行下一个case。
嵌套条件语句：条件语句可以嵌套使用，但要注意逻辑清晰，避免过度嵌套导致代码难以维护。

通过这些条件语句，C语言可以实现复杂的条件判断和逻辑控制。

10-4、循环语句

在C语言中，循环用于重复执行某段代码，直到满足退出条件。主要的循环结构有三种：while循环、do-while循环和for循环。下面详细介绍这些循环的使用方法。

1. while循环

while循环在条件为真时重复执行代码块。

while (条件) {
    // 循环体
}

示例：

#include <stdio.h>

int main() {
    int count = 0;

    while (count < 5) {
        printf("Count: %d\n", count);
        count++;
    }

    return 0;
}

2. do-while循环

do-while循环先执行一次代码块，然后在条件为真时重复执行。

do {
    // 循环体
} while (条件);

示例：

#include <stdio.h>

int main() {
    int count = 0;

    do {
        printf("Count: %d\n", count);
        count++;
    } while (count < 5);

    return 0;
}

3. for循环

for循环通过初始化、条件判断和迭代来控制循环。

for (初始化; 条件; 迭代) {
    // 循环体
}

示例：

#include <stdio.h>

int main() {
    for (int count = 0; count < 5; count++) {
        printf("Count: %d\n", count);
    }

    return 0;
}

4. 嵌套循环

循环可以嵌套使用，即在一个循环内部包含另一个循环。

示例：

#include <stdio.h>

int main() {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("i: %d, j: %d\n", i, j);
        }
    }

    return 0;
}

10-5、跳转语句

在循环中可以使用跳转语句来改变循环的执行流程。

break语句：用于跳出循环或switch语句。

示例：

#include <stdio.h>

int main() {
    for (int i = 0; i < 10; i++) {
        if (i == 5) {
            break; // 跳出循环
        }
        printf("i: %d\n", i);
    }

    return 0;
}

continue语句：用于跳过当前循环的剩余部分，直接进入下一次循环。

示例：

#include <stdio.h>

int main() {
    for (int i = 0; i < 10; i++) {
        if (i % 2 == 0) {
            continue; // 跳过偶数
        }
        printf("i: %d\n", i);
    }

    return 0;
}

注意事项

条件表达式：循环的条件表达式必须返回一个布尔值（0表示假，非0表示真）。
无限循环：确保循环条件最终会变为假，否则会导致无限循环。
循环变量的作用域：在for循环中，循环变量的作用域仅限于循环体内。
嵌套循环的复杂性：嵌套循环会增加代码的复杂性，要注意逻辑清晰，避免过度嵌套导致代码难以维护。

通过这些循环结构和跳转语句，C语言可以实现复杂的重复执行逻辑。

11、数组

在C语言中，数组是一种用于存储相同类型数据元素的有序集合。数组的使用包括声明、初始化和访问数组元素。下面详细介绍数组的使用方法。

11-1、创建数组

1. 声明数组

声明数组时需要指定数组的类型和大小。

类型 数组名[大小];

示例：

int numbers[5]; // 声明一个包含5个整数的数组

2. 初始化数组

数组可以在声明时进行初始化，也可以在声明后逐个赋值。

声明时初始化

类型 数组名[大小] = {值1, 值2, ..., 值N};

示例：

int numbers[5] = {1, 2, 3, 4, 5}; // 声明并初始化一个包含5个整数的数组

如果初始化值的数量少于数组大小，剩余的元素将被初始化为0。

int numbers[5] = {1, 2}; // 数组内容为 {1, 2, 0, 0, 0}

逐个赋值

数组名[索引] = 值;

示例：

int numbers[5];
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[3] = 4;
numbers[4] = 5;

11-2、访问数组

访问数组元素

数组元素通过索引访问，索引从0开始。

数组名[索引];

示例：

#include <stdio.h>

int main() {
    int numbers[5] = {1, 2, 3, 4, 5};

    printf("First element: %d\n", numbers[0]); // 输出第一个元素
    printf("Third element: %d\n", numbers[2]); // 输出第三个元素

    return 0;
}

11-3、多维数组

C语言支持多维数组，最常见的是二维数组。

声明和初始化二维数组

类型 数组名[行数][列数];

示例：

int matrix[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

访问二维数组元素

数组名[行索引][列索引];

示例：

#include <stdio.h>

int main() {
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    printf("Element at (1, 1): %d\n", matrix[1][1]); // 输出第二行第二列的元素

    return 0;
}

注意事项

数组越界：访问数组时要注意索引不能超出数组范围，否则会导致未定义行为。
数组大小：数组大小在声明时必须是常量表达式。
数组传递：数组作为函数参数传递时，实际传递的是数组首元素的地址，函数内部无法知道数组的大小，需要额外传递数组大小参数。

通过这些方法，C语言可以有效地使用数组来存储和操作数据。

12、函数

在C语言中，函数用于封装可重用的代码块。函数的使用包括函数的声明、定义和调用。下面详细介绍函数的使用方法。

12-1、创建函数

1. 函数的声明

函数的声明告诉编译器函数的名称、返回类型和参数列表。函数声明通常放在头文件中或源文件的顶部。

返回类型 函数名(参数列表);

示例：

int add(int a, int b); // 声明一个返回类型为int，参数为两个int的函数

2. 函数的定义

函数的定义包含函数的具体实现。

返回类型 函数名(参数列表) {
    // 函数体
}

示例：

int add(int a, int b) {
    return a + b;
}

3. 函数的调用

函数的调用使用函数名和传递给函数的参数。

函数名(参数列表);

示例：

#include <stdio.h>

int add(int a, int b); // 函数声明

int main() {
    int result = add(3, 4); // 调用函数
    printf("Result: %d\n", result);
    return 0;
}

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

12-2、参数和返回值

参数

函数可以有零个或多个参数。参数可以是基本数据类型、数组或指针。

示例：

void printMessage(char *message) {
    printf("%s\n", message);
}

返回值

关键字：return

函数可以返回一个值，返回值的类型在函数声明和定义中指定。如果函数不返回值，使用void作为返回类型。

示例：

int getMax(int a, int b) {
    return (a > b) ? a : b;
}

void printHello() {
    printf("Hello, World!\n");
}

12-3、函数的作用域

函数内部定义的变量具有局部作用域，只在函数内部可见。函数外部定义的变量具有全局作用域，可以在整个文件中访问。

示例：

#include <stdio.h>

int globalVar = 10; // 全局变量

void printGlobalVar() {
    printf("Global Variable: %d\n", globalVar);
}

int main() {
    int localVar = 20; // 局部变量
    printf("Local Variable: %d\n", localVar);
    printGlobalVar();
    return 0;
}

注意事项

函数声明和定义：确保函数在使用前已声明或定义。
参数传递：C语言中参数传递是按值传递，函数内部对参数的修改不会影响调用者。如果需要修改参数，可以使用指针。
返回值：确保函数返回值的类型与声明一致。
递归深度：递归函数要注意栈溢出问题，避免过深的递归调用。

通过这些方法，C语言可以有效地使用函数来组织和重用代码。

13、指针

13-1、什么是指针

在C语言中，指针是一个非常重要的概念，它用于存储变量的内存地址。

通过指针，可以直接访问和操作内存中的数据。

13-2、声明指针

要声明一个指针变量，需要在变量名前加上星号（*）。例如：

int *ptr;  // 声明一个指向int类型的指针

13-3、获取变量的地址

使用取地址运算符（&）可以获取变量的地址。例如：

int num = 10;
int *ptr = &num;  // ptr现在存储了num的地址

13-4、通过指针访问变量

使用间接运算符（*）可以通过指针访问或修改指向的变量。例如：

int num = 10;
int *ptr = &num;

printf("num的值: %d\n", *ptr);  // 输出: num的值: 10

*ptr = 20;  // 通过指针修改num的值
printf("修改后的num值: %d\n", num);  // 输出: 修改后的num值: 20

13-5、指针与数组

数组名本身就是一个指向数组第一个元素的指针。例如：

int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr;  // 等价于 int *ptr = &arr[0];

printf("第一个元素: %d\n", *ptr);  // 输出: 第一个元素: 1
printf("第二个元素: %d\n", *(ptr + 1));  // 输出: 第二个元素: 2

13-6、指针与函数

指针可以作为函数参数传递，从而实现对函数外部变量的修改。例如：

void increment(int *ptr) {
    (*ptr)++;
}

int main() {
    int num = 10;
    increment(&num);
    printf("increment后的值: %d\n", num);  // 输出: increment后的值: 11
    return 0;
}

13-7、指针的指针

指针也可以指向另一个指针，形成指针的指针。例如：

int num = 10;
int *ptr = &num;
int **ptr_to_ptr = &ptr;

printf("num的值: %d\n", **ptr_to_ptr);  // 输出: num的值: 10

通过这些基本用法，可以在C语言中灵活地使用指针来操作内存和数据。

14、C预处理器

C预处理器（C Preprocessor）是C语言编译过程中的一个重要组成部分，它在实际的编译过程之前对源代码进行预处理。C预处理器的主要功能包括宏定义、文件包含、条件编译和行控制等。通过这些功能，C预处理器可以简化代码的编写、提高代码的可读性和可维护性，并且在编译时进行一些特定的处理。

主要功能

1. 宏定义（Macro Definition）

宏定义是C预处理器最常用的功能之一，通过#define指令定义宏。宏可以是一个常量、一个表达式或者一段代码片段。宏定义在预处理阶段会被替换为实际的代码。

#define PI 3.14159  // 定义一个常量宏
#define SQUARE(x) ((x) * (x))  // 定义一个带参数的宏

int main() {
    double radius = 5.0;
    double area = PI * SQUARE(radius);
    printf("圆的面积: %f\n", area);  // 输出: 圆的面积: 78.539750
    return 0;
}

2. 文件包含（File Inclusion）

文件包含功能通过#include指令将另一个文件的内容包含到当前文件中。常见的用法是包含头文件（.h文件），以便使用其中的函数声明、宏定义和类型定义等。

#include <stdio.h>  // 包含标准输入输出库的头文件

int main() {
    printf("Hello, World!\n");
    return 0;
}

3. 条件编译（Conditional Compilation）

条件编译功能通过#if、#ifdef、#ifndef、#else和#endif等指令，根据条件选择性地编译代码。这在处理不同平台或配置时非常有用。

#define DEBUG 1

#if DEBUG
    #define LOG(msg) printf("DEBUG: %s\n", msg)
#else
    #define LOG(msg)
#endif

int main() {
    LOG("This is a debug message.");  // 只有在DEBUG定义为1时才会输出
    return 0;
}

4. 行控制（Line Control）

行控制功能通过#line指令改变编译器输出的错误信息中的行号和文件名，这在生成代码或处理复杂的预处理器指令时非常有用。

#line 100 "custom_file.c"

int main() {
    // 编译器会认为这段代码在custom_file.c的第100行
    return 0;
}

5. 其他指令

还有一些其他预处理器指令，如#error、#pragma等，用于控制编译过程或生成特定的编译错误信息。

#ifndef __STDC__
    #error "This code requires a standard C compiler."
#endif

int main() {
    return 0;
}

总结

C预处理器是C语言编译过程中的一个重要工具，通过宏定义、文件包含、条件编译等功能，可以在编译前对源代码进行处理，从而简化代码的编写和维护，提高代码的可读性和可移植性。理解和掌握C预处理器的使用，对于编写高效、可维护的C代码非常重要。

15、C库

C库（C Library）是C语言编程中一组预定义的函数、宏和数据类型的集合，它们提供了基本的和高级的编程功能，以便开发者能够更方便地编写程序。C库分为标准库和非标准库两种类型。标准库是C语言标准的一部分，所有符合标准的C编译器都必须支持；而非标准库则是由第三方或特定平台提供的，可能不具有跨平台性。

标准C库

标准C库（Standard C Library）是C语言标准的一部分，包含了一系列的函数、宏和数据类型，用于处理输入输出、字符串操作、内存管理、数学计算等常见任务。标准C库的头文件通常以.h为扩展名，例如<stdio.h>、<stdlib.h>、<string.h>等。

常见的标准C库头文件和功能

<stdio.h>：标准输入输出库，提供文件操作和控制台输入输出函数，如printf、scanf、fopen、fclose等。
<stdlib.h>：标准库，提供内存管理、随机数生成、字符串转换等函数，如malloc、free、atoi、rand等。
<string.h>：字符串处理库，提供字符串操作函数，如strcpy、strcat、strlen、strcmp等。
<math.h>：数学库，提供各种数学函数，如sin、cos、sqrt、pow等。
<ctype.h>：字符处理库，提供字符分类和转换函数，如isalpha、isdigit、toupper、tolower等。
<time.h>：时间库，提供时间获取和转换函数，如time、localtime、strftime等。

非标准C库

非标准C库（Non-standard C Library）是由第三方或特定平台提供的库，它们可能不具有跨平台性，但在某些特定的应用场景中非常有用。例如，POSIX库提供了一些与操作系统相关的函数，如文件系统操作、进程控制等。

常见的非标准C库

POSIX库：提供与UNIX和类UNIX系统相关的函数，如文件系统操作、进程控制、信号处理等。
Windows API：提供与Windows操作系统相关的函数，如图形界面、多线程、网络编程等。
第三方库：如GLib、SQLite、OpenSSL等，提供特定功能的实现，如数据结构、数据库、加密等。

使用C库

使用C库通常需要包含相应的头文件，并在编译时链接相应的库文件。例如，使用标准C库中的printf函数：

#include <stdio.h>  // 包含标准输入输出库的头文件

int main() {
    printf("Hello, World!\n");  // 使用printf函数输出字符串
    return 0;
}

编译和运行上述代码时，编译器会自动链接标准C库，因此不需要额外的链接步骤。

总结

C库是C语言编程中一组预定义的函数、宏和数据类型的集合，它们提供了基本的和高级的编程功能。标准C库是C语言标准的一部分，所有符合标准的C编译器都必须支持；而非标准库则是由第三方或特定平台提供的，可能不具有跨平台性。理解和掌握C库的使用，对于编写高效、可维护的C代码非常重要。

语法详解

1、进制

编程中经常使用不同的进制数表示数字

常见的进制有以下几种：

二进制（Binary）：使用0和1表示数字，前缀为0b或0B。例如，0b1010表示十进制的10。
八进制（Octal）：使用0到7表示数字，前缀为0。例如，012表示十进制的10。
十进制（Decimal）：使用0到9表示数字，没有前缀。例如，10表示十进制的10。
十六进制（Hexadecimal）：使用0到9和A到F（或a到f）表示数字，前缀为0x或0X。例如，0xA表示十进制的10。

1-1、十进制

十进制（Decimal）是一种基数为10的数制系统，使用0到9这十个数字来表示数值。

运算规则：逢十进一

0，1，2，3，4，5，6，7，8，9，10

00，01，02，03，04，05，06，07，08，09，10

在十进制系统中，每个数字的位置表示其对应的权重，从右到左依次是个位、十位、百位、千位等，每个位置的权重是10的幂次。

例如，数字1234在十进制中表示:
1234= 1x10**3 + 2X10**2 + 3X10**1 + 4X10**0

十进制的一位可以表示多少个数？

在计算器中使用十进制数

电脑搜索计算器

1-2、二进制

二进制是一种基于2的数字系统，它只使用两个数字：0和1。这与我们日常生活中使用的十进制系统（基于10，使用0到9的数字）不同。二进制系统是计算机科学和数字电子学的基础，因为计算机的硬件（如CPU和内存）都是基于二进制逻辑设计的。

运算规则：逢二进一

0，1，10，11，100，101，110

000，001，010，011，100，101，110

在二进制系统中，每一位（bit）代表一个2的幂次方。例如：

最低位（最右边）是2^0（即1）
下一位是2^1（即2）
再下一位是2^2（即4）
以此类推

因此，一个二进制数可以表示为这些位的和。例如，二进制数101可以转换为十进制数如下：

101 (二进制) = 1 * 2^2 + 0 * 2^1 + 1 * 2^0 = 4 + 0 + 1 = 5 (十进制)

同样地，十进制数也可以转换为二进制数。例如，十进制数5可以转换为二进制数如下：

5 (十进制) = 1 * 2^2 + 0 * 2^1 + 1 * 2^0 = 101 (二进制)

二进制系统在计算机科学中非常重要，因为它允许计算机以非常简单和高效的方式存储和处理数据。每个二进制位（bit）可以表示一个开关状态（开或关），这对应于电子电路中的高电平或低电平。通过组合多个二进制位，计算机可以表示和处理各种类型的数据，如数字、文本、图像和声音。

1-3、八进制和十六进制

八进制（Octal）

八进制数以数字 0 开头，后面跟随八进制数字（0到7）

int a = 012

十六进制（Hexadecimal）

十六进制数以 0x 或 0X 开头，后面跟随十六进制数字（0到9，A到F或a到f）。

int a = 0x11

1-4、打印不同进制的数

在C语言中，可以使用不同的格式说明符来打印不同进制的数。以下是一些常用的格式说明符及其示例：

十进制（Decimal）：使用 %d 或 %i 格式说明符。
八进制（Octal）：使用 %o 格式说明符。
十六进制（Hexadecimal）：使用 %x 或 %X 格式说明符。%x 输出小写字母，%X 输出大写字母。

printf的格式说明符：

%d 或 %i：用于输出有符号十进制整数
%u：用于输出无符号十进制整数。
%x 或 %X：用于输出无符号十六进制整数（小写或大写）。
%o：用于输出无符号八进制整数。

以下是一个示例程序，展示了如何打印不同进制的数：

#include <stdio.h>

int main() {
    int number = 255;

    // 打印十进制数
    printf("十进制: %d\n", number);

    // 打印八进制数
    printf("八进制: %o\n", number);

    // 打印十六进制数（小写字母）
    printf("十六进制 (小写): %x\n", number);

    // 打印十六进制数（大写字母）
    printf("十六进制 (大写): %X\n", number);

    return 0;
}

运行上述程序将输出：

十进制: 255
八进制: 377
十六进制 (小写): ff
十六进制 (大写): FF

通过这些格式说明符，你可以方便地在C语言中打印不同进制的数。

2、整数类型

学习目标：

掌握整数数据类型
熟悉有符号和无符号的定义方法
学会打印有符号和无符号的整数
了解不同整数类型的取值范围

在C语言中，可以使用不同的格式说明符来打印不同类型的整数。以下是一些常见的整数类型及其对应的格式说明符：

char：字符类型，通常是1字节（8位），可以是有符号或无符号的。char ch = ‘A’;
unsigned char uch = 255;
printf(“The character is %c\n”, ch); // 使用%c打印字符
printf(“The unsigned char is %hhu\n”, uch); // 使用%hhu打印无符号字符
short：短整型，通常是2字节（16位），可以是有符号或无符号的。short s = 32767;
unsigned short us = 65535;
printf(“The short is %hd\n”, s); // 使用%hd打印有符号短整型
printf(“The unsigned short is %hu\n”, us); // 使用%hu打印无符号短整型
int：整型，通常是4字节（32位），可以是有符号或无符号的。int i = 2147483647;
unsigned int ui = 4294967295;
printf(“The int is %d\n”, i); // 使用%d打印有符号整型
printf(“The unsigned int is %u\n”, ui); // 使用%u打印无符号整型
long ：长整型，通常是4字节（32位）或8字节（64位），可以是有符号或无符号的。long l = 2147483647L;
unsigned long ul = 4294967295UL;
printf(“The long is %ld\n”, l); // 使用%ld打印有符号长整型
printf(“The unsigned long is %lu\n”, ul); // 使用%lu打印无符号长整型
long long ：长长整型，通常是8字节（64位），可以是有符号或无符号的。long long ll = 9223372036854775807LL;
unsigned long long ull = 18446744073709551615ULL;
printf(“The long long is %lld\n”, ll); // 使用%lld打印有符号长长整型
printf(“The unsigned long long is %llu\n”, ull); // 使用%llu打印无符号长长整型

以下是一个完整的示例程序，展示了如何打印不同类型的整数：

#include <stdio.h>

int main() {
    char ch = 'A';
    unsigned char uch = 255;
    short s = 32767;
    unsigned short us = 65535;
    int i = 2147483647;
    unsigned int ui = 4294967295;
    long l = 2147483647L;
    unsigned long ul = 4294967295UL;
    long long ll = 9223372036854775807LL;
    unsigned long long ull = 18446744073709551615ULL;

    printf("The character is %c\n", ch);
    printf("The unsigned char is %hhu\n", uch);
    printf("The short is %hd\n", s);
    printf("The unsigned short is %hu\n", us);
    printf("The int is %d\n", i);
    printf("The unsigned int is %u\n", ui);
    printf("The long is %ld\n", l);
    printf("The unsigned long is %lu\n", ul);
    printf("The long long is %lld\n", ll);
    printf("The unsigned long long is %llu\n", ull);

    return 0;
}

运行这个程序将输出不同类型的整数，每个整数都以其对应的格式说明符打印。

这些整数类型的大小和范围取决于具体的编译器和平台。可以使用sizeof运算符来确定每种类型的大小：

#include <stdio.h>

int main() {
    printf("Size of char: %zu bytes\n", sizeof(char));
    printf("Size of short: %zu bytes\n", sizeof(short));
    printf("Size of int: %zu bytes\n", sizeof(int));
    printf("Size of long: %zu bytes\n", sizeof(long));
    printf("Size of long long: %zu bytes\n", sizeof(long long));
    return 0;
}

输出结果将显示每种类型在当前平台上的大小。

在使用这些整数类型时，需要注意它们的范围。有符号整数类型的范围是从负数到正数，而无符号整数类型的范围是从0到正数。例如：

char：-128 到 127（有符号），0 到 255（无符号）
short：-32768 到 32767（有符号），0 到 65535（无符号）
int：-2147483648 到 2147483647（有符号），0 到 4294967295（无符号）
long：通常与int相同，但在某些平台上可能更大
long long：-9223372036854775808 到 9223372036854775807（有符号），0 到 18446744073709551615（无符号）

如果超过取值范围，则是整数溢出

选择合适的整数类型可以确保程序的正确性和效率。

3、char类型

在C语言中，char类型用于表示字符数据。它是一个整数类型，通常占用1个字节（8位）的内存空间。char类型可以用来存储ASCII字符集中的字符，每个字符都有一个对应的整数值。

例如：

char ch = 'A';  // 存储字符 'A'，其ASCII值为65


printf("The character is: %c\n", ch);

char类型也可以用来存储小整数值，范围通常是-128到127（有符号char）或0到255（无符号char）。可以通过在类型前加上unsigned关键字来定义无符号的char类型：

unsigned char uch = 255;  // 无符号char，范围是0到255

打印无符号字符的字符形式

#include <stdio.h>

int main() {
    unsigned char uch = 65;  // 对应字符 'A'
    printf("The character is: %c\n", uch);
    return 0;
}

打印无符号字符的数值形式

#include <stdio.h>

int main() {
    unsigned char uch = 65;  // 对应字符 'A'
    printf("The value is: %hhu\n", uch);
    return 0;
}

在C语言中，字符常量用单引号括起来，例如'A'，而字符串常量用双引号括起来，例如"Hello, World!"。

拓展知识：

ASCII编码

百度百科：https://baike.baidu.com/item/ASCII/309296

ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是一种基于拉丁字母的计算机编码系统。它使用7位二进制数来表示128个字符，包括英文字母、数字、标点符号和一些控制字符。ASCII编码是最早的字符编码标准之一，广泛用于计算机系统中。

例如：

字符 ‘A’ 的ASCII值是 65
字符 ‘a’ 的ASCII值是 97
字符 ‘0’ 的ASCII值是 48

Unicode

Unicode是一种国际编码标准，旨在为世界上所有的字符提供一个唯一的数字代码。Unicode编码可以表示几乎所有的语言字符，包括中文、日文、韩文等。Unicode字符集非常庞大，可以容纳超过100万个字符。

Unicode字符通常用16进制表示，例如：

字符 ‘A’ 的Unicode码点是 U+0041
字符 ‘你’ 的Unicode码点是 U+4F60

UTF-8

UTF-8（8-bit Unicode Transformation Format）是一种针对Unicode的可变长度字符编码。它可以用1到4个字节来表示一个字符，能够兼容ASCII编码。UTF-8是目前最常用的Unicode编码方式之一，广泛应用于互联网、文件存储和数据传输等领域。

UTF-8的特点：

对于ASCII字符（U+0000到U+007F），UTF-8使用1个字节表示，与ASCII编码完全相同。
对于其他Unicode字符，UTF-8使用2到4个字节表示。

例如：

字符 ‘A’ 在UTF-8中编码为 0x41（1个字节）
字符 ‘你’ 在UTF-8中编码为 0xE4BDA0（3个字节）

总结来说，ASCII是一种早期的字符编码标准，Unicode是一个广泛的字符编码标准，而UTF-8是Unicode的一种具体实现方式，具有良好的兼容性和高效性。

4、浮点类型

在C语言中，浮点类型用于表示带有小数部分的数值。浮点类型可以表示非常大或非常小的数值，并且可以包含小数部分。C语言提供了三种主要的浮点类型：float、double和long double。

浮点类型

float：单精度浮点数，通常占用4个字节（32位）的内存空间。
double：双精度浮点数，通常占用8个字节（64位）的内存空间，精度比float更高。
long double：扩展精度浮点数，占用内存空间通常大于8个字节（64位），具体大小依赖于编译器和平台，精度比double更高。

示例代码

以下是一些示例代码，演示如何声明和使用浮点类型：

#include <stdio.h>

int main() {
    float f = 3.14f;  // 单精度浮点数
    double d = 3.141592653589793;  // 双精度浮点数
    long double ld = 3.14159265358979323846L;  // 扩展精度浮点数

    printf("float: %f\n", f);
    printf("double: %lf\n", d);
    printf("long double: %Lf\n", ld);

    return 0;
}

格式说明

%f：用于打印float和double类型的值。
%lf：用于打印double类型的值（虽然%f也可以用于double，但%lf更明确）。
%Lf：用于打印long double类型的值。

注意事项

浮点数在内存中的表示方式与整数不同，因此浮点数的运算和比较需要特别注意精度问题。
浮点数的精度是有限的，特别是在进行复杂的数学运算时，可能会出现舍入误差。

通过这些示例和解释，你应该对C语言中的浮点类型有了基本的了解。根据具体需求选择合适的浮点类型，并使用相应的格式说明符进行输出。

5、字符串

5-1、创建字符串

在C语言中，字符串是一个以空字符（\0）结尾的字符数组。字符串用于存储文本数据，如单词、句子或任何其他字符序列。以下是对C语言中字符串的详细解释：

字符串的定义

字符串可以定义为字符数组，并以空字符（\0）结尾。空字符是一个特殊的字符，其ASCII值为0，用于标识字符串的结束。

字符串的初始化

字符串可以通过以下几种方式进行初始化：

字符数组初始化：

char str1[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

字符串字面量初始化：

char str2[] = "Hello";  // 编译器会自动添加'\0'

字符指针初始化：

char *str3 = "Hello";  // 指向字符串常量

5-2、打印字符串

在C语言中，打印字符串是一个常见的操作。可以使用标准库函数printf来实现。printf函数是一个格式化输出函数，可以通过指定不同的格式说明符来打印不同类型的数据，包括字符串。

打印字符串的基本方法

使用printf函数打印字符串时，需要使用%s格式说明符。以下是一些示例代码，演示如何打印字符串：

示例1：打印字符数组

#include <stdio.h>

int main() {
    char str[] = "Hello, World!";
    printf("The string is: %s\n", str);
    return 0;
}

示例2：打印字符指针

#include <stdio.h>

int main() {
    char *str = "Hello, World!";
    printf("The string is: %s\n", str);
    return 0;
}

打印字符串长度

在C语言中，可以使用strlen函数来计算字符串的长度，并使用printf函数来打印这个长度。以下是详细的步骤和示例代码。

步骤

包含必要的头文件：<stdio.h> 和 <string.h>。
使用strlen函数计算字符串的长度。
使用printf函数打印字符串的长度。

示例1：打印字符数组的长度

#include <stdio.h>
#include <string.h>

int main() {
    char str[] = "Hello, World!";
    size_t length = strlen(str);
    printf("The length of the string is: %zu\n", length);
    return 0;
}

示例2：打印字符指针指向的字符串长度

#include <stdio.h>
#include <string.h>

int main() {
    char *str = "Hello, World!";
    size_t length = strlen(str);
    printf("The length of the string is: %zu\n", length);
    return 0;
}

6、常量

在C语言中，常量是指在程序运行过程中其值不能被改变的量。常量可以是字面量（直接写在代码中的值）或通过const关键字定义的变量。以下是一些常见的常量类型：

字面量常量

字面量常量是直接写在代码中的值，包括以下几种类型：

整数常量：例如 123, -456, 0xFF（十六进制）, 0123（八进制）。
浮点常量：例如 3.14, -0.001, 1.23e-4。
字符常量：例如 'a', 'B', '\n'（转义字符）。
字符串常量：例如 "Hello, World!"。

const关键字定义的常量

使用const关键字可以将变量定义为常量，其值在初始化后不能被修改。

const int MAX_SIZE = 100;
const float PI = 3.14159;
const char *MESSAGE = "Hello, World!";

以下是一个示例代码，演示了常量的使用：

#include <stdio.h>

int main() {
    // 整数常量
    const int MAX_SIZE = 100;
    // 浮点常量
    const float PI = 3.14159;
    // 字符常量
    const char CHAR_A = 'A';
    // 字符串常量
    const char *MESSAGE = "Hello, World!";

    printf("Integer constant: %d\n", MAX_SIZE);
    printf("Float constant: %f\n", PI);
    printf("Character constant: %c\n", CHAR_A);
    printf("String constant: %s\n", MESSAGE);

    return 0;
}

#define定义常量

除了使用const关键字定义常量外，还可以使用预处理器指令#define来定义常量。#define是一个预处理指令，用于在编译之前替换代码中的标识符。

#define指令的基本语法如下：

#define 标识符 替换文本

以下是一个示例代码，演示了如何使用#define定义常量：

#include <stdio.h>

// 使用#define定义常量
#define MAX_SIZE 100
#define PI 3.14159
#define MESSAGE "Hello, World!"

int main() {
    printf("Integer constant: %d\n", MAX_SIZE);
    printf("Float constant: %f\n", PI);
    printf("String constant: %s\n", MESSAGE);

    return 0;
}

比较const和#define

类型安全：const定义的常量有类型信息，编译器会进行类型检查。
作用域：const定义的常量有作用域，而#define定义的常量没有作用域，会在整个文件中进行替换。
调试：const定义的常量可以进行调试，而#define定义的常量在调试时看不到替换后的值。

注意事项

常量一般使用大写字母，这是一个约定
使用const关键字定义的常量在初始化后不能被修改，否则会导致编译错误。
字符串常量（如"Hello, World!"）在内存中以只读形式存储，不能被修改。

下载权限

查看

￥

免费下载

评论并刷新后下载

登录后下载

查看演示

{{attr.name}}：

您当前的等级为

登录后免费下载登录小黑屋反思中，不准下载！评论后刷新页面下载评论支付以后下载请先登录您今天的下载次数（次）用完了，请明天再来支付积分以后下载立即支付支付以后下载立即支付您当前的用户组不允许下载升级会员

您已获得下载权限您可以每天下载资源次，今日剩余次

{{userData.name}}已认证

初始C语言

1、C语言简介

2、C语言历史

3、C语言能做什么

4、C语言开发流程

5、编译原理

6、编译器

7、安装MinGW

8、第一个C程序

快速入门

1. 开发环境

2. AI编程助手

3. Hello World

4、基本语法

5、数据类型

5-1、计算机如何处理数据

5-2、什么是数据类型

5-3、基本数据类型

6、变量

6-1、创建变量

6-2、查看变量

7、标识符

8、运算符

9、表达式和语句

9-1、表达式

9-2、语句

10、流程控制

10-1、什么是流程控制

10-2、布尔值

10-3、条件语句

10-4、循环语句

10-5、跳转语句

11、数组

11-1、创建数组

11-2、访问数组

11-3、多维数组

12、函数

12-1、创建函数

12-2、参数和返回值

12-3、函数的作用域

13、指针

13-1、什么是指针

13-2、声明指针

13-3、获取变量的地址

13-4、通过指针访问变量

13-5、指针与数组

13-6、指针与函数

13-7、指针的指针

14、C预处理器

15、C库

语法详解

1、进制

1-1、十进制

1-2、二进制

1-3、八进制和十六进制

1-4、打印不同进制的数

2、整数类型

3、char类型

4、浮点类型

5、字符串

5-1、创建字符串

5-2、打印字符串

6、常量

注意事项