C语言

恋歌828

已于 2022-07-24 16:27:23 修改

阅读量1.2k

点赞数 3

文章标签： c语言开发语言

于 2022-06-23 20:37:50 首次发布

本文链接：https://blog.csdn.net/weixin_63647072/article/details/125414410

版权

1.常量

C语言程序处理的数据有常量和变量两种形式。

定义：常量就是在程序中不能改变其值的量。

类型划分: 整型常量、实型常量、字符型常量、字符串字面量（string literal）和枚举常量。

关于常量的实例：

关于常量的实例
常量的类型	实例	备注
整数常量	10，-30, 0	包括正整数、负整数和零在内的所有整数。
实型常量	3.14， -0.56， 18.0	计算机中的实型数是以浮点形式表示的（即小数点位置可以是浮动的），因此实型常量既可以称为实数，也可以称为浮点数。
字符型常量	'x', 'X', '0', '9'	用一对单引号括起来的任意字符（单个字符）。
字符串字面量	"Hello!", "K88","9"	用一对双引号括起来的零个或多个字符。

C程序中的整型常量通常用十进制数来表示，但实际上它们都是以二进制形式存储在计算机内存中的。

二进制数表示不直观方便，因此有时也将其表示为八进制和十六进制，编译器会自动将其转换为二进制形式存储。

不同进制的整型常量的表示形式
进制	整数17的不同进制表示	整数-31的不同进制表示	特点
十进制	17	-31	以10为基的数值系统称为十进制。由0~9的数字序列组成，数字前可以带正负号。
二进制	00010001	-000011111	以2为基的数值系统称为二进制。二进制整数由0、1数字序列组成。在二进制系统中，数10相当于十进制中的数2。
八进制	021	-037	以8为基的数值系统称为八进制。八进制整数由数字0开头，后跟0~7（可用3位二进制位表示）的数字序列组成。在八进制系统中，数10相当于十进制中的数8。
十六进制	0x11	-0x1F	以216基的数值系统称为十六进制。十六进制整数由0加字母x(或X）开头，后跟0~9，a~f或A~F(可用4位二进制位表示）的数字序列组成。在十六进制系统中，数10相当于十进制中的数16。

注：二进制

00010001

$1*2^0+0*2^{1}+0*2^{2}+0*2^{3}+1*2^{4}+0*2^{5}+0*2^{6}+0*2^{7}$ =17

-000011111 $-\left ( 1*2^{0}+1*2^{1}+1*2^{2}+1*2^{3}+1*2^{4}+0*2^{5}+0*2^{6}+0*2^{7}+0*2^{8} \right )= -31$

八进制

021

$1*8^{0}+2*8^{1}+0*8^{2}=17$

-037

$-\left ( 7*8^{0}+3*8^{1}+0*8^{2} \right )=-31$

十六进制

0x11

$1*16^{0}+1*16^{1}=17$

-0x1F

$-\left ( F*16^{0}+1*16^{1} \right )=-31$

整型常量有长整型和短整型、有符号和无符号之分。

不同类型的整型常量的表示形式
不同类型的整型常量	实例	特点
有符号整型常量	10 ，-30， 0	默认的int型定义为有符号整数，因此对int型无需使用signed。
无符号整型常量	30u, 256U	无符号整型常量由常量值后跟U或u来表示，不能表示成小于0的数，如-30u是不合法的。
长整型常量	-256l， 1024L	长整型常量由常量值后跟l或L来表示。
无符号长整型常量	30lu	无符号长整型常量由常量值后跟LU、Lu、lU或lu来表示。

C程序中的实型常量有十进制小数和指数两种表示形式。

实型常量的表示形式
不同形式的实型常量	实例	特点
十进制小数形式	0.123， -12.35， .98	十进制小数形式与人们表示实数的惯例形式相同，是由数字和小数点组成的。注意必须有小数点，如果没有小数点，则不能作为小数形式的实型数。
指数形式	3.45e-6（等价于0.00000345）	指数形式用于直观地表示绝对值很大或很小的数。在c语言中，由于程序编辑时不能输入上下角标，所以以字母e或E来表示以10为底的指数。其中，e的左边是数值部分（有效数字），可以表示成整数或者小数形式，它不能省略；e的右边是指数部分，必须是整数型。

实型常量有单精度、双精度和长双精度之分，但无有符号和无符号之分。

不同类型的实型常量的表示形式
不同类型的实型常量	实例	特点
单精度（float）实型常量	1.25F, 1.25e-2f	单精度实型常量由常量值后跟F或f来表示。
双精度(double)实型常量	0.123， -12.35， .98	实型常量隐含按双精度型处理。
长双精度（long double）实型常量	1.25L	长双精度型常量由常量值后跟L或l来表示。

2.变量

1.变量不同于常量，其值在程序执行过程中是可以改变的。

2.在C程序中，变量在使用之前必须先定义。

定义变量的一般形式为：类型关键字变量名

3.关键词是C语言预先规定的、具有特殊意义的单词。这里的类型关键词用于声明变量的类型。

变量的类型决定了编译器为其分配内存单元的字节数、数据在内存单元中的存放形式、该类型变量合法的取值范围以及该类型变量可参与的运行种类。

4.下面程序首先定义整型、实型和字符型三个变量，然后分别为其赋值。

int main(void)
{
   int a;          //用关键字int指定变量a的类型
   float b;        //用关键字float指定变量b的类型
   char c;         //用关键字char指定变量c的类型
   a=1;            //为int型变量a赋值整型常量1
   b=2.5;          //为float型变量b赋值整型常量2.5
   c='A';          //为char型变量c赋值整型常量'A'
   return 0;
}

注意：C程序是没有行号的，这里的行号仅是为了对程序进行说明和叙述方便。

1.标准C语言编写的程序都是以 main() 作为开头的，它制定了C程序执行的起点，在C程序中只能出现一次。

2.一个C程序必须有且只能有一个用main作为名字的函数，这个函数称为主函数。

3.main 后面圆括号内的 void 表示它没有函数参数。

4.main 前面的 int 表示函数执行后会返回操作系统一个整型值，在 main 函数的函数体中的最后一条语句使用 return 语句返回了这个值，通常返回 0 表示程序正常结束。

5.C程序总是从主函数开始执行，与它在程序中的位置无关。

6.主函数中的语句用花括号{}括起来。一般情况下，C语句是以分号结尾的。

7.变量名是用户定义的标识符，用于标识内存中一个具体的存储单元，在这个存储单元中存放的数据称为变量的值。

8.变量名的命名应遵守以下基本的命名规则：

1）标识符只能由英语字母、数字和下划线组成，建议使用见名知意的名字为变量命名，可以使用英文单词大小写混排或中间加下划线的方式，而不要使用汉语拼音；

2）标识符必须以字母或下划线开头；

3）不允许使用C关键字为标识符命名；

4）标识符可以包含任意多个字符，但一般会有最大长度限制，与编译器相关，不过大多数情况下不会达到此限制。

9.如果定义了一个变量，但未对其进行初始化，那么该变量的值是一个随机数（静态变量和全局变量除外）。

3.运算符

1.只需要一个操作数的运算符称为一元运算符（或单目运算符），需要两个操作数的运算符称为二元运算符（或双目运算符），需要三个操作数的运算符称为三元运算符（或三目运算符）。

条件运算符是c语言提供的唯一一个三元运算符。

2.除计相反数是一元运算符以外，其余的算术好运算都是二元运算符。

3.在c语言中，求余运算限定参与运算的两个操作数须为整形，不能对两个实型数据进行求余运算。将求余运算符的左操作数作为被除数，右操作数作为除数，二者整除后的余数即为求余运算的结果。

4.c语言中没有幂运算符。

5.一元的取相反数运算符的结合性为右结合（即自右向左计算），其余的算术运算符为左结合（即自左向右计算）。

6.增1运算符和减1运算符都是一元运算符只需要一个操作数，且操作数须有“左值性质“”，必须是变量，不能是常量或表达式。

7.后缀是先使用变量的值，然后再增1（减1），前缀是先增1（减1），然后再使用变量的值，并且后缀增1（减1）运算符的优先级高于前增1（减1）运算符，前者是左结合的，而后者是有结合的。

4.宏常量与宏替换

1.圆的周长和面积计算公式中用到了圆周率 $\prod$ ，而 $\prod_{}^{}$ 值在程序中是用一个常数近似表示的，像这种在程序中直接使用的常数，称为幻数。

2.为了提高程序的可读性和可维护性，保持良好的程序设计风格，建议把幻数定义为宏常量或cost常量，代替程序中多次出现的常数。其优点在于能使用户以一个简单易懂的名字来代替一个长字符串，有助于提高程序的可读性。

3.示例：使用宏常量定义 $\prod$ ，编程从键盘输入圆的半径r，计算并输出圆的周长和面积。

#include <stdio.h>
#define PI 3.14159

int main(void) {
    double r;
    printf("Input r:");
    scanf("%lf",&r);
    printf("circumference = %f\n",2*PI*r);
    printf("area = %f\n",PI*r*r);
    return 0;
}

4.宏常量也称为符号常量，是指用一个标识符号来表示的常量，这时该标识符号与此常量是等价的。通常量是由宏定义编译预处理命令来定义的。

5.宏定义的一般形式为：

#define 标识符字符串

6.宏定义中的标识符被称为宏名，将程序中出现的宏名替换成字符串的程称为宏替换。

7.宏定义中的宏名与字符串之间可有多个空白，但无需加等号，且字符串后一般不以括号结尾，因为宏定义不是c语言，而是一种编译预处理命令。

5.const常量

1.在声明语句中，只要将const类型修饰符放在类型名之前，即可将类型名后的标识符声明为具有该类型的cost常量，const常量只能在定义时赋初值。

2.与宏常量比，const常量的优点是它有数据类型，编译器能对其进行对行检查,某些集成化调试工具可以对const常量进行调试。

6.转换运算符

1.自动类型转换

以下表示不同类型的操作数进行混合运算时由低到高的类型转换方向，但不表示转换的中间过程。

double > float > long > int > short > char

2.强制类型转换

方式：

（类型）表达式

7.常见的转义字符

常见的转义字符
字符	含义	字符	含义
'\n'	换行	'\a'	响铃报警提示音
'\r'	回车（不换行）	'\"'	一个双引号
'\0'	空字符，通常用做字符串结束标志	'\''	单引号
'\t'	水平制表	'\\'	一个反斜线
'\v'	垂直制表	'\?'	问号
'\b'	退格	'\ddd'	1到3位八进制ASCII码值所代表的字符
'\f'	走纸换页	'\xhh'	1到3位十六进制ASCII码值所代表的字符

8.输入输出

1.getchat()和putchar()是C标准函数库中专门用于字符输入/输出的函数。

2.示例：从键盘输入一个大写英文字母将其转换为小写字母，再显示到屏幕上。

#include <stdio.h>

int main(void) {
   char ch;
   printf("Press a key and then press Enter:");
   ch = getchar();
   ch = ch+32;
   putchar(ch);
   putchar('\n');
    return 0;
}

3.函数getchar()没有参数，函数的返回值就是从终端键盘读入的字符。

4.函数printf（）的一般格式：

printf(格式控制字符串);

printf(格式控制字符串,输出值参数表);

5.函数printf()的格式转换说明

函数printf()的格式转换说明
格式转换说明	用法
%d	输出带符号的十进制整数，正数的符号省略
%u	以无符号的十进制整数形式输出
%o	以无符号的八进制整数形式输出，不输出前导符0
%x	以无符号的十进制整数形式（小写）输出，不输出前导符0x
%X	以无符号的十进制整数形式（大写）输出，不输出前导符0x
%c	输出一个字符
%s	输出字符串
%f	以十进制小数形式输出实数（包括单、双精度），整数部分全部输出，隐含输出6位小数，输出的数字并非全部是有效数字，单精度实数的有效位数一般为7位，双精度实数的有效位数一般为16位。 %f适合于输出像3.14这样位数较少的实数，可以使实数输出的宽度较小。
%e	以指数形式（小写e表示指数部分）输出实数，要求小数点前必须有且仅有1位非零数字。 %e适合于输出像1.0e+10这样的小数位较多的实数，可以使实数输出的宽度较小。在不同的编译环境下，使用%e输出数据所占的列数略有差异。
%E	以指数形式（大写E表示指数部分）输出实数
%g	自动选取f或e格式中输出宽度较小的一种使用，且不输出无意义的0
%%	输出百分号%

6.实例：从键盘输入一个大写英文字母，将其转换为小写英文字母后，将转换后的小写英文字母及其十进制的ASCII码值显示到屏幕上。

#include <stdio.h>

int main(void) {
   char ch;
   printf("Press a key and then press Enter:");
   ch = getchar();
   ch = ch+32;
   printf("%c, %d\n",ch,ch);
   
    return 0;
}

运行结果

Press a key and then press Enter:B
b, 98

7.函数printf()中的格式修饰符

函数printf()中的格式修饰符
格式修饰符	用法
英文字母l	修饰格式符 d,o,x,u 时，用于输出 long 型数据
英文字母L	修饰格式符 f,e,g 时，用于输出 long double 型数据
英文字母h	修饰格式符 d,o,x 时，用于输出 short 型数据
输出域宽m（m为整数）	指定输出项输出时所占的列数。若m为正整数，当输出数据宽度小于m时，在域内向右靠齐，左边多余位补空格；当输出数据宽度大于m时，按实际宽度全部输出；若m有前导符0，则左边多余位补0。若m为负整数，则输出数据在域内向左靠齐
显示精度 .n (n为大于或等于0的整数）	精度修饰符位于最小域宽修饰符之后，由一个原点及其后的整数构成。对于浮点数，用于指定输出的浮点数的小数位数。对于字符串，用于指定从字符串左侧开始截取的子串字符个数

8.实例：使用const常量定义 $\prod$ ，编程从键盘输入圆的半径r，计算并输出圆的周长和面积。使其输出的数据保留两位小数点。

#include <stdio.h>

int main(void) {
 const double pi=3.14159;
 double r,circum,area;
 printf("Input r:");
 scanf("%lf",&r);
 circum=2*pi*r;
 area=pi*r*r;
 printf("circumference = %f,area = %f\n",circum,area);
 printf("circumference = %7.2f,area = %7.2f\n",circum,area);
    return 0;
}

运行结果

Input r:5.3
circumference = 33.300854,area = 88.247263
circumference = 33.30,area = 88.25

9.函数scanf()的一般格式

scanf(格式控制字符串，参数地址表);

10.函数scanf()的格式转换说明符

函数scanf()的格式转换说明符
格式转换说明符	用法
%d	输入十进制整数
%o	输入八进制整数
%x	输入十六进制整数
%c	输入一个字符，空白字符（包括空格、回车、制表符）也作为有效字符输入
%s	输入字符串，遇到空白字符（包括空格、回车、制表符）时，系统认为读入结束（但在开始读之前遇到的空白字符会被系统跳过）
%f或%e	输入实数，以小数或指数形式输入均可
%%	输入一个百分号%

11.函数scanf()中的格式修饰符

函数scanf()中的格式修饰符
格式修饰符	用法
英文字母l	加在格式符 d,o,x,u 之前，用于输入 long 型数据；加在格式符 f,e 之前，用于输入 double 型数据
英文字母L	加在格式符 f,e 之前，用于输入 long double 型数据
英文字母h	加在格式符 d,o,x 之前，用于输入 short 型数据
域宽m（正整数）	指定输入数据的宽度（列数），系统自动按此宽度截取所需数据
显示精度 .n（0或正整数）	scanf()没有精度修饰符，即用scanf()输入实型数据时不能规定精度
忽略输入修饰符*	表示对应的输入项在读入后不赋给相应的变量

12.在用函数scanf()输入数值型数据时，遇到以下几种情况都认为数据输入结束：

（1）遇空格符、回车符、制表符（Tab）；

（2）达到输入域宽；

（3）遇非法字符输入；

注意：如果函数scanf()的格式控制字符串中存在除格式说明符以外的其他字符，那么这些字符必须在输入数据时由用户从键盘原样输入。

13.分隔符：回车符、空格符、逗号、制表符、字符-

14.用%c输入字符时存在的问题：空格字符和转义字符（包括回车）都会被当作有效字符读入。

15.%c格式符存在问题的解决方法：

（1）用函数getchar()将数据输入时存入缓冲区中的回车符读入，以避免被后面的字符型变量作为有效字符读入。

#include <stdio.h>

int main(void) {
int a;
char b;
float c;
printf("Please input an integer:");
scanf("%d",&a);
printf("integer: %d\n", a);
getchar();
printf("Please input a character:");
scanf("%c",&b);
printf("character: %c\n",b);
printf("Please input a float number:");
scanf("%f",&c);
printf("character:%c\n", b);
printf("float: %f\n", c);
    return 0;
}

运行结果

Please input an integer:12
integer: 12
Please input a character:a
character: a
Please input a float number:3.5
character:a
float: 3.500000

（2）在%c前面加一个空格，忽略前面数据输入时存入缓冲区中的回车符，避免被后面的字符型变量作为有效字符读入

#include <stdio.h>

int main(void) {
int a;
char b;
float c;
printf("Please input an integer:");
scanf("%d",&a);
printf("integer: %d\n", a);
printf("Please input a character:");
scanf(" %c",&b);
printf("character: %c\n",b);
printf("Please input a float number:");
scanf("%f",&c);
printf("character:%c\n", b);
printf("float: %f\n", c);
    return 0;
}

运行结果

Please input an integer:12
integer: 12
Please input a character:a
character: a
Please input a float number:3.5
character:a
float: 3.500000

9.选择结构（分支控制结构）

1.关系运算符及其优先级

关系运算符及其优先级
运算符	含义	优先级
<	小于	高
>	大于
<=	小于或等于
>=	大于或等于
==	等于	低
!=	不等于	低

2.在C语言中，用非0值表示“真”，用0值表示“假”。

3.单分支控制结构

（1）用以下的if语句实现： if(表达式P) 语句A

（2）使用单分支的条件语句编程，计算并输出两个整数的最大值

#include <stdio.h>

int main(void) {
int a,b,max;
printf("Input a,b:");
scanf("%d,%d",&a,&b);
if(a>b)  max=a;
if(a<b)  max=b;
printf("max = %d\n",max);
    return 0;
}

运行结果

Input a,b:3,5
max = 5

4.双分支控制

（1）一般形式：

if（表达式 P）语句1

else 语句2

（2）使用双分支条件语句编程，计算并输出两个整数的最大值

#include <stdio.h>

int main(void) {
int a,b,max;
printf("Input a,b:");
scanf("%d,%d",&a,&b);
if(a>b)  max=a;
else     max=b;
printf("max = %d\n",max);
    return 0;
}

5.条件运算符是C语言中唯一的一个三元运算符

条件表达式的一般形式：

表达式1？表达式2：表达式3

含义：若表达式1的值非0，则该条件表达式的值是表达式2的值，否则是表达式3的值。

6.用于多分支控制的条件语句

if(表达式）语句1

else if(表达式2）语句2

else if(表达式m) 语句m

else 语句 m+1

7.用于多路选择的switch语句（一般大于三种）

switch语句的一般形式：

switch（表达式）{

case 常量1：

可执行语句序列1

case 常量2：

可执行语句序列2

case 常量n：

可执行语句序列n

default:

可执行语句序列n+1

}

switch语句相当于一系列的if-else语句，表达式只能是char型或int型。

case 后面接着的是常量。

常量与case中间至少有一个空格，常量的后面是冒号，常量的类型应与switch后括号内表达式的类型一致。

实例：

#include<stdio.h>
int main(){
int date1,date2;
char op;
scanf("%d%c%d",&date1,&op,&date2);

switch(op){
case '+':
        printf("%d+%d=%d\n",date1,date2,date1+date2);
        break;

case '-':
        printf("%d-%d=%d\n",date1,date2,date1+date2);
        break;
case '*':
        printf("%d*%d=%d\n",date1,date2,date1*date2);
        break;
case '/':
if(0==date2)
printf("Division by zero!\n");
else
        printf("%d/%d=%d\n",date1,date2,date1/date2);
        break;
default:
printf("Invalid operator!\n");
}
return 0;
}

8.逻辑运算符和逻辑表达式

在数学上正确的表达式在C语言的逻辑上不一定总是正确的。

逻辑运算符
逻辑运算符	类型	含义	优先级	结合性
！	单目	逻辑非	最高	从右向左
&&	双目	逻辑与	较高	从左向右
\|\|	双目	逻辑或	较低	从左向右

！的优先级是最高的，其次是&&，再次是||

10.循环控制结构

1.循环结构通常有两种类型：

（1）当型循环结构，表示当条件P成立（为真）时，反复执行A操作，直到条件不成立(为假)时结束循环。

（2）直到型循环结构，表示先执行A操作,再判断条件P是否成立（为真），若条件成立（为真），则反复执行A操作，直到条件P不成立（为假）时结束循环。

2.while语句

while语句属于当型循环。其一般形式为：

while(循环控制表达式)

{

语句序列

}

while语句中的循环控制表达式是在执行循环体之前测试的，其执行过程如下：

（1）计算循环控制表达式的值。

（2）如果循环控制表达式的值为真，那么就执行循环体中的语句。并返回步骤（1）。

（3）如果循环控制表达式的值为假，就退出循环，执行循环体后面的语句。

3.do-while语句

do-while语属于直到型循环，其一般形式为：

{

语句序列

}while(循环控制表达式）;

do-whil语句中的循环控制表达式是在执行循环体之后测试的。do-while语句的行过程如下:

（1）执行循环体中的语句。

（2）计算循环控制表达式的值。

（3）如果循环控制表达式的值为真，那么返回步骤（1）。

（4）如果循环控制表达式的值为假，就退出循环，执行循环体后面的语句。

所以循环体内的语句将至少被执行一次。

4.for语句

for语句属于当型循环结构，它的使用方法非常灵活，在c语言程序中的使用频率也最高。其一般形式如下：

for(初始化表达式;循环控制表达式;增值表达式)

{

语句序列

}

初始化表达式的作用是为循环控制变量初始化。即赋初值，他决定了循环的起始条件。

循环控制表达式是循环控制条件，准确地说是控制循环句句执行的条件，当这个表达式的值为真实，继续重复执行循环。否则结束循环，执行循环体后面的语句。

增值表达式的作用是每执行一次循环后将循环控制变量增值。

5.流程的转移控制

goto语句、break语句、continue语句和return语句是C语言中用于控制流程转移的跳转语句

（1）goto语句：无条件转向语句

goto 语句标号；

......

语句标号：.......

作用：再不需要任何条件的情况下直接使程序跳转到该语句标号所标识的语句去执行，其中语句标号代表goto语句转向的目标位置，应使用合法的标识符表示语句标号，其命名规则与变量名相同。尽管goto语句是无条件转向语句，但通常情况下goto语句与if语句联合使用。

（2）break语句

break语句除用于退出switch结构外，还可用于由while、do-while和for构成的循环语句的循环体中。

break语句实际是一种有条件的跳转语句，跳转的语句位置限定为紧接着循环语句后的第一条语句

（3）continue语句

当在循环体中遇到continue时，程序将跳过continue语句后面尚未执行的语句，开始下一次循环，即只结束本次循环的执行，并不终止整个循环的执行。

实例：读入5个正整数并且显示它们。

#include <stdio.h>

int main(void) {
    int i,n;
    for(i=1;i<=5;i++){
        printf("Please enter n:");
        scanf("%d",&n);
        if(n<0)  goto END;
       printf("n = %d\n",n);
    }
    END:printf("Program is over!\n");
    return 0;
}

#include <stdio.h>

int main(void) {
    int i,n;
    for(i=1;i<=5;i++){
        printf("Please enter n:");
        scanf("%d",&n);
        if(n<0)  break;
       printf("n = %d\n",n);
    }
    printf("Program is over!\n");
    return 0;
}

运行结果

Please enter n:10
n = 10
Please enter n:-10
Program is over!

continue语句

#include <stdio.h>

int main(void) {
    int i,n;
    for(i=1;i<=5;i++){
        printf("Please enter n:");
        scanf("%d",&n);
        if(n<0)  continue;
       printf("n = %d\n",n);
    }
    printf("Program is over!\n");
    return 0;
}

运行结果

Please enter n:10
n = 10
Please enter n:-10
Please enter n:20
n = 20
Please enter n:-20
Please enter n:30
n = 30
Program is over!

大多数for循环可以转换为while循环，但并非全部。例如，当循环体中有continue语句时，二者就并非是等价的。

在嵌套循环的情况下，break语句和continue语句只对包含它们的最内层的循环语句起作用，不能用break语句跳出多重循环。若要跳出多重循环，使用break语句只能一层一层地跳出。而显然goto语句是跳出多重循环的一条捷径。

11.穷举

简单地说就是通过尝试问题的所有可能来得到最终答案

例：韩信点兵问题。韩信有一队兵，他想知道有多少人，便让士兵排队报数。按从1至5报数，最末一个士兵报的数为1；按从1至6报数，最末一个士兵报的数为5；按从1至7报数，最末一个士兵报的数为4；最后再按从1至11报数，最末一个士兵报的数为10。请编程计算韩信至少有多少兵。

分析：

设兵数为 x，则按题意x应满足下述关系式

x % 5== 1 && x % 6 == 5 && x % 7 ==4 && x % 11 == 10

方法1：

#include<stdio.h>
int main(){
	int x;
	for(x=1; ;x++){
		if(x%5==1&&x%6==5&&x%7==4&&x%11==10){
			printf("x = %d\n",x);
			break;
		}
	}
	return 0;
}

方法2：

#include<stdio.h>
int main(){
	int x;
	int find = 0;
	for(x=1;!find;x++){
		if(x%5==1&&x%6==5&&x%7==4&&x%11==10){
			printf("x = %d\n",x);
			find = 1;
		}
	}
	return 0;
}

方法3：

#include<stdio.h>
int main(){
	int x=0;
	int find = 0;
	do{
		x++;
		find=(x%5==1&&x%6==5&&x%7==4&&x%11==10);
	}while(!find);
	printf("x = %d\n",x);
	return 0;
}

12.函数

1.函数是C语言中模块化程序设计的最小单位，既可以把每个函数都看做一个模板，也可以将若干相关的函数合并成一个模板。

2.一个C程序可以由一个或多个源程序文件组成，一个源程序文件又可以由一个或多个函数组成。

3.函数的分类

1.在C语言中，函数是构成程序的基本模板。

2.从使用者的角度对函数分类，将函数分为标准库函数和自定义函数两类。

3.使用ANSI C的库函数，必须在程序的开头把该函数所在的头文件包含进来。

4.和使用变量一样，函数在使用之前必须先定义。

函数定义的基本格式为：

返回值类型函数名（类型形式参数1，类型形式参数2，···） $\leftarrow$ 函数头部

{

声明语句序列

可执行语句序列

}

5.函数名是函数的唯一标识，用于说明函数的功能。函数名标识符的命名规则与变量的命名规则相同。

函数体必须用一对花括号包围，这里的花括号{}是函数体的定界符。

在函数体内部定义的变量只能在函数体内访问，称为内部变量

函数头部参数表里的变量，称为形式参数，简称形参，也是内部变量，即只能在函数体内访问。

若函数没有函数返回值，则需用void定义返回值的类型。若函数不需要入口参数，则需用void代替形参表示的内容，表示该函数不需要任何外部数据。

6.实例：用函数编写计算整数n的阶乘n!

//函数功能：用迭代法计算n!
//函数入口参数：整型变量n表示阶乘的阶数
//函数返回值：返回n!的值
long fact(int n) //函数定义
{
int i;
long result = 1;
for(i=2;i<= n;i++) {
result*=i;
}
return result;
}

7.如何进行函数调用

main函数调用函数fact()时，必须提供有一个称为实际参数（简称，实参）的表达式给被调用的函数。将调用其他函数的函数简称为主调函数，被调用的函数简称为被调函数。主调函数把实参的值复制给形参的过程，称为参数传递。

#include<stdio.h>
long Fact(int n){
	int i;
	long result=1;
	for(i=2;i<=n;i++){
		result*=i;
	} 
	return result;
}
int main(){
	int n;
	long ret;
	printf("Input n:");
	scanf("%d",&n);
	ret=Fact(n);
	printf("%d!=%ld\n",n,ret);
	return 0;
	
}

8.有返回值的函数必须有return语句，return语句用来指明函数将返回给主调函数的值是什么。无论在函数的什么位置，只要执行到它，就立即返回到函数的调用者。

注意：函数的返回值只能有一个，函数返回值的类型可以是除数组以外的任何类型。函数中的return语句可以有多个，但不表示函数可以有多个返回值。

多个return语句通常出现在if-else语句中，表示在不同的条件下返回不同的值。

当函数返回值类型为void类型时，表示函数没有返回值，函数可以没有return语句，程序一直运行到函数的最后一条语句后再返回。如果程序不是运行到函数的最后一条语句才返回，那么必须使用return语句返回，无须