【C语言】拯救新手，半小时从零到一认识C语言基础

梦里梦外; 2022-10-06 11:53 162阅读 0赞

**目录**

前言

一、环境

1.1 安装Dev-C++

1.2 首次使用配置

二、Hello baiyu

三、变量及赋值

四、数据类型

4.1 基本数据类型

五、格式化输出

5.1 整数

5.2 字符及字符串

5.3 小结

六、运算符

6.1 算术运算符

6.2 关系运算符

6.3 逻辑运算符

七、程序结构

7.1 顺序结构

7.2 分支结构

7.2.1 if-else语句

7.2.2 只使用if语句

7.2.3 if-else语句的嵌套

7.3 循环结构

7.3.1 while 循环

7.3.2 do-while循环

7.3.3 for循环

总结

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

# **前言** #

今年家里有小朋友开始接触编程，有时也会问我一些问题，索性把C语言新手入门的东西都整理一遍。本教程适合零基础的、想要学习C语言的大小朋友们。

本文会讲到的内容：

*  数据类型
 *  格式化输出
 *  运算符
 *  程序结构

# **一、环境** #

工欲善其事必先利其器，首先，咱们要有环境

系统：win10

IDE：Dev C++

这里提供了工具下载，没有工具的小朋友们可以戳这里

链接: [Dev C++ 安装包][Dev C_] 提取码: q5se

## **1.1 安装****Dev-C++** ##

![20210613141939650.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 2][]

## **1.2 首次使用配置** ##

选择中文

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 3][]

颜色推荐Obsidian，因为这个颜色看久了眼睛也不会特别累

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 5][]

# **二、Hello baiyu** #

新建一个源代码文件

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 6][]

写入代码内容，请直接粘贴复制，后面会解析的

#include <stdio.h>
 int main()
 {
 //这里是白玉写的注释
 printf("Hello, baiyu! \n");
 /*这里是白玉写的另外一种注释
 这种注释是可以多行的
 不信，你看
 */
 return 0;
 }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 7][]

保存源代码文件，这里记得选择是【C source files(\*.c)】,因为咱们的C语言源文件就是以【.c】结尾的。以【.cpp】结尾的文件是C++源代码文件。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 8][]

点击【运行】

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 9][]

此时代码还没编译，会提示你是否编译，点击是

因为C语言是编译型语言，在运行之前，要编译链接

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 10][]

运行截图如下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 10][]

至此，咱们的第一个C语言的程序就这样完成啦

注：

**编译型语言**：程序在执行之前需要一个专门的编译过程，把程序编译成为机器语言的文件，运行时不需要重新翻译。编译型语言有C、C++、go

**解释型语言**：是相对于编译型语言而言的，源代码不是直接翻译成机器语言，运行时需要一个解释器对源代码进行逐行解释的语言。Javascript、python

**半解释半编译语言**：代码需要先转换成一种中间文件（字节码文件），然后再将中间文件拿到虚拟机中执行。有Java和C\#，java是运行在JVM上，而C\#是运行在.net上

# **三、变量及赋值** #

咱们在小学数学，就学过代数x，这个x是可以代表任何数的，在咱们编程语言里面，就把这个可变的数值称之为变量。变量是有名字的，称之为变量名。比如咱们前面提到的x，这个x就是一个变量名。

咱们在定义一个变量之前呢，要先定义一个变量名

> 数据类型 变量名

对于变量的赋值，咱们有两种方式：

1.  先声明再赋值
2.  声明的同时赋值

#include <stdio.h>
 int main()
 {
 int i_baiyu;//定义一个变量
 i_baiyu = 666;//给变量进行赋值，把666赋值给i_baiyu这个变量名
 
 //声明定义变量的同时，把520这个值赋值给到i_baiyu_1这个变量 
 int i_baiyu_1 = 520;
 
 return 0;
 }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 11][]

# **四、数据类型** #

C语言的数据类型大致可以分类四大类：

*  基本数据类型
 *  构造类型
 *  指针类型
 *  空类型

本文主要面向零基础的同学，入门就先了解一下基本的数据类型

## **4.1 基本数据类型** ##

C 语言里有六种基本数据类型，分别用short、int、long、char、float、double 这六个关键字表示

<table style="margin-left:.5pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> 数据类型 </td> 
 <td style="vertical-align:top;width:100pt;"> 名称 </td> 
 <td style="vertical-align:top;width:100pt;"> 占用内存 </td> 
 <td style="vertical-align:top;width:490pt;"> 值范围 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> char </td> 
 <td style="vertical-align:top;width:100pt;"> </td> 
 <td style="vertical-align:top;width:100pt;"> 1 byte </td> 
 <td style="vertical-align:top;width:490pt;"> -128 到 127 或 0 到 255 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> short </td> 
 <td style="vertical-align:top;width:100pt;"> </td> 
 <td style="vertical-align:top;width:100pt;"> 2 byte </td> 
 <td style="vertical-align:top;width:490pt;"> -32,768 到 32,767 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> int </td> 
 <td style="vertical-align:top;width:100pt;"> </td> 
 <td style="vertical-align:top;width:100pt;"> 4 byte </td> 
 <td style="vertical-align:top;width:490pt;"> -2,147,483,648 到 2,147,483,647 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> long </td> 
 <td style="vertical-align:top;width:100pt;"> </td> 
 <td style="vertical-align:top;width:100pt;"> 4 byte </td> 
 <td style="vertical-align:top;width:490pt;"> -2,147,483,648 到 2,147,483,647 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> float </td> 
 <td style="vertical-align:top;width:100pt;"> </td> 
 <td style="vertical-align:top;width:100pt;"> 4 byte </td> 
 <td style="vertical-align:top;width:490pt;"> 1.2E-38 到 3.4E+38v </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> double </td> 
 <td style="vertical-align:top;width:100pt;"> </td> 
 <td style="vertical-align:top;width:100pt;"> 8 byte </td> 
 <td style="vertical-align:top;width:490pt;"> 2.3E-308 到 1.7E+308 </td> 
 </tr> 
 </tbody> 
</table>

注：一个字节（byte）＝8位（bit），值范围就是2的几次方，比如char型是一个字节，也就是8位，所以char型变量的取值最大就是2^8=255

#include <stdio.h>
 int main()
 {
 char c_baiyu = 'a';//字符类型
 char c_baiyu_1 = 97;//字符类型也可以用ASCII码赋值
 
 printf("字符型数据 c_baiyu：%c\n",c_baiyu) ;
 printf("字符型数据 c_baiyu_1：%c\n",c_baiyu_1) ;
 
 short s_baiyu = 11;
 printf("短整型数据 s_baiyu：%d\n",s_baiyu) ;
 
 int i_baiyu = 100;
 printf("整型数据 i_baiyu：%d\n",i_baiyu) ;
 
 long l_baiyu = 666;
 printf("长整型数据 l_baiyu：%d\n",l_baiyu) ;
 
 float f_baiyu = 1.0;
 printf("单精度浮点型数据 f_baiyu：%f\n",f_baiyu) ;
 
 double d_baiyu = 2.22222;
 printf("双精度浮点型数据 d_baiyu：%f\n",d_baiyu) ;
 
 return 0;
 }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 12][]

# **五、格式化输出** #

前面咱们几个小例子都用到了printf()，咱们只是知道了它是C语言的一个输出函数，接下来咱们来仔细的剖析一下这个输出函数。

咱们在引用这个输出函数之前，咱们首先需要引入这个头文件，这个头文件。这个是在C语言里面的标准库的头文件

printf()函数是最常用的格式化输出函数，其原型为：

> int printf( char \* format, ... );

printf()会根据参数 format 字符串来转换并格式化数据，然后将结果输出到标准输出设备（显示器），直到出现字符串结束('\\0')为止。后面的省略号...就是代表可变的参数

## **5.1 整数** ##

*  %d 输出十进制的整数，如果输入的是字符，会输出对应的ASCII码
 *  %o 输出八进制的整数
 *  %x 输出十六进制的小写
 *  %X 输出十六进制的大写
 *  %f 输出浮点数

## **5.2 字符及字符串** ##

*   %c 输出字符，如果输出的是数字0~126，则会输出ASCII码表对应的符号
 *   %s 输出字符串里的字符，直到出现NULL 字符为止

#include<stdio.h>
 int main(void)
 {
 int i_baiyu = 97;
 char c_baiyu = 'a';
 float f_baiyu = 5.0;
 char str_baiyu[100]= "https://blog.csdn.net/zhh763984017";
 
 // 整数
 printf("int 整数输出：%d\n",i_baiyu); 
 // 八进制数
 printf("int 八进制数输出：%o\n",i_baiyu); 
 // 十六进制数 
 printf("int 十六进制数小写输出: %x\n",i_baiyu);
 // 十六进制大写输出 
 printf("int 十六进制数大写输出: %X\n",i_baiyu);
 // 浮点数输出 
 printf("浮点数输出: %f\n",f_baiyu);
 
 // 字符
 printf("输出单个字符: %c\n",c_baiyu);
 // ASCII码输出字符
 printf("ASCII码输出字符 : %c\n",i_baiyu);
 // 输出字符对应的ASCII码
 printf("输出字符对应的ASCII码: %d\n",c_baiyu) ;
 // 字符串
 printf("输出字符串: %s\n",str_baiyu);
 
 return 0;
 }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 13][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 14][]

## **5.3 小结** ##

<table style="margin-left:.5pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> 格式 </td> 
 <td style="vertical-align:top;"> 含义 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> %d </td> 
 <td style="vertical-align:top;"> 整数的参数会被转成有符号的十进制数字 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> %u </td> 
 <td style="vertical-align:top;"> 整数的参数会被转成无符号的十进制数字 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> %o </td> 
 <td style="vertical-align:top;"> 整数的参数会被转成无符号的八进制数字 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> %x </td> 
 <td style="vertical-align:top;"> 整数的参数会被转成无符号的十六进制数字，并以小写abcdef 表示 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> %X </td> 
 <td style="vertical-align:top;"> 整数的参数会被转成无符号的十六进制数字，并以大写ABCDEF 表示浮点型数 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> %f </td> 
 <td style="vertical-align:top;"> double 型的参数会被转成十进制数字，并取到小数点以下六位，四舍五入 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> %e </td> 
 <td style="vertical-align:top;"> double 型的参数以指数形式打印，有一个数字会在小数点前，六位数字在小数点后，而在指数部分会以小写的e 来表示 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> %E </td> 
 <td style="vertical-align:top;"> 与%e 作用相同，唯一区别是指数部分将以大写的E 来表示 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> %g </td> 
 <td style="vertical-align:top;"> double 型的参数会自动选择以%f 或%e 的格式来打印，其标准是根据打印的数值及所设置的有效位数来决定。 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> %G </td> 
 <td style="vertical-align:top;"> 与%g 作用相同，唯一区别在以指数形态打印时会选择%E 格式。 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> %c </td> 
 <td style="vertical-align:top;"> 整型数的参数会被转成unsigned char 型打印出 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> %s </td> 
 <td style="vertical-align:top;"> 指向字符串的参数会被逐字输出，直到出现NULL 字符为止 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:100pt;"> %p </td> 
 <td style="vertical-align:top;"> 如果是参数是"void *"型指针则使用十六进制格式显示 </td> 
 </tr> 
 </tbody> 
</table>

# **六、运算符** #

C语言的运算符有以下几种：

*  算术运算符
 *  关系运算符
 *  逻辑运算符
 *  位运算符
 *  赋值运算符

在这里我就先介绍一下算术运算符、关系运算符和逻辑运算符

## **6.1 算术运算符** ##

算术运算符，就是跟咱们小学时候学习的四则运算一样的，有加减乘除，只不过在C语言里面的除法，有分两种，一种是整除【/】，一种是取余【%】

接下来咱们举个例子，也结合下面的表格，可以更清楚的了解，C语言的算术运算符。例如有两个数，A=10，B=21，C是A和B运算的结果

<table style="margin-left:.5pt;"> 
 <tbody> 
 <tr> 
 <td style="background-color:#3370ff;width:105pt;"> 运算符 </td> 
 <td style="background-color:#3370ff;width:225pt;"> 描述 </td> 
 <td style="background-color:#3370ff;width:415pt;"> 实例 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:105pt;"> + </td> 
 <td style="vertical-align:top;width:225pt;"> 把两个操作数相加 </td> 
 <td style="vertical-align:top;width:415pt;"> C = A + B，C = 31 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:105pt;"> - </td> 
 <td style="vertical-align:top;width:225pt;"> 从第一个操作数中减去第二个操作数 </td> 
 <td style="vertical-align:top;width:415pt;"> C = A - B，C = -11 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:105pt;"> * </td> 
 <td style="vertical-align:top;width:225pt;"> 把两个操作数相乘 </td> 
 <td style="vertical-align:top;width:415pt;"> C = A * B 将得到 210 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:105pt;"> / </td> 
 <td style="vertical-align:top;width:225pt;"> 分子除以分母 </td> 
 <td style="vertical-align:top;width:415pt;"> C = B / A 将得到 2 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:105pt;"> % </td> 
 <td style="vertical-align:top;width:225pt;"> 取模运算符，整除后的余数 </td> 
 <td style="vertical-align:top;width:415pt;"> C = B % A 将得到 1 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:105pt;"> ++ </td> 
 <td style="vertical-align:top;width:225pt;"> 自增运算符，整数值增加 1 </td> 
 <td style="vertical-align:top;width:415pt;"> A++ 将得到 11 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:105pt;"> -- </td> 
 <td style="vertical-align:top;width:225pt;"> 自减运算符，整数值减少 1 </td> 
 <td style="vertical-align:top;width:415pt;"> A-- 将得到 9 </td> 
 </tr> 
 </tbody> 
</table>

## **6.2 关系运算符** ##

<table style="margin-left:.5pt;"> 
 <tbody> 
 <tr> 
 <td style="background-color:#4e83fd;width:89pt;"> 运算符 </td> 
 <td style="background-color:#4e83fd;width:422pt;"> 描述 </td> 
 <td style="background-color:#4e83fd;width:229pt;"> 实例 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:89pt;"> == </td> 
 <td style="vertical-align:top;width:422pt;"> 检查两个操作数的值是否相等，如果相等则条件为真。 </td> 
 <td style="vertical-align:top;width:229pt;"> (A == B) 为假。 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:89pt;"> != </td> 
 <td style="vertical-align:top;width:422pt;"> 检查两个操作数的值是否相等，如果不相等则条件为真。 </td> 
 <td style="vertical-align:top;width:229pt;"> (A != B) 为真。 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:89pt;"> &gt; </td> 
 <td style="vertical-align:top;width:422pt;"> 检查左操作数的值是否大于右操作数的值，如果是则条件为真。 </td> 
 <td style="vertical-align:top;width:229pt;"> (A &gt; B) 为假。 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:89pt;"> &lt; </td> 
 <td style="vertical-align:top;width:422pt;"> 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 </td> 
 <td style="vertical-align:top;width:229pt;"> (A &lt; B) 为真。 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:89pt;"> &gt;= </td> 
 <td style="vertical-align:top;width:422pt;"> 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 </td> 
 <td style="vertical-align:top;width:229pt;"> (A &gt;= B) 为假。 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:89pt;"> &lt;= </td> 
 <td style="vertical-align:top;width:422pt;"> 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 </td> 
 <td style="vertical-align:top;width:229pt;"> (A &lt;= B) 为真。 </td> 
 </tr> 
 </tbody> 
</table>

## **6.3 逻辑运算符** ##

<table style="margin-left:.5pt;"> 
 <tbody> 
 <tr> 
 <td style="background-color:#4e83fd;width:80px;"> 运算符 </td> 
 <td style="background-color:#4e83fd;width:597px;"> 描述 </td> 
 <td style="background-color:#4e83fd;width:217px;"> 实例 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:80px;"> &amp;&amp; </td> 
 <td style="vertical-align:top;width:597px;"> 称为逻辑与运算符。如果两个操作数都非零，则条件为真。 </td> 
 <td style="vertical-align:top;width:217px;"> (A &amp;&amp; B) 为假。 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:80px;"> || </td> 
 <td style="vertical-align:top;width:597px;"> 称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 </td> 
 <td style="vertical-align:top;width:217px;"> (A || B) 为真。 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:80px;"> ! </td> 
 <td style="vertical-align:top;width:597px;"> 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 </td> 
 <td style="vertical-align:top;width:217px;"> !(A &amp;&amp; B) 为真。 </td> 
 </tr> 
 </tbody> 
</table>

# **七、程序结构** #

程序在执行的过程中有三种方式，顺序结构，条件结构，循环结构。无论大小的程序，都是会由这几种结构的组成的。

## **7.1 顺序结构** ##

顺序结构，就是字面意思，按照顺序，从上往下执行。举个例子，就是你看电视这个动作，

1.  打开电视，
2.  调到想看的节目
3.  开始看电视

这三个动作是按顺序来进行的，这个就是顺序结构。咱们在前面举的所有的程序的例子，都是顺序结构的，按顺序执行完毕，然后结束。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 15][]

#include<stdio.h> 
 int main()
 {
 char step1[] = "1.打开电视\n";
 char step2[] = "2.调到想看的台\n";
 char step3[] = "3.开始看电视\n";
 
 printf("baiyu 在这里演示一下顺序结构:\n");
 printf("开始:\n");
 printf("%s",step1);
 printf("%s",step2);
 printf("%s",step3);
 printf("结束\n");
 
 return 0; 
 }

执行效果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 16][]

## **7.2 分支结构** ##

分支结构，也叫选择结构。就是程序在执行的过程中，会出现分支，给你进行选择。C语言在分支结构里面有专用的语法，就是咱们接下来即将要讲的if-else语句

### **7.2.1 if-else****语句** ###

**if**跟**else**，是C语言的两个关键字，if-else的结构用法如下：

> if(判断条件)\{
> 
>   语句块1
> 
> \}else\{
> 
>    语句块2
> 
> \}

if关键字后面跟的是一个条件判断，如果条件成立。执行if关键字紧跟着的语句块、不成立的话，就执行else跟着的语句块。条件结构如图所示：

![20210613142619269.png][]

### **7.2.2 只使用****if****语句** ###

这里的if-else语句的并不一定要成对出现，有时候，我们只需要在满足某些条件的时候，才执行语句，而不满足条件的时候，不需要执行语句。如下图所示：

![20210613142619269.png][]

### **7.2.3 if-else****语句的嵌套** ###

> if(判断条件1)\{
> 
> 　　语句块1
> 
> 　　if(判断条件2)\{
> 
> 　　　　语句块2
> 
> 　　\}else\{
> 
> 　　　　语句块3
> 
> 　　\}
> 
> \}else\{
> 
> 　　语句块4
> 
> 　　if(判断条件3)\{
> 
> 　　　　语句块5
> 
> 　　\}else\{
> 
> 　　　　语句块6
> 
> 　　\}
> 
> \}

接着咱们之前的看电视的例子。细化一下，

1.  你打开了电视，
2.  如果你想看新闻，你就调到新闻台，如果你想看动画片，你就调到动漫频道，如果你想看其他的，你就调到其他的台。
3.  然后开始看电视

咋一看，你会觉得这个是顺序结构的，但是，实际上的流程如下图所示，里面包含了分支结构。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 17][]

咱们上面的流程图看电视的程序实现如下：

#include<stdio.h>
 int main() {
 char step1[] = "1.打开电视\n";
 char step2[] = "2.调到想看的台\n";
 char step3[] = "3.开始看电视\n";
 
 int select;
 printf("开始:\n");
 printf("baiyu 在这里演示一下分支结构:\n");
 printf("%s",step1);
 printf("你是否要看新闻？0-否，1-是\n");
 scanf("%d",&select);//scanf()是输入函数 
 
 printf("你的选择是：%d\n",select);
 if(select==1) 
 {
 printf("开始看新闻\n");
 } 
 else 
 {
 printf("你是否要看动漫？0-否，1-是\n");
 scanf("%d",&select);
 printf("你的选择是：%d\n",select);
 if(select==1) 
 {
 printf("开始看动漫\n");
 } else 
 {
 printf("开始看其他\n");
 }
 }
 printf("%s",step3);
 
 printf("结束\n");
 
 return 0;
 }

程序执行的效果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 18][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 19][]

## **7.3 循环结构** ##

接着看电视的例子，今天我一共看了15集《名侦探柯南》，每看完一集，我就用printf语句打印一条出来，“我看完x集柯南了”。

#include <stdio.h> 
 int main(){
 printf("baiyu看完1集柯南了\n");
 printf("baiyu看完2集柯南了\n");
 printf("baiyu看完3集柯南了\n");
 printf("baiyu看完4集柯南了\n");
 printf("baiyu看完5集柯南了\n");
 printf("baiyu看完6集柯南了\n");
 printf("baiyu看完7集柯南了\n");
 printf("baiyu看完8集柯南了\n");
 printf("baiyu看完9集柯南了\n");
 printf("baiyu看完10集柯南了\n");
 printf("baiyu看完11集柯南了\n");
 printf("baiyu看完12集柯南了\n");
 printf("baiyu看完13集柯南了\n");
 printf("baiyu看完14集柯南了\n");
 printf("baiyu看完15集柯南了\n");
 return 0;
 }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 20][]

你会不会发现这样子打印的语句，其实除了几集那个数字是变的，其他的内容的都是一样的，那我们能否将这些重复的动作给简化呢？答案是肯定的，就是咱们即将说到的循环结构。

循环——比喻事物周而复始地运动或变化。

在C语言里面的循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。

在C语言里，循环结构有三种：

1.  while
2.  do...while
3.  for

### **7.3.1 while** **循环** ###

> while （表达式）\{
> 
> 　　循环语句块
> 
> \}

while循环的执行流程如下：先判断表达式满不满足为true，如果满足的话，执行循环语句块，再判断表达式是否满足，如果满足的话，继续执行循环语句块。直到表达式不成立，即为false。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 21][]

#include<stdio.h>
 int main(){
 int num = 1;
 printf("while循环结构打印示例\n"); 
 while(num<=15)
 {
 printf("baiyu看完%d集柯南了\n",num);
 num++; 
 }
 return 0;
 }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 22][]

### **7.3.2 do-while****循环** ###

> do\{
> 
> 　　循环语句块
> 
> \}while(表达式);

do-while循环其实跟while循环结构是一样的，满足表达式时，执行循环体。

唯一的区别就是，do-while循环，**会在判断表达式是否成立之前，先执行一次循环语句块**。

换句话说，**do-while** **循环会确保循环体语句至少执行一次**

![20210613142940947.png][]

在do-while循环结构中，while(表达式)；在这里的分号是一定要有的，不然程序会报错。

#include<stdio.h>
 int main(){
 int num = 1;
 printf("do-while循环打印示例\n");
 do{
 printf("baiyu看完%d集柯南了\n",num);
 num++; 
 }while(num<=15);
 
 return 0;
 }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 23][]

### **7.3.3 for循环** ###

> for (\[表达式1\];\[表达式2\];\[表达式3\])\{
> 
> 　   循环语句块
> 
> \}

for循环的执行顺序如下：

1.  执行表达式1，对循环变量做初始化；
2.  判断表达式2，若其值为真（非0），则执行for循环体中执行代码块，然后向下执行；若其值为假（0），则结束循环；
3.  执行表达式3；
4.  执行for循环中执行代码块后执行第二步；
5.  循环结束，程序继续向下执行。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 24][]

#include<stdio.h>
 int main(){
 int num;
 printf("for循环打印示例\n");
 for(num=1;num<=15;num++)
 {
 printf("baiyu看完%d集柯南了\n",num); 
 }
 return 0;
 }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 25][]

从上面的例子也可以看出，循环结构中，while循环、do-while循环、for循环都可以实现同样的功能。咱们在实际的编程过程中，可以根据实际需要跟自己的喜好选中不同的循环结构。

# **总结** #

至此，你已经对于C语言的基础入门知识有了一定的了解了。也掌握了基本的编译敲代码技巧。

接下来，我会根据C语言不同的知识点，将整理好的更详细的教学的文章发出来给大家。

如果你觉得本文有帮助的话，不妨给个一键三连。

[Dev C_]: https://pan.baidu.com/s/1FsXBVs1cofpNBB1VQJL0NQ
[20210613141939650.png]: /images/20221005/d4e2a184250744e48bf20e07e504269c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70]: /images/20221005/a61dc75faab44f9c8ef19e676197cbe8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 1]: /images/20221005/ae25e749c95745debb305611cf631144.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 2]: /images/20221005/194a0b399bce480ab0243f83810c58dc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 3]: /images/20221005/4712f2abf3fb4d6395c9ce358439aab0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 4]: /images/20221005/3860c07a74bb445bb5deb5a6f1b221a5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 5]: /images/20221005/cd2c1eebbd884d3c89906757882512b4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 6]: /images/20221005/03d48bf2a7274675b9fae968ae5e0814.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 7]: /images/20221005/c3b9a0c16cc74a8b8be74246945afd7e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 8]: /images/20221005/73190f0d170244fea5c0d8492201bad9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 9]: /images/20221005/0dfc1402e18448d184f2e4f920dd30b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 10]: /images/20221005/afe22591cd4a45f7af550ec5f31ace46.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 11]: /images/20221005/2f4a8f139d2b4fe98376c964a9a69f23.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 12]: /images/20221005/164f2937a8df4a74b2e7976ab74535ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 13]: /images/20221005/b6982f7d1b334d1f84d6962bf6f59180.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 14]: /images/20221005/67168e2cf56b4c838af61d2cd5cf65c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 15]: /images/20221005/5fdce03f38014d5d8c9ec863fca392da.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 16]: /images/20221005/cec10869de6f4b0e8c44de8cb4392ce9.png
[20210613142619269.png]: /images/20221005/c8e67e0a04bf41958023dfb8dcc97ba4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 17]: /images/20221005/5d4a7c801dda40c48788030f9ec78515.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 18]: /images/20221005/3e8794f38a1f44c289e18b618e4561c4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 19]: /images/20221005/aeac27e1cc24412596bee7c0a1d2b0f0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 20]: /images/20221005/1817e1b4e009413c8191c054410e9486.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 21]: /images/20221005/18b1a81d15cf4c0fbe4a179d236e82e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 22]: /images/20221005/876b178846d34b579525fc7feb819f7f.png
[20210613142940947.png]: /images/20221005/f6e2347bb1f147a29a08f9ba8ddadf65.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 23]: /images/20221005/cc90410c813643519f2b63bf1c2574fb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 24]: /images/20221005/cf35a3152eb74bdbaaa54e59babb119d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaDc2Mzk4NDAxNw_size_16_color_FFFFFF_t_70 25]: /images/20221005/01e0abb5eb9c4f8897606dd32cff56bf.png