C语言-第一章节初识-函数总结

目录

一、初始

1、第一个C程序，1 基础框架，最少组成，写任何C代码前先敲好

1、2 数据类型

1、3printf用法

1、4 printf练习

1、5 scanf输入的用法

1、6 scanf混合输入注意问题

1、7 其它输入输出的方式

1、8 输入输出

1、9小练习作业

1、9、1输入两个数，获得两个数加减乘除的值

1、9、2作业

二、流程控制

2、1 流程控制之if语句

2、2 if控制经典案例代数交换值

​编辑

2、3 逻辑判断与非

2、4 ifelse练习 

2.5 if嵌套练习

2.6 列表选择switchcase 

2.7 Switch练习学生成绩划分 

 2.8 选择练习路程算折扣

 2.9 作业

2.10 while循环

2.11 while循环计算1-100的和 

2.12 do——while 

2.13 while的表达式以及for循环等价引入

2.14循环干涉之break和continue编码分析

2.15 for嵌套

最大公约和最小公倍数

水仙花数

三、第3章 数组

3.1数组初始化

 3.2 sizeof关键字以及大小数组计算方法

 3.3 逆序输出10位数

 3.4 斐波那契数列

3.5冒泡排序

 3.6选择简单排序

3、7  二维数组

四、第4章函数封装

第一个函数练习

 第二个函数加法运算

 第3个形参-实参=====打印内存地址变量

 第4封装获得两个数的大数

第5函数嵌套

第6个递归函数求年龄算法

 第7函数求N阶乘

第8个数组传参中关于形式参数的，函数数组

 第9个值传递和真正的数组地址传递

 第10个数组函数求不同班级学生的平均分

 第11个函数二维数组输入

 第12函数全局变量概念

第十三个求最高，最低，平均分 。

第14要求输入10个数，找出最大数以及最大数的下标。

 第15个封装冒泡排序的函数

 最好用的冒泡排序

第16封装选择排序的函数

---

一、初始

1、第一个C程序，1 基础框架，最少组成，写任何C代码前先敲好

#include <stdio.h>        //编译预处理指令

int main()                //程序的入口主函数main
                          //程序（函数、功能）开始标志
{
	printf("hello.C。");   //需要编写的代码
	
    return 0;              
                            //程序退出前返回给调用者（操作系统）的值
}                          //程序（函数、功能）结束标志

代码运行：

总结：echo %errorleve1%可以查看错误等级，命名规则，建议驼峰命名法；

小驼峰：xiaoTuoFeng

大驼峰：DaTuoFeng

顾名思义：小驼峰小写开头中间首字母大写，大驼峰以大写开头。

1、2 数据类型

整数型 

int data

字符型

char data1 = 'c'

浮点数

float data = 1.2

ASCll表

1、3printf用法

#include <stdio.h>

/* 
	author: 作者
	date: 日期
	funDescription:
	用发
*/

int main()
{
	int a_data = 3; //c c++ java 一个分号代表一个语句结束
	float f_data = 2.3;
	char c_data = '#';
	
	int data = 10;
	int chushu = 3;
	float result;
	
	result = (float)data/chushu; //强制转换，把整数给小数
	
	printf("随便你输出什么东西，在cmd终端可以看到\n");
	
	
	printf("a=%d\n",a_data);   //占位符,是以%开头，注释是程序员看到，编译预处理的时候，会被清除
						//sdfsdfsdf
	a_data = 100;  //0000 0000 0000 0000 0000 0000   0110 0100
	printf("修改后：a=%d\n",a_data);
	printf("16进制输出a=0x%x\n",a_data);//%x16进制输出
	printf("有一个小数f=%f\n",f_data);
	printf("有一个字符c = %c\n",c_data);
	printf("a_data的地址是%p\n",&a_data);//打印地址
	
	printf("result = %f\n",result);
	printf("result2 = %f\n",(float)data/chushu);//强制转换表达式
	
	return 0;
}

代码示例：

随便你输出什么东西，在cmd终端可以看到
a=3
修改后：a=100
16进制输出a=0x64
有一个小数f=2.300000
有一个字符c = #
a_data的地址是000000000023FE38
result = 3.333333
result2 = 3.333333

1、4 printf练习

#include <stdio.h>

int main()
{
	int data1 = 10; 
	int data2 = 6;
	float data4;
	
	int data3;
	
	
	printf("有两个原始数据%d,%d\n",data1, data2);

	
	printf("那么这两数的和是%d\n",data3 = data1 + data2);//表达式输出
	data3 = data1 - data2;
	
	printf("那么这两数的差是%d\n",data3);
	
	data3 = data1 * data2;
	
	printf("那么这两数的积是%d\n",data3);
	
	data4 = (float)data1 / data2;//强制转换
	
	printf("那么这两数的相除是%f\n",data4);
	
}

代码运行示例：

你看，这是我做的第一个不正经小的C程序，厉害不
有两个原始数据10,6
那么这两数的和是16
那么这两数的差是4
那么这两数的积是60
那么这两数的相除是1.666667

1、5 scanf输入的用法

#include <stdio.h>

int main()
{
	int data;
	int data2;
	int data3;
	
	/*printf("请输入一个整数：\n");
	scanf("%d",&data);           //指针部分内容
	printf("输入完毕\n");
	printf("你输入的数据是：%d\n",data);
	

	printf("请输入3个数\n");
	scanf("%d%d%d",&data,&data2,&data3);
	printf("你输入的数据是：data=%d,data2=%d,data3=%d\n",data,data2,data3);
	*/
	printf("请输入3个数\n");
	scanf("data=%d,data2=%d,data3=%d",&data,&data2,&data3);//在scanf有逗号或者空格，
    //data=都要有否则空格断掉输入数据
	printf("你输入的数据是：data=%d,data2=%d,data3=%d\n",data,data2,data3);
	return 0;
}

代码示例： 

请输入3个数
data=12,data2=23,data3=43
你输入的数据是：data=12,data2=23,data3=43

1、6 scanf混合输入注意问题

#include <stdio.h>

int main()
{
	char data;
	char data2;
	char data3;
	int dataInt;
	float dataFloat;
	
	/*
	printf("请输入3个字符\n");
	scanf("%c%c%c",&data,&data2,&data3);
	printf("你输入的数据是：data=%c,data2=%c,data3=%c\n",data,data2,data3);
	*/
	printf("请以此输入整数，字符和小数\n");
	scanf("%d%c%f",&dataInt,&data,&dataFloat);
	printf("你输入的数据是 dataInt=%d,data=%c,dataFloat=%f\n",dataInt,data,dataFloat);
			
	return 0;
}

代码示例：

请以此输入整数，字符和小数
12@1.2
你输入的数据是 dataInt=12,data=@,dataFloat=1.200000

1、7 其它输入输出的方式

#include <stdio.h>

/*
	跟printf的区别
	1. 自动加入换行符
	2. printf支持多种花样输出，而puts就是输出字符串
*/

int main()
{
	char c;
	
	puts("请输入一个字符");
	c = getchar();
	puts("你输入的字符是");
	putchar(c);
	return 0;
}

代码示例：

请输入一个字符
@
你输入的字符是
@
--------------------------------
Process exited after 3.92 seconds with return value 0
请按任意键继续. . .

1、8 输入输出

例3.10 改写例3.3程序，使之可以适用于任何大写字母，从键盘输入一个大写字母，在显示屏上显示对应的小写字母。

案例一：

#include <stdio.h>

int main()
{
	char a = 'a';
	char b = 'b';
	
	char A = 'A';
	char B = 'B';
	
	printf("%c,%c,%c,%c\n",a,b,A,B);
	printf("a=%d,b=%d,A=%d,B=%d\n",a,b,A,B);
	
	puts("请输入一个大写字母\n");
	scanf("%c",&a);
	b = a+32;
	printf("你输入的字母对应的小写字母是 %c\n",a+32);
	printf("你输入的字母对应的小写字母是 %c\n",b);
	printf("测试");
	getchar();//吸收回车符，来源于15行。当你分多次连续scanf获得字符的时候，要注意回车符
	putchar(getchar()+32);
	return 0;
}

代码运行示例：

a,b,A,B
a=97,b=98,A=65,B=66
请输入一个大写字母

K
你输入的字母对应的小写字母是 k
你输入的字母对应的小写字母是 k
测试A
a
--------------------------------
Process exited after 12.3 seconds with return value 0
请按任意键继续. . .

1、9小练习作业

1、9、1输入两个数，获得两个数加减乘除的值

#include<stdio.h>

int main()
{
	int data1;
	int data2;
	int data3;
	printf("请输入两个数\n");
	scanf("%d",&data1);
	scanf("%d",&data2);

	printf("输入两个数的和为:%d\n",data3 = data1 + data2);
	printf("输入两个数的差为:%d\n",data3 = data1 - data2);
	printf("输入两个数的乘为:%d\n",data3 = data1 * data2);
	printf("输入两个数的除为:%d\n",data3 = data1 / data2);
	
	return 0;
}

代码运行示例：

请输入两个数
12
3
输入两个数的和为:15
输入两个数的差为:9
输入两个数的乘为:36
输入两个数的除为:4

--------------------------------
Process exited after 5.273 seconds with return value 0
请按任意键继续. . .

1、9、2作业

/*习题 3.6 请编程序将"China"译成密码，密码规律是：用原来的字母后面第4个字母代替原来的字母。例如：字母“A”后面第4个字母时"E"，用"E"代替"A"。因此，“China"应译为"Glmre”。请编一程序，用赋初值的方法使c1, c2, c3, c4, c5这5个变量的值分别为’C’, ‘h’, ‘i’, ‘n’, ‘a’, 经过运算，使c1, c2, c3, c4, c5分别为’G’, ‘l’, ‘m’, ‘r’, ‘e’。分别用putchar函数和printf函数输出这个5个字符。*/
#include <stdio.h>

int main()
{
    //给5个变量赋初值
    char c1 = 'C';
    char c2 = 'h';
    char c3 = 'i';
    char c4 = 'n';
    char c5 = 'a';
    //输出原代码
    putchar(c1);
    putchar(c2);
    putchar(c3);
    putchar(c4);
    putchar(c5);
    putchar('\n');
    //原代码加密
    c1 += 4;
    c2 += 4;
    c3 += 4;
    c4 += 4;
    c5 += 4;
    printf("%c%c%c%c%c\n", c1, c2, c3, c4, c5);

    return 0;
}

Ghina
Glmre

二、流程控制

2、1 流程控制之if语句

 

#include <stdio.h>

int main()
{
	int money;
	printf("请问你有多少钱？\n");
	scanf("%d",&money);
	//如果超过100元，富翁
	if(money > 100)
	{
		printf("有钱人\n");
	}
	puts("谈话结束");
	printf("测试结果：%d\n",money>100);//大于100会等于1，小于运行会等于0
	
	return 0;
}

运行：

请问你有多少钱？
1111
有钱人
谈话结束
测试结果：1

--------------------------------
Process exited after 3.081 seconds with return value 0
请按任意键继续. . .

#include <stdio.h>

int main()
{
	int atHomeYesOrNot;
	puts("你在吗，1在家，0不在家");
	scanf("%d",&atHomeYesOrNot);
	if(atHomeYesOrNot == 1){ //==才是判断，一个等号，编译能过，但是。。，
							//if（）括号的内容终究会被转换成0,1，是1（true）才会执行大括号中的代码语句。
		puts("扑到你");	
		puts("xx");
	}
	
	return 0;
}

代码运行：

2、2 if控制经典案例代数交换值

#include <stdio.h>

int main()
{
	int data1;
	int data2;
	
	printf("请输入两个数：\n");
	scanf("%d%d",&data1,&data2);
	
	if (data1 > data2){
		printf("data大数是%d\n",data1);
		printf("data小数是%d\n",data2);		
	}
	if (data1 < data2){
		printf("data大数是%d\n",data2);
		printf("data小数是%d\n",data1);	
	} 
	return 0;
}

代码运行： 

 if控制经典案例代数法交换值

注释：1、如果前面输入是小数则不会交换

           2、如果前面是大数后面是小数则会交换

#include <stdio.h>

int main()
{
	int data1;
	int data2;
	int datatmp;//不管怎么输入数据，data1当中存放的就是小数
	
	printf("请输入两个数：\n");
	scanf("%d%d",&data1,&data2);
	
	if(data1 > data2){
		//交换
		printf("=====交换\n");
		datatmp = data1;
		data1 = data2;
		data2 = datatmp;
	}
	
	printf("%d，%d\n",data1,data2);
	
}

代码运行：

三个数进行交换

#include <stdio.h>

int main()
{
	int data1;
	int data2;
	int data3;
	int tmp;
	
	printf("请输入三个数：\n");
	scanf("%d%d%d",&data1,&data2,&data3);
	
	if(data1 > data2)
	{
		tmp = data1;
		data1 = data2;
		data2 = tmp;
	}
	if(data1 > data3)
	{
		tmp = data1;
		data1 = data3;
		data3 = tmp;
	}
	if(data2 > data3)
	{
		tmp = data2;
		data2 = data3;
		data3 = tmp;
	}
	printf("%d %d %d\n",data1,data2,data3);
	return 0;
}

2、3 逻辑判断与非

#include <stdio.h>

int main()
{
	int a;
	int b;
	
	printf("请输入a,b两个数：\n");
	scanf("%d%d",&a,&b);
	
	if( a==1 && b==0){
		printf("逻辑与成功\n");
	}
	
	if( a==1 || b==0){
		printf("逻辑或成功\n");
	}
	
	if( !a ){
		printf("逻辑非\n");
	}
	
	return 0;
}

代码运行：

案例：

#include <stdio.h>

int main() {
    int enjoyRunning;
    int enjoyCycling;
    int enjoySwimming;

    // 询问用户是否喜欢跑步
    puts("你喜欢跑步吗？喜欢的话输入1，不喜欢输入0");
    scanf("%d", &enjoyRunning);

    // 询问用户是否喜欢骑车
    puts("你喜欢骑车吗？喜欢的话输入1，不喜欢输入0");
    scanf("%d", &enjoyCycling);

    // 询问用户是否喜欢游泳
    puts("你喜欢游泳吗？喜欢的话输入1，不喜欢输入0");
    scanf("%d", &enjoySwimming);

    // 根据用户的喜好推荐运动
    if (enjoyRunning == 1) {
        printf("跑步是一种很好的有氧运动，能有效提升心肺功能。\n");
    }
    if (enjoyCycling == 1) {
        printf("骑车不仅可以锻炼身体，还能欣赏沿途风景。\n");
    }
    if (enjoySwimming == 1) {
        printf("游泳是全身性的运动，对增强体质大有裨益。\n");
    }

    // 如果用户对这三项活动都不感兴趣
    if (enjoyRunning == 0 && enjoyCycling == 0 && enjoySwimming == 0) {
        printf("你似乎对这些运动没有兴趣，也许可以尝试其他类型的运动，如瑜伽、健身等。\n");
    }

    printf("选择运动，健康生活！\n");

    return 0;
}

2、4 ifelse练习 

#include <stdio.h>

int main() {
    int tooLazyToCook;
    int worriedAboutCost;

    // 询问用户是否懒得做饭
    puts("你懒得做饭吗？如果是的话输入1，不是的话输入0");
    scanf("%d", &tooLazyToCook);

    // 询问用户是否担心外出就餐的费用
    puts("你担心外出就餐的费用吗？如果担心请输入1，不担心请输入0");
    scanf("%d", &worriedAboutCost);

    // 根据用户的回答提供建议
    if (tooLazyToCook == 1 && worriedAboutCost == 0) {
        printf("看来你今天可以选择外出就餐，享受一顿美食吧！\n");
    } else if (tooLazyToCook == 1 && worriedAboutCost == 1) {
        printf("你可以考虑点一些经济实惠的外卖，这样既不用做饭，也能控制预算。\n");
    } else if (tooLazyToCook == 0 && worriedAboutCost == 1) {
        printf("自己做饭是个不错的选择，既能节省费用，又可以按自己的口味调整。\n");
    } else {
        printf("你似乎不怕麻烦，也不担心费用，那就根据心情选择做饭或外出就餐吧！\n");
    }

    printf("祝你用餐愉快！\n");

    return 0;
}

运行： 

        

 

#include <stdio.h>

int main()
{
	char cdata;
	
	//1. 输入一个字符
		//提示输入
	printf("请输入一个字符\n");
		//获取输入
	scanf("%c",&cdata);
	//2. 判断这个字符是不是小写字母
		//2.1 如果是小写字母
	if( cdata >= 97 && cdata <= 122 ){
		//直接输出
		printf("%c",cdata);
	}else if( cdata >= 65 && cdata <=90){//否则  流程图 方图
				
		//转换成小写字母再输出
		printf("%c",cdata+32);
	}else{
		printf("请输入正确的字符\n");
	}
	//3. 程序结束
	printf("\ndone!\n");
	return 0;
}

 运行：

 

2.5 if嵌套练习

#include <stdio.h>

int main()
{
	int Figure;//身材 
	int Pretty;//漂亮 
	int Rich;//有钱
	int Generous; //大方
	
	puts("你身材好？");
	scanf("%d",&Figure);
	
	if(Figure == 1){
		printf("你漂亮？你有钱？（tips：两个数：）\n");
		scanf("%d%d",&Pretty,&Rich);
		if(Pretty == 1 && Rich == 1){
			puts("你的钱愿意给我花？");
			scanf("%d",&Generous);
			if(Generous == 1){
				puts("可以和你做好朋友"); 
			}else{
				puts("不够大方，小气鬼，不可以做好朋友"); 
			} 
		}else{
			printf("不漂亮也没有钱无法愉快玩耍\n");
		}
	}else{
		printf("身材差没有手感\n");
	} 
	return 0;
}

运行示例：

2.6 列表选择switchcase 存在意义、学生成绩等级划分

#include <stdio.h>

int main()
{
	int data;
	char cdata;
	printf("请输入一个数：\n");

	scanf("%d",&data);
	
	switch(data){
		case 1:
		case 2:
		case 4:
		case 5:
		case 3:
			puts("满足了条件1,2,3,4,5的情况");
			break;
	
		case 8:
			puts("满足了条件5的情况");
			break;
		default:
			puts("其他非列表中的情况");	
	}
	
		
	printf("请输入一个字符：\n");

	getchar();
	scanf("%c",&cdata);
	
	switch(cdata){
		case 'a':
			puts("满足了条件a的情况");
			break;
		case 'b':
			puts("满足了条件b的情况");
			break;
		default:
			puts("其他非列表中的情况");	
	}
	
	return 0;
}

运行示例：

2.7 Switch练习学生成绩划分 

#include <stdio.h>

int main()
{
	int score;
	
	puts("请输入分数：");
	scanf("%d",&score);		//56 34 10 9 6 
	switch(score/10){
		case 0:
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
			printf("等级为D,不及格，学渣，垃圾\n");
			break;
		case 6:
		case 7:
			printf("等级为C,一般般，混日子吧\n");
			break;
		case 8:
		case 9:
			printf("等级为B,优秀，很棒\n");
			break;
		case 10:
			printf("等级为A,你不是正常人\n");
			break;
		default:
			printf("成绩非法，请重新输入\n");
	}
	puts("done!");
	return 0;
}

代码运行示例：

 2.8 选择练习路程算折扣

#include <stdio.h>

int main()
{
	int zheKou;
	int luCheng;
	int danJia;
	int zhongLiang;
	
	puts("请输入路程");
	scanf("%d",&luCheng);
	
	if(luCheng < 250){
		zheKou = 0;
	}else if(luCheng >= 250 && luCheng < 500){
		zheKou = 2;
	}else if(luCheng >= 500 && luCheng < 1000){
		zheKou = 5;
	}else if(luCheng >= 1000 && luCheng < 2000){
		zheKou = 8;
	}else if(luCheng >= 2000 && luCheng < 3000){
		zheKou = 10;
	}else{
		zheKou = 15;
	}
	
	printf("折扣是：%.2f\n",(float)zheKou/100);
	return 0;
}

代码运行：

#include <stdio.h>

int main()
{
	int zheKou;
	int luCheng;
	puts("请输入路程");
	scanf("%d",&luCheng);
	
	switch(luCheng/250){
		case 0:
			zheKou = 0;
			break;
		case 1:
			zheKou = 2;
			break;
		case 2: 
		case 3:
			zheKou = 5;
			break;
		case 4:
		case 5:
		case 6:
		case 7:
			zheKou = 8;
			break;
		case 8:
			zheKou = 10;
			break;
		case 9:
		case 10:
		case 11:
			zheKou = 12;
			break;
		default:
			zheKou = 15;
			break;
	}
	printf("折扣是：%.2f\n",(float)zheKou/100);
	return 0;
}

 2.9 作业

#include <stdio.h>
 
int main()
{
    int x,y;
    
    printf("请输入x的值：\n");
    scanf("%d",&x);
 
    if ( x < 1)
    {
        y = x;
    }
    else if ( x < 10 )
    {
        y=2*x-1;
    }
    else 
	{
	
        y=3*x-11;
    }
    
    printf(" y的值为: %d ",y);
    return 0;
}

#include <stdio.h>
 
int main()
{
	int score;
	
	printf("请输入你的成绩\n"); 
	scanf("%d",&score);
	
	if ( score >= 90)
	{
		printf("非常优秀，成绩为: A \n");	
	}
	else if ( score >= 80 && score <= 89)
	{
		printf("优秀，成绩为： B \n");	
	}
	else if (score >= 70 && score <= 79)
	{
		printf("良好，成绩为：C \n");
	}
	else if (score >= 60 && score <= 69)
	{
		printf("及格，成绩为：D\n");
	}else if ( score < 60)
	{
		printf("不及格，成绩为：E\n");
	}
	
	return 0;
}

#include <stdio.h>
 
int main()
{
	int score;
	
	printf("请输入你的分数\n"); 
	scanf("%d",&score);	
	
	switch(score/10){
		case 10:
			puts("非常优秀，成绩为: A");
			break;
		case 8:
		case 9:
			printf("优秀，成绩为： B \n");
			break;
		case 7:
			printf("良好，成绩为： C \n");
			break;
		case 6:
			printf("刚刚及格多一分浪费法，少一分可惜成绩为： C \n");
			break;
		case 5:
			printf("不及格，成绩为：E\n");
			break;
		default :
			printf("成绩非法重新输入\n");					 
	}
	return 0;
}

2.10 while循环

#include <stdio.h>

int main()
{
	int times;//定义好变量 
	times = 101;// 次数
	
	while(times){  //只要条件为真，就一直执行，if,只执行一次
					//避免死循环，到一定程度能满足退出条件。除c51单片机代码
		puts("啦啦，来魔法了");
		times = times - 1;//执行一次减少一次
	}
	
	
	return 0;
}

代码运行示例：

while-- 自减

#include <stdio.h>

int main()
{
	int times;
	times = 10;
	
	while(times){  //只要条件为真，就一直执行，if,只执行一次
					//避免死循环，到一定程度能满足退出条件。除c51单片机代码
		puts("可乐加冰");
		//times = times - 1;
		times--;//自减 
	}
	
	
	return 0;
}

代码运行示例：

 while++自加

#include <stdio.h>

int main()
{
	int times = 0;
	
	//0 1 2 3 4 5 6 7 8 9 
	while(times < 10){  //只要条件为真，就一直执行，if,只执行一次
					//避免死循环，到一定程度能满足退出条件。除c51单片机代码
		puts("魔法打败你");
		printf("times = %d\n",times);//打一次数一次 
		times++;//自加 
	
	}
	
	
	return 0;
}

代码运行：

2.11 while循环计算1-100的和 

#include <stdio.h>

int main()//3个表达式
{
	int sum;//变量最好初始化成0 ，编码习惯
	int data = 1;//第一个表达式，条件的初始值
	int testData;//测试是否会初始化成0 

	while(data <= 100){//第二个表达式，条件的临界值)
		printf("data = %d\n",data);// 
		sum = sum + data;//相加计算方式 
		data++;//第三个表达式，条件发生变化
	}
	printf("0到100的和是：%d\n",sum);
	printf("%d\n",testData);//是否会初始化成0 
	
	return 0;
}

代码运行示例：

2.12 do——while 

#include <stdio.h>

int main()
{
	int data = 0;
	/*while(data != 0){
		printf("this is a test\n");
		data--;
	}*/
	
	do{
		printf("this is a test\n");
		data--;
	}while(data != 0);
	return 0;
}

代码运行示例：

#include <stdio.h>

int main()
{
	int data = 1;
	/*while(data != 0){
		printf("this is a test\n");
		data--;
	}*/
	
	do{
		printf("this is a test\n");
		data--;
	}while(data != 0);
	return 0;
}

2.13 while的表达式以及for循环等价引入

#include <stdio.h>

int main()
{
	int i;
	  // 条件赋初值  判断临界值 条件改变
	for(i=0;i<10;i++){  //判断，执行循环体，条件改变。
		puts("你是胖胖的");//循环体
		puts("大笨蛋");
		
	}
}
//while(1)死循环
//for(;;)
/*
	  // 条件赋初值  判断临界值 条件改变
	for(int i=0;i<10;i++){  //判断，执行循环体，条件改变。

    int i = 0;    

    for( ;i<10;){
    i++;
}
*/

代码运行示例：

2.14循环干涉之break提前结束循环

和continue提前结束本次循环编码分析

#include <stdio.h>

int main()
{
	int numOfPerson;
	int totalMoney = 0;
	int money;
	
	//numOfPerson=1;
	//while(numOfPerson<=1000){
	for(numOfPerson=1;numOfPerson<=1000;numOfPerson++){
		printf("请输入捐款的数目：\n");
		scanf("%d",&money);
		totalMoney = totalMoney+money;
		if(totalMoney >= 100000){
			puts("很棒，已经到达10万元");
			break;
		}
		numOfPerson++;
	}
	
	printf("总捐款人数是%d\n",numOfPerson);
	printf("每个人的平均捐款数据：%f\n",(float)totalMoney/numOfPerson);
	return 0;
}
/*#include <stdio.h>

int main()
{
	int numOfPerson;
	int totalMoney = 0;
	int money;
	
	numOfPerson=1;
	while(numOfPerson<=1000){
	//for(numOfPerson=1;numOfPerson<=1000;numOfPerson++){
		printf("请输入捐款的数目：\n");
		scanf("%d",&money);
		totalMoney = totalMoney+money;
		if(totalMoney >= 100000){
			puts("很棒，已经到达10万元");
			break;
		}
		numOfPerson++;
	}
	
	printf("总捐款人数是%d\n",numOfPerson);
	printf("每个人的平均捐款数据：%f\n",(float)totalMoney/numOfPerson);
	return 0;
}*/

代码示例：

continue

#include <stdio.h>

int main()
{
	int data;
	data = 10;
	
	/*printf("ret = %d\n",10%3);//%余数=除数，10/3=1；余数是1 
	printf("ret = %d\n",11%3);//余数就是要除尽不可留 
	printf("ret = %d\n",12%3);//12/3= 0-
	*/
	
	for(data = 100; data <= 200; data++){
		if(data %3 == 0){ //！= 不能和能== 
			continue;
		}
		printf("%d  ",data);
	}
	return 0;
 } 

代码运行示例：

2.15 for嵌套

#include <stdio.h>

int main()
{
	int i;
	int j;
	for(i=1;i<=4;i++){
		for(j=1;j<=5;j++){	
			printf("%d    ",i*j);
		}	
		printf("\n");
	}
	return 0;
}

代码运行示例:

1    2    3    4    5
2    4    6    8    10
3    6    9    12    15
4    8    12    16    20

最大公约和最小公倍数

#include <stdio.h>

int main()
{
	int m,n,i,max,min;//定义了4个变量,i用于循环时计数
	//如printf()和scanf()函数。这里用到了scanf()函数来读取用户输入的m和n的值
	printf("请依次输入两个正整数m和n：\n");
	scanf("%d%d", &m, &n);
	//求最大公约数
	max = (m > n) ? m : n;//max为m和n中较大的数,三目运算符 
	for(i = max; i > 0; i--)// 一直遍历找到最大数 
	{
		if(m % i == 0 && n % i == 0)//通过if语句判断i是否是m和n的公约数
									//如果是，那么就找到了最大的公约数，									
		{
			printf("%d和%d的最大公约数为：%d\n",m, n, i);
			break;//此时输出结果并跳出循环
		}
	}
	// 求最小公倍数
    min = (m * n) / i; // i为最大公约数,最小公倍数可以通过两数之积除以它们的最大公约数来计算
	printf("%d和%d的最小公倍数为：%d\n", m, n, min);
	
	return 0;
 } 
 /*
 最小公倍数可以通过两数之积除以它们的最大公约数来计算
 因为最小公倍数是最大公约数的倍数。
这里直接使用了已经求得的最大公约数i来求最小公倍数min，
并将结果以printf()函数输出
 */

水仙花数

#include <stdio.h>
#include <math.h>

int main()
{
    int i, num, c, n, sum;

    printf("请输入一个三位正整数：\n");
    scanf("%d", &num);

    sum = 0;
    for(i = num; i > 0; i /= 10)
    {
        c = i % 10;
        n = i / 10 % 10;
        sum += pow(c, 3) + pow(n, 3) + pow(i / 100, 3);
    }

    if(num == sum)
    {
        printf("%d是一个水仙花数。\n", num);
    }
    else
    {
        printf("%d不是一个水仙花数。\n", num);
    }

    return 0;
}

三、第3章 数组

3.1数组初始化

#include <stdio.h>

int main()
{
	int a[10];//这边的10表示大小
	int data;

	/*蠢
	a[0] = 100;
	a[1] = 102;
	a[2] = 1110;
	a[3] = 250;
	*/
	
	
	for(data = 0; data < 10; data++){
		a[data] = data+100; 
	}

	puts("数组初始化完毕");
	for(data = 0; data < 10; data++){
		printf("address: %p, data:%d\n",&a[data],a[data]);
	}
	puts("done");
	return 0;
}

代码运行示例：

 3.2 sizeof关键字以及大小数组计算方法

#include <stdio.h>

int main()
{
	//int a[10] = {1,2,3,4,5,6,7,8,9,10};//这边的10表示大小
	int a[10] = {1,2,3};//这边的10表示大小
	int data;
	int array[] = {100,444,55,66,77,88,99,9};
	int size;
	
	int b[10] = {0};
		//把整个数组的大小，除以数组中一个元素的大小，就获得总个数
	size = sizeof(array)/sizeof(array[0]);//sizeof关键字，能计算括号中对应数据的内存空间大小。
	printf("array的个数有：%d\n",size);
	for(data = 0; data < size; data++){
		printf("address: %p, data:%d\n",&array[data],array[data]);
	}

	return 0;
}

代码运行示例：

 3.3 逆序输出10位数

#include <stdio.h>

int main()
{
	int arr[10];
	int i;
	
	for(i=0;i<10;i++){
		arr[i] = i;
	}
	puts("当前数组是");
	
	for(i=0;i<10;i++){
		printf("%d ",arr[i]);
		
	}
	
	puts("逆序输出后是：\n");
		
	for(i=9;i>=0;i--){
		printf("%d ",arr[i]);
	}
	return 0;
}

代码运行示例：

 3.4 斐波那契数列

#include <stdio.h>

int main()
{
	int arr[30];
	int i;
	int arraySize;
	arraySize = sizeof(arr)/sizeof(arr[0]);
	
	arr[0] = 0;
	arr[1] = 1;
	for(i=2;i<arraySize;i++){
		arr[i] = arr[i-1] + arr[i-2];
	}
	
	for(i=0;i<arraySize;i++){
		printf("%d ",arr[i]);
	}
	printf("\ndone\n");
	return 0;
}

代码运行示例：

3.5冒泡排序

#include <stdio.h>

int main()
{
	int array[] = {12,8,13,9,110,34,1,90,85,101,13,13};
	int i;
	int j;
	int tmp;
	int len = sizeof(array)/sizeof(array[0]);
	
	for(i=0;i<len-1;i++){
		for(j=0; j<len-1-i;j++){
			if(array[j] > array[j+1]){//从<到大、从>到小
				tmp = array[j];
				array[j] = array[j+1];
				array[j+1] = tmp;
			}
		}
	}
	for(i=0;i<len;i++){
		printf("%d ",array[i]);
	}
	return 0;
}

 详细解读以上代码：

1、定义了一个整型数组array，并初始化了数组元素的值。

2、在变量定义时，我们定义了下面四个变量：

    i、j用于循环时控制数组的轮数和比较的元素位置。

    tmp用于交换数组元素时临时存储数组元素的值。

    len用于计算数组array中元素的个数。

3、实现冒泡排序的主循环部分，使用双重for循环，外层循环i用于控制数组的轮数，比较的元素位置，内层循环j用于控制每轮中相邻元素的比较。

    如果发现array[j]大于array[j+1]的话，就进行交换。

4、循环结束后，使用for循环输出排序后的结果。最后返回0，表示程序正常结束。

 3.6选择简单排序

#include <stdio.h>

int main()
{
	int array[] = {12,8,13,9,223,44,5,66,7,88};
	int i;
	int j;
	int tmp;
	int len = sizeof(array)/sizeof(array[0]);
	
	//简单选择排序法
	for(i=0;i<len-1;i++){
		for(j=i+1;j<len;j++){
			if(array[i] < array[j]) 
			{
				tmp = array[i];
				array[i] = array[j];
				array[j] = tmp;
			}
		}
	}

	for(i=0;i<len;i++){
		printf("%d ",array[i]);
	}
	return 0;
}

代码的功能是实现一个简单选择排序算法，目的是将一个数组中的元素按照从大到小排序，并输出排序结果。

接下来逐行解释代码：

1. `#include <stdio.h>`

该行代码是包含了标准输入输出头文件`stdio.h`。

2. `int main()`

程序的入口函数，`main` 函数默认返回一个整型值。

3. `int array[] = {12,8,13,9,223,44,5,66,7,88};`

定义了一个整型数组`array`，包含了初始的无序数组元素。

4. `int i;`

定义了一个整型变量`i`，用于循环及数组下标的操作。

5. `int j;`

定义了一个整型变量`j`，用于循环及数组下标的操作。

6. `int tmp;`

定义了一个整型变量`tmp`，用于交换数组中两个元素的值。

7. `int len = sizeof(array)/sizeof(array[0]);`

计算了数组`array`的长度。

8. `//简单选择排序法`

注释说明使用的是一个简单选择排序算法。

9. `for(i=0;i<len-1;i++){`

第一重循环，控制数组的轮次。

10. `for(j=i+1;j<len;j++){`

第二重循环，控制数组的比较次数，挑选出最大元素并将其交换到最前面。

11. `if(array[i] < array[j])`

比较`array[i]`和`array[j]`的值。

12. `tmp = array[i];`

将`array[i]`的值赋给`tmp`。

13. `array[i] = array[j];`

将`array[j]`的值赋给`array[i]`。

14. `array[j] = tmp;`

将`tmp`的值赋给`array[j]`。

15. `}`

结束第二重循环。

16. `}`

结束第一重循环。

17. `for(i=0;i<len;i++){`

第三重循环，输出排序后的数组元素。

18. `printf("%d ",array[i]);`

输出数组元素，使用空格分隔。

19. `return 0;`

程序执行完毕后，返回整型值`0`，表示程序执行成功。

3、7  二维数组

#include <stdio.h>

int main()
{
	int array[2][3] = {{222,333,444},
						{777,888,999}};
	int i,j;			  
	for(i=0;i<2;i++){
		for(j=0;j<3;j++){
			//printf("%d,%d,%d\n",i,j,array[i][j]);
			printf(" %d  %p \n",array[i][j],&array[i][j]);
		}
	}
	//printf("%d\n",array[1][1]);
	putchar('\n');
	return 0;
 } 
/*
这是一段C语言的程序，主要功能是遍历一个二维数组中的所有元素，并打印每个元素的值和内存地址，以及代码注释。

首先，在程序中定义了一个二维数组array，其大小为2×3。它的第一行元素为222、333和444，第二行元素为777、888和999。


int array[2][3] = {{222,333,444},
                    {777,888,999}};


接下来，使用两个循环遍历这个二维数组中的所有元素，其中i和j分别表示数组元素的行和列。


for(i=0;i<2;i++){
    for(j=0;j<3;j++){
        //printf("%d,%d,%d\n",i,j,array[i][j]);
        printf(" %d  %p \n",array[i][j],&array[i][j]);
    }
}


在每次循环中，打印当前数组元素的值和内存地址。用%p格式化符号打印内存地址，%d格式化符号打印整数。


printf(" %d  %p \n",array[i][j],&array[i][j]);


最后，程序返回0，表示程序正常结束。


return 0;



整个程序在输出的结果中，每行包含一个数组元素的值和对应的内存地址，以空格分隔。如下所示：


222  0x7fff59dd2e90 
333  0x7fff59dd2e94 
444  0x7fff59dd2e98 
777  0x7fff59dd2e9c 
888  0x7fff59dd2ea0 
999  0x7fff59dd2ea4 

*/

#include <stdio.h>

int main()
{
	int array[2][3] = {{222,333,444},{777,888,999}};
	int arr[][4] = {1,2,3,4,5,6,7,8,9};
	int i,j;			  
	for(i=0;i<3;i++){
		for(j=0;j<4;j++){
			//printf("%d,%d,%d\n",i,j,array[i][j]);
			printf("%d ",arr[i][j]);
		}
		//printf("%d\n",array[1][1]);
		putchar('\n');
	}

	return 0;
 } 

这段代码主要功能是遍历一个二维数组并打印每个元素的值。下面我们逐行详细解读它的功能和实现方法。

int array[2][3] = {{222,333,444},{777,888,999}};

这行代码定义了一个二维整型数组`array`，它有两行三列，初始值分别为222、333、444和777、888、999。

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

这行代码定义了一个二维整型数组`arr`，由于在定义时只给定了一个列数，所以程序会自动根据初始化的值来补全行数。这里初始化了一个3行4列的数组，初始值为1-9。

for(i=0;i<3;i++){
    for(j=0;j<4;j++){
        printf("%d ",arr[i][j]);
    }
    putchar('\n');
}

这两行代码实现了对数组的遍历和打印。`for`循环中，变量`i`和`j`分别表示数组元素的行和列。使用嵌套的`for`循环遍历二维数组中的所有元素，并在每次循环中打印当前数组元素的值。

在内部循环结束后，打印一个换行符，使下一行的打印从新的一行开始。


return 0;

程序正常结束并返回0。

整个程序输出结果为：

1 2 3 4 
5 6 7 8 
9 


它将二维数组的元素按从左到右、从上到下的顺序，以空格分隔的形式打印出来了。

四、第4章函数封装

第一个函数练习

• 1. #include <stdio.h>：引入标准输入输出库的头文件，以便使用其中的函数。
• 2. void printwelcome()：声明一个名为 `printwelcome` 的函数，该函数没有输入参数，也没有返回值。
• 3. {}：函数体开始和结束的大括号。
• 4. printf("=====================\n");：在控制台输出字符串“=====================”并换行。
• 5. printf("欢迎来的我的程序\n");：在控制台输出字符串“欢迎来的我的程序”并换行。
• 6. printf("=====================\n");：在控制台输出字符串“=====================”并换行。
• 7. int getData(int data)：声明一个名为 `getData` 的函数，该函数接收一个整数类型的参数 `data`。
• 8. {}：函数体开始和结束的大括号。
• 9. return data-1;：函数返回一个整数类型的值，即传入的参数减去1后的结果。
• 10. `int main()`：程序的主函数，也是程序的起点。
• 11. `{}`：函数体开始和结束的大括号。
• 12. `int x;`：声明一个整型变量 `x`。
• 13. `int y;`：声明一个整型变量 `y`。
• 14. `printwelcome();`：调用 `printwelcome()` 函数，输出欢迎信息。
• 15. `puts("请输入一个数：");`：在控制台输出字符串“请输入一个数：”。
• 16. `scanf("%d",&x);`：从标准输入流读取一个整型值，并将其赋值给变量 `x`。
• 17. `y = getData(x);`：调用 `getData()` 函数，将变量 `x` 的值作为参数传入，并将返回值赋给变量 `y`。
• 18. `printf("x = %d,y = %d\n", x, y);`：输出变量 `x` 和变量 `y` 的值，其中 `%d` 表示输出整型变量，`\n` 表示换行符。
• 19. `return 0;`：将程序的运行状态返回给操作系统，表示程序运行结束并正常退出。
• 综上所述，这是一个简单的基于控制台输入输出的程序，其主要功能是输入一个整数，将其值减1输出。

#include <stdio.h>

void printWelcome()
{
	printf("========================\n");
	printf("欢迎来到我的程序，baby\n");
	printf("========================\n");
}
//数据和值
int getDataFromX(int x)//形式参数，需要包含变量类型，变量名（）
{
	int y;
	y = x-1;
	
	return y; 
}

int main()
{
	int x;
	int y;
	
	printWelcome();
	puts("请输入一个数：");
	scanf("%d",&x);
	y = getDataFromX(x);
	y = getDataFromX(x+1);
	y = getDataFromX(100);
	printf("x=%d，y=%d\n",x,y);
	return 0;
}

 第二个函数加法运算

#include <stdio.h>

int add(int data1,int data2,int data3)
{
	//int ret;//定义一个返回值 
	//ret = data1 + data2 + data3;
	return data1+data2+data3;//直接return返回输出 
	//return ret;//可返回值输出
	 
}
int main()
{
	int x;
	int y;
	int z;
	//int ret;
	int fret;//假结果 
	
	puts("请输入一个数：");
	scanf("%d",&x);
	puts("请再输入一个数：");
	scanf("%d",&y);
	puts("请再输入一个数：");
	scanf("%d",&z);
	
	fret = add(x,y,z)+100;
	printf("%d+%d+%d=%d\n",x,y,z,add(x,y,z));//直接函数体输出，
	//也可返回ret输出 
	printf("fret = %d\n",fret);
	return 0;
}

下面逐行解读这个程序：

1. int add(int data1,int data2,int data3)`：定义一个名为 `add` 的函数，该函数接收三个整型参数 data1`、`data2`、`data3`。
2. {}：函数体开始和结束的大括号。
3. return data1+data2+data3;`：将 `data1`、`data2` 和 `data3` 的值相加并返回结果。
4. int main()：程序的主函数，也是程序的起点。
5. {}：函数体开始和结束的大括号。
6. `int x;`：声明一个整型变量 `x`。
7. `int y;`：声明一个整型变量 `y`。
8. `int z;`：声明一个整型变量 `z`。
9. `int fret;`：声明一个整型变量 `fret`。
10. `puts("请输入一个数：");`：在控制台输出字符串“请输入一个数：”。
11. `scanf("%d",&x);`：从标准输入流读取一个整型值，并将其赋值给变量 `x`。
12. `puts("请再输入一个数：");`：在控制台输出字符串“请再输入一个数：”。
13. `scanf("%d",&y);`：从标准输入流读取一个整型值，并将其赋值给变量 `y`。
14. `puts("请再输入一个数：");`：在控制台输出字符串“请再输入一个数：”。
15. `scanf("%d",&z);`：从标准输入流读取一个整型值，并将其赋值给变量 `z`。
16. `fret = add(x,y,z)+100;`：调用 `add()` 函数，将变量 `x`、`y` 和 `z` 的值作为参数传入，并将返回值加100后赋给变量 `fret`。
17. `printf("%d+%d+%d=%d\n",x,y,z,add(x,y,z));`：将 `x`、`y`、`z` 和 `add(x,y,z)` 的值依次输出，并将 `add(x,y,z)` 的返回值作为最后一个参数输出。
18. `printf("fret = %d\n",fret);`：将 `fret` 的值输出。
19. `return 0;`：将程序的运行状态返回给操作系统，表示程序运行结束并正常退出。

综上所述，这是一个基于控制台输入输出的程序，主要功能是输入3个整数，将它们的值相加并输出，同时将结果加 100 后输出。程序定义了一个函数 `add()`，通过调用该函数实现整数相加。

 第3个形参-实参=====打印内存地址变量

#include <stdio.h>

//数据和值
int test(int x)//形式参数，需要包含变量类型，变量名（） 生命周期：栈空间，
				//被调用的时候才为形式参数申请内存，调用结束，内存有被系统释放
				//局部变量的有效作用空间（作用域）要记得
{
	int y;
	printf("test的x内存地址是%p,数值是%d\n",&x,x);
	return y; 
}
//变量四要素： 名 类型 值 地址
int main()
{
	int x;
	int y;

	
	
	puts("请输入一个数：");
	scanf("%d",&x);
	printf("main的x内存地址是%p,数值是%d\n",&x,x);
	y = test(x);//实际参数
	//printf("x=%d，y=%d\n",x,y);
	return 0;
}

 第4封装获得两个数的大数

程序的功能是获取用户输入的两个浮点数，比较它们的大小，然后将较大的值输出。

程序中首先定义了一个函数`getBigDataFromTwo`，这个函数有两个参数：x和y，代表要比较的两个数。函数中使用三目运算符`x > y ? x : y`比较x和y的大小，如果x大于y，则返回x的值，否则返回y的值。程序中还注释掉了一段if语句的代码，与三目运算符的功能类似，都是找出x和y中的较大值。

在主函数中，首先提示用户输入两个数`puts("请输入两个数：");`，然后使用`scanf("%f%f",&data1,&data2);`从键盘获取用户的输入。接下来调用`getBigDataFromTwo`函数，将用户输入的两个数作为参数传递给函数，获取这两个数的较大值。最后使用`printf`函数将获取到的较大值和用户输入的两个数一起输出`printf("两个数据是%.2f,%.2f，大数是：%.2f\n",data1,data2,bigOne);`，其中%.2f表示输出浮点数时保留两位小数。程序的整体思路比较清晰，主要是实现获取用户输入和进行大小比较，是C语言中比较基础的程序。

#include <stdio.h>

float getBigDataFromTwo(float x, float y)
{
	//int z;
	/*
	if(x > y){
		z = x;
	}else{
		z = y;
	}
	*/
	//z = x>y?x:y;
	return x>y?x:y;
	//return z;
}

int main()
{
	float data1;
	float data2;
	float bigOne;
	//输入两个数
	//提示输入
	puts("请输入两个数：");
	//获取输入
	scanf("%f%f",&data1,&data2);
	//函数调用
	bigOne = getBigDataFromTwo(data1, data2);
	//输出结果
	printf("两个数据是%.2f,%.2f，大数是：%.2f\n",data1,data2,bigOne);
	return 0;
}
/*
程序的功能是获取用户输入的两个浮点数，比较它们的大小，然后将较大的值输出。

程序中首先定义了一个函数`getBigDataFromTwo`，这个函数有两个参数：x和y，代表要比较的两个数。函数中使用三目运算符`x > y ? x : y`比较x和y的大小，如果x大于y，则返回x的值，否则返回y的值。程序中还注释掉了一段if语句的代码，与三目运算符的功能类似，都是找出x和y中的较大值。

在主函数中，首先提示用户输入两个数`puts("请输入两个数：");`，然后使用`scanf("%f%f",&data1,&data2);`从键盘获取用户的输入。接下来调用`getBigDataFromTwo`函数，将用户输入的两个数作为参数传递给函数，获取这两个数的较大值。最后使用`printf`函数将获取到的较大值和用户输入的两个数一起输出`printf("两个数据是%.2f,%.2f，大数是：%.2f\n",data1,data2,bigOne);`，其中%.2f表示输出浮点数时保留两位小数。程序的整体思路比较清晰，主要是实现获取用户输入和进行大小比较，是C语言中比较基础的程序。*/

第5函数嵌套

#include <stdio.h>

int getDataFromTwo(int data1,int data2)
{
	int biger;
	
	biger = data1>data2?data1:data2;
	
	return biger;
}

int getDataFromFour(int a,int b,int c,int d)
{
	int max;
	max = getDataFromTwo(a,b);
	max = getDataFromTwo(max,c);
	max = getDataFromTwo(max,d);
	
	return max;
}

int main()
{
	int data1;
	int data2;
	int data3;
	int data4;
	int thebigOne;
	
	printf("Please enter four numbers:\n");
	scanf("%d%d%d%d",&data1,&data2,&data3,&data4);
	
	thebigOne = getDataFromFour(data1,data2,data3,data4);
	
	printf("The largest number is: %d\n",thebigOne);
	return 0;
 } 

1、主函数，首先定义4个整型变量data1、data2、data3和data4，
并声明一个整型变量thebigOne。接着，使用标准输入函数scanf从标准输入流中读取4个整型数据。
然后，通过调用getDataFromFour函数获取四个数中的最大值，结果保存在变量thebigOne中。
最后使用printf函数输出最大值。

2、定义函数getDataFromFour，该函数接受四个整型参数，
并返回四个参数中的最大值。在该函数内部，通过调用getDataFromTwo函数来逐步求出最大值。

3、定义函数getDataFromTwo，该函数接受两个整型参数，并返回两个参数中较大的那个数。

第6个递归函数求年龄算法

#include <stdio.h>

int getAge(int currPersonNum)//当前人数 
{
	int age;
	
	if(currPersonNum == 1){
		age = 10;
	}else{
		age = getAge(currPersonNum -1)+2;
	}
	return age;	
}

int main()
{
	int age;
	int num;
	
	printf("你要知道第几个学生的年龄：\n");
	scanf("%d",&num);
	
	age = getAge(num);
	 
	printf("第%d个学生的年龄是：%d\n",num,age);
	
	return 0;
 } 

这是一个计算第 n 个学生年龄的程序，程序中使用了递归函数 `getAge` 来计算每个学生的年龄。

首先，在 `getAge` 函数中，根据当前人数 `currPersonNum` 分别处理特殊情况和一般情况。如果当前人数是 1，即第一个学生，那么他的年龄为 10 岁；否则，根据题目中的规律，第 i 个学生的年龄是第 (i-1) 个学生的年龄加 2。因此，递归调用 `getAge(currPersonNum - 1)` 来计算第 (currPersonNum-1) 个学生的年龄，再加上 2 就是当前学生的年龄。

在 `main` 函数中，先读入要查询年龄的学生序号 `num`，再调用 `getAge(num)` 来计算第 `num` 个学生的年龄。最后输出查询结果。

该程序正确运行的输出为：

```
你要知道第几个学生的年龄：
5
第5个学生的年龄是：18

代码行解读如下：

1. `#include <stdio.h>`：包含标准输入输出头文件。

3. `int getAge(int currPersonNum) //当前人数`：定义递归函数 `getAge`，参数是当前要计算年龄的学生序号 `currPersonNum`。

5. `int age;`：定义整型变量 `age`，准备用来存储当前学生的年龄。

7. `if(currPersonNum == 1){`：如果当前计算的是第一个学生（`currPersonNum` 的值为 1），则执行以下代码块。

8. `age = 10;`：第一个学生的年龄是 10 岁，赋值给 `age`。

10. `}else{`：如果当前计算的不是第一个学生，则执行以下代码块。

11. `age = getAge(currPersonNum -1)+2;`：计算第 currPersonNum 个学生的年龄，根据题目规律，等于第 (currPersonNum-1) 个学生的年龄加 2。因此调用递归函数 `getAge` 来计算第 (currPersonNum-1) 个学生的年龄，再加 2 赋值给 `age`。

13. `return age;`：返回当前学生的年龄。

15. `int main()`：主函数开始。

17. `int age;`：定义整型变量 `age`，准备存储所查询学生的年龄。

18. `int num;`：定义整型变量 `num`，准备存储要查询的学生序号。

20. `printf("你要知道第几个学生的年龄：\n");`：输出提示信息，让用户输入要查询的学生序号。

21. `scanf("%d",&num);`：读取用户输入的要查询的学生序号，存储在 `num` 中。

23. `age = getAge(num);`：调用递归函数 `getAge` 计算第 `num` 个学生的年龄，赋值给 `age`。

25. `printf("第%d个学生的年龄是：%d\n",num,age);`：输出查询结果，格式化输出结果包括第 `num` 个学生的序号和年龄。

27. `return 0;`：返回 0 表示程序正常结束。

 第7函数求N阶乘

这是一个和上面的程序类似的用递归计算阶乘的C语言程序，但是在计算前增加了一个判断，如果输入的数大于 17，则输出“越界”并结束程序。

相比上面的程序，这个程序增加了程序的可靠性，避免了计算结果超出 `long int` 范围的问题。同时通过 `exit(-1);` 终止程序的运行，避免继续执行可能会产生意料之外的结果的代码。

此外，它输出的 `long int` 的字节数和上一个程序相同。

首先声明了一个函数 `getFactorial`，它接收一个参数 `num`，表示要求阶乘的数。这个函数的返回值类型是 `unsigned long int`。

在 `getFactorial` 中，先声明了一个变量 `result`，表示阶乘的结果。

函数使用了递归的方法来计算阶乘。如果 `num` 等于 1，说明到达了递归的最底层，阶乘为1；否则，将 `num` 减去 1 作为参数再次调用 `getFactorial` 函数，然后将返回的结果乘以 `num`，得到当前层次的阶乘值。

最后，主函数中接收用户输入的数 `num`，调用 `getFactorial` 函数计算阶乘，将结果输出。

值得注意的是，这里将计算阶乘的结果类型定义为了 `unsigned long int`，这是为了避免计算出来的阶乘数超过 `long int` 表示范围的问题。同时，在程序中也输出了系统中使用的 `long int` 变量的字节数，以便更好地理解变量类型的选择。

//```
#include <stdio.h>
#include <stdlib.h>
/*```
这句代码包含了 C 语言标准库中的 I/O 函数声明和内存管理函数声明。

```*/
unsigned long int getFactorial(int num)//阶乘getFactorial
{
    long int result;

    if(num >=17){
        printf("越界\n");
        exit(-1);
    }
    if(num == 1){
        result = 1;
    }else{
        result = getFactorial(num-1) * num;
    }
    return result;
}
/*```
这个代码部分定义了一个递归函数 `getFactorial`，用来计算 `num` 的阶乘。它包含了下列语句：

- `*/long int result;`：//定义了一个变量 `result`，用来表示阶乘的结果。
//if(num > 17){​//如果输入的数超过了 17，则输出“越界”并终止程序运行。
//if(num == 1){​//如果输入的参数为 1，则将 `result` 赋值为 1。
//result = getFactorial(num-1) * num;/*：如果输入参数不是 1，则通过递归调用 `getFactorial` //函数来计算阶乘。*/
//return result;//`：计算完成后，返回阶乘的结果。

//```
int main()
{
    int num;
    unsigned long int ret;

    puts("请输入要求的阶乘数：");
    scanf("%d",&num);
    ret = getFactorial(num);
    printf("%d阶乘是：%ld\n",num,ret);
    printf("%d\n",sizeof(long int)); 
    return 0;
}
```
/*这段代码包含了 `main()` 函数的定义。

- `int num;`：定义一个变量 `num`，用于接收用户输入。
- `unsigned long int ret;`：定义一个变量 `ret`，用来记录阶乘的结果。
- `puts("请输入要求的阶乘数：");`：输出提示信息，告诉用户需要输入一个整数来计算阶乘。
- `scanf("%d",&num);`：读取用户输入的整数。
- `ret = getFactorial(num);`：调用 `getFactorial` 函数来计算 `num` 的阶乘，并将结果赋值给 `ret`。
- `printf("%d阶乘是：%ld\n",num,ret);`：输出阶乘的结果。
- `printf("%d\n",sizeof(long int));`：输出由 `long int` 类型变量表示的大小，以字节为单位。
- `return 0;`：结束程序的执行，并返回值 0 表示程序执行成功。*/

第8个数组传参中关于形式参数的，函数数组

• 在第3行至第6行之间，定义了一个函数printData。这个函数接收一个整数参数data，并且使用printf函数打印出该参数的值。

• 在第8行至第16行之间，定义了一个函数printArr。这个函数接收两个参数，一个是整型数组arry[]，另一个是整数len，用来表示数组的长度。在函数中，通过sizeof(arry)获取数组arry的大小，但是在形参中，arry实际上是一个指针，所以sizeof(arry)返回的是指针的大小（通常为8字节）。然后使用一个循环遍历数组的每个元素，并使用printf函数逐个打印出来。

• 在第18行至第23行之间，定义了主函数main。在函数内部，首先定义了一个整数变量len，用于存储数组arry的长度。通过sizeof(arry) / sizeof(arry[0])可以计算出数组的长度。然后通过printf函数将数组arry的大小打印出来。接下来，通过两次调用printArr函数来打印数组的内容，第一次传递了数组的首地址&arry[0]，第二次传递了数组名arry，对于数组名的传递，它代表整个数组的首地址。最后，函数返回0，表示程序正常结束。

#include <stdio.h>

void printData(int data)
{
	printf("%d\n",data);	
}

void printArr(int arry[],int len)
{//形参中不存在数组的概念，即使中括号约定了数组的大小，也无效。
	//传递是一个地址，是数组的首地址 
	int i;
	printf("printArr: arry的大小是：%d\n",sizeof(arry));
	//在os用8个字节来表示一个地址 
	for(i=0; i < len; i++){
		printf("%d ",arry[i]);
	}
	putchar('\n');
}
int main()
{
	int len; 
	int arry[] = {1,2,3,4,5,6,7,8,9,10,11,12};
	len = sizeof(arry)/sizeof(arry[0]);
	printf("main: arry的大小是：%d\n",sizeof(arry));
	
	printArr(&arry[0],len);//第一个元素的地址也是数组的首地址，/记得一定要传参
	printArr(arry[0],len);//数组名代表整个数组首地址 
	return 0;
 } 

 

 第9个值传递和真正的数组地址传递

在这个代码中，定义了一个函数changData，它接收一个整数参数data。在main函数中，你定义了一个整数变量data并初始化为10。然后你调用了changData函数并传递这个变量。

在changData函数内部，参数data是通过数值传递方式传递的，这意味着传递给函数的实际参数值被复制到了函数内部的一个新的变量。所以，在changData函数内部对data的修改不会影响到main函数中的data变量。在函数内部，data的值增加了100，并且打印出了在函数内部的地址和值。

回到main函数，下一行的printf语句打印出了在main函数中的data变量的地址和值。你会发现，在main函数中，data的值仍然是10，这是因为changData函数中对参数进行的修改对main函数中的变量没有影响。

最后，main函数返回0，表示程序正常结束

 值传递

#include <stdio.h>

void changData(int data)//数值传递，操作的是不同的内存空间 
{
	data = data + 100;
	printf("address : %p dataInfunc = %d\n",&data,data);
	
}
int main()
{
	int data = 10;
	changData(data);
	printf("address: %p data = %d\n",&data,data);
	return 0;
}

 

地址数组传递

在这段代码中，更新了changData函数来接受一个整型数组data[]作为参数。在main函数中，你定义了一个包含两个元素的整型数组data并进行了初始化。

在changData函数中，数组名data在作为参数传递时实际上代表数组的首地址。因此，传递给changData函数的是数组的地址。在函数内部，可以通过修改数组元素的方式修改实际的数据，因为操作的是同一块内存空间。

在changData函数内部，对data[0]的值进行了加100的操作，然后通过printf函数打印出了在函数内部的地址和值。

回到main函数，下一行的printf语句打印出了在main函数中的data[0]元素的地址和值。你会发现，在main函数中，data[0]的值已经被修改为110，因为在changData函数中对数组元素进行了修改。

最后，main函数返回0，表示程序正常结束

#include <stdio.h>

void changData(int data[])//操作的一定是相同的内存空间，数组名当作实参到底传了什么 
	//传的是地址 
{
	data[0] = data[0] + 100;
	printf("address: %p, dataInFunc = %d\n",&data[0],data[0]);
}
int main()
{
	int data[2]= {10,20};
	changData(data);
	printf("address: %p, data = %d\n",&data[0],data[0]);
	return 0;
}

 

 第10个数组函数求不同班级学生的平均分

#include <stdio.h>

void initArr(int array[], int len)
{
    int i;
    for(i = 0; i < len; i++){
        printf("请输入第%d个学生的成绩：\n", i + 1);
        scanf("%d", &array[i]);
    }
    printf("deno");
}

void printArry(int array[], int len)
{
    int i;
    printf("总人数%d个\n", len);
    for(i = 0; i < len; i++){
        printf("%d ", array[i]);
    }
    printf("\n deno \n");
}

float getAverage(int array[], int len)
{
    int i;
    float aver = 0.0;
    int sum = 0; // 总分变量初始化一定要为0，默认值可能是一个大数会影响结果 

    for(i = 0; i < len; i++){
        sum = sum + array[i];
    }
    aver = (float)sum/len;
    return aver;
}

int main()
{
    int classOne[5];
    int classTwo[5];
    float averOfClassOne;
    float averOfClassTwo;

    int lenOfClassOne = sizeof(classOne)/sizeof(classOne[0]);
    int lenOfClassTwo = sizeof(classTwo)/sizeof(classTwo[0]);

	initArr(classOne,lenOfClassOne);
	initArr(classTwo,lenOfClassTwo);
	
	printArry(classOne,lenOfClassOne);
	printArry(classTwo,lenOfClassTwo);
	
	averOfClassOne = getAverage(classOne,lenOfClassOne);
	averOfClassTwo = getAverage(classTwo,lenOfClassTwo);
	
	printf("一班的平均分：%f\n",averOfClassOne);
	printf("一班的平均分：%f\n",averOfClassTwo);
    return 0;
}

 计算两个班级学生成绩平均分的简单示例：

1、定义了一个名为initArr的函数，该函数用于初始化一个数组。它接受一个整型数组array和一个整型变量len作为参数。在函数内部，使用for循环提示用户输入每个学生的成绩，并将成绩存储到数组中。

2、定义了一个名为printArry的函数，该函数用于打印数组中的元素。它接受一个整型数组array和一个整型变量len作为参数。在函数内部，使用for循环遍历数组，并逐个打印数组元素。

3、定义了一个名为getAverage的函数，该函数用于计算数组中元素的平均值。它接受一个整型数组array和一个整型变量len作为参数。在函数内部，使用for循环遍历数组并累加数组元素的值，然后除以数组的长度得到平均值。

4、定义了主函数main。在主函数内部，声明了两个含有5个元素的整型数组classOne和classTwo，以及两个浮点型变量averOfClassOne和averOfClassTwo。接下来，通过sizeof运算符计算出数组的长度，并将其赋值给对应的变量。

5、然后，依次调用initArr函数对两个数组进行初始化，用户需要输入每个学生的成绩。接着，调用printArry函数分别打印两个数组的元素。

最后，调用getAverage函数计算每个班级的平均分，并使用printf函数打印出结果。

 第11个函数二维数组输入

可以不写行但是要写列void printfDoubleArry(int array[][3])

• main函数：
• 1、定义max用于传参；
• 2、定义一个array数组[2][3]；
• 3、定义一个arr数组[3][4]；
• 4、定义一个void函数 printfDoubleArry传参(array);
• 5、定义一个initArryDouble函数传参arr,传参3、4；
• 6、max =  getMaxFromArrDouble函数，传参arr,3,4;
• 7、打印输出printf("二维数组最大的值是%d\n",max);最大的函数；
• void printfDoubleArry(int array[][3]):
• 定义了一个名为 printfDoubleArry 的函数，它接受一个二维整数数组作为参数，并没有返回值。此函数用于打印二维数组的内容。
• void initArryDouble(int array[][4], int han, int lie)：
• 定义了一个名为 initArryDouble 的函数，接受一个二维整数数组、行数和列数作为参数，并没有返回值。此函数用于初始化二维数组，通过用户输入从控制台读取数组的值。
• int getMaxFromArrDouble(int array[][4], int han, int lie)：
• 定义了一个名为 getMaxFromArrDouble 的函数，接受一个二维整数数组、行数和列数作为参数，并返回一个整数值。此函数用于在二维数组中找到最大的元素，并将其返回。

#include <stdio.h>

void printfDoubleArry(int array[][3])
{
    int i,j;
    for(i = 0;i < 2; i++){
        for(j = 0; j < 3; j++){
            printf("%d ",array[i][j]);
        }
        putchar('\n');
    }
}

void initArryDouble(int array[][4],int han,int lie)
{
    int i,j;
    for(i = 0; i < han; i++){
        for( j = 0; j < lie; j++){
            printf("请输入第%d行，第%d的数据是\n",i+1,j+1);
            scanf("%d",&array[i][j]);
        }
    }
}

int getMaxFromArrDouble(int array[][4],int han,int lie)
{
    int i;
    int j;
    int max;
    
    max = array[0][0];
    for(i = 0; i < han; i++){
        for(j = 0; j < lie; j++){
            if(max < array[i][j]){
                max = array[i][j];
            }
        }
    }
    return max;
}
int main()
{
    int max;
    int array[2][3] = {{2,1,3},
                        {4,5,6}};
    int arr[3][4];
    
    printfDoubleArry(array);
    initArryDouble(arr,3,4);
    
    max = getMaxFromArrDouble(arr,3,4);
    
    printf("二维数组最大的值是%d\n",max);
    return 0;
}

 第12函数全局变量概念

1、int q = 100;int p = 50;全局变量所有函数都可以操作有风险；

2、int a = 200;int b = 550;外部变量，定义以下可以用函数，也可以调用；

3、外部变量，之后的所有函数可以用，之前的不能用

#include <stdio.h>
#include <stdlib.h>

int q = 100;//全局变量，写在所有的函数之前的外部变量
int p = 50;//程序员便捷，但是有隐藏风险！所有的函数
			//都可以操作这个变量

void fun1()
{
    printf("fun1 = %d\n",q);
    printf("fun1 = %d\n",p);
    putchar('\n');    
}

int a = 200;//外部变量
int b = 550;

void fun2()
{
    printf("fun2 = %d\n",a);
    printf("fun2 = %d\n",b);
    putchar('\n');
}
int main()
{
    fun1();
    fun2();
    
    printf("main: = %d\n",a);
    printf("main: = %d\n",p);
    return 0;
}

第十三个求最高，最低，平均分 

1. #include <stdio.h>：包含标准输入输出的头文件。
2. #include <stdlib.h>：包含标准库函数的头文件。
3. int max;：声明一个名为 max 的整型变量，用于存储最大值。
4. int min;：声明一个名为 min 的整型变量，用于存储最小值。
5. float getResult(int arr[],int len)：函数的原型声明，用于计算平均值，并返回计算结果。
6. int scores[] = {12,23,34,45,56,67,78,89,90,40};：定义一个包含 10 个整型元素的数组 scores，并进行初始化。
7. float aver;：声明一个名为 aver 的浮点型变量，用于存储平均值。
8. aver = getResult(scores,sizeof(scores)/sizeof(scores[0]));：调用 getResult 函数，计算 scores 数组的平均值，并将结果赋值给 aver 变量。
9. printf("班级的最高分是:%d,最低分是：%d,平均数分是：%2.f\n",max,min,aver);：使用 printf 函数打印班级的最高分、最低分和平均值。

#include <stdio.h>
#include <stdlib.h>

int max;
int min;

float getResult(int arr[],int len)
{
    int i;
    int sum = 0;
    max = arr[0];
    min = arr[0];
    for (i = 0; i < len; i++){
        if(max < arr[i]){
            max = arr[i];
        }
        if(min > arr[i]){
            min = arr[i];
        }
        sum = sum +  arr[i];
    }
    return (float)sum/len;
}
int main()
{
    //定义一个数组
    int scores[] = {12,23,34,45,56,67,78,89,90,40};
    //定义一个小数作为除数承接
    float aver;
    //
    aver = getResult(scores,sizeof(scores)/sizeof(scores[0]));
    printf("班级的最高分是:%d,最低分是：%d,平均数分是：%2.f\n",max,min,aver);
    return 0;
}

 

第14要求输入10个数，找出最大数以及最大数的下标。

#include <stdio.h>   // 包含标准输入输出的头文件
#include <stdlib.h>  // 包含标准库函数的头文件
#define SIZE 10       // 定义数组的大小为10

int arr[SIZE];        // 定义全局数组，用于存储输入的10个数

int max;              // 用于存储最大数
int index;            // 用于存储最大数的下标

void getData(int arr[]) {    // 定义函数，用于获取输入的10个数，参数是数组
    int i;
    printf("请输入10个数:\n");     // 提示用户输入10个数
    for (i = 0; i < SIZE; i++) {   // 循环获取输入的10个数
        printf("请输入第%d个数: ", i + 1);
        scanf("%d", &arr[i]);     // 将输入的数存储到数组中
    }
}

void findMax() {    // 定义函数，用于找出最大数及其下标
    max = arr[0];   // 假设第一个数是最大的
    index = 0;      // 初始化最大数的下标为0

    int i;
    for (i = 1; i < SIZE; i++) {
        // 遍历数组，如果当前数比最大数大，则更新最大数及其下标
        if (arr[i] > max) {
            max = arr[i];
            index = i;
        }
    }
}

int main() {
    getData(arr);   // 调用函数获取输入的10个数
    findMax();      // 调用函数找出最大数及其下标

    printf("最大数是：%d\n", max);          // 打印最大数
    printf("最大数的下标是：%d\n", index);   // 打印最大数的下标
    
    return 0;   // 返回0，表示程序正常结束
}

 

 第15个封装冒泡排序的函数

#include <stdio.h>
#define SIZE 10

void bubbleSort(int arr[], int size) {
    int i, j;
    for (i = 0; i < size - 1; i++) {
        for (j = 0; j < size - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换相邻的两个数
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[SIZE];
    int i;

    printf("请输入%d个数:\n", SIZE);
    for (i = 0; i < SIZE; i++) {
        printf("请输入第%d个数: ", i + 1);
        scanf("%d", &arr[i]);
    }

    printf("排序前的数组：");
    for (i = 0; i < SIZE; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // 调用函数对数组进行冒泡排序
    bubbleSort(arr, SIZE);

    printf("排序后的数组：");
    for (i = 0; i < SIZE; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

 最好用的冒泡排序

#include <stdio.h>

void get_arr(int arr[], int size)
{
    int i; 
    for (i = 0; i < size; i++)
    {   
        printf("请输入第%d个数据：", i + 1);
        scanf("%d", &arr[i]);
    }
}

void sort(int arr[], int size)
{
    int i, j;
    for (i = 0; i < size - 1; i++)
    {
        for (j = 0; j < size - i - 1; j++)
        {
            if (arr[j] > arr[j+1])
            {
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }   
        }   
    }   
}

void print_arr(int arr[], int size)
{
    int i;
    for (i = 0; i < size; i++)
    {
        printf("%d ", arr[i]);
    }
}

int main()
{
    int arr[10];
    int size = sizeof(arr) / sizeof(arr[0]);

    get_arr(arr, size);

    sort(arr, size);

    print_arr(arr, size);

    return 0;
}

 

第16封装选择排序的函数

#include <stdio.h>
#define SIZE 10

void selectionSort(int arr[], int size) {
    int i, j, minIndex, temp;
    for (i = 0; i < size - 1; i++) {
        minIndex = i;
        for (j = i + 1; j < size; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        
        // 交换最小值到已排序部分的末尾
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

int main() {
    int arr[SIZE];
    int i;

    printf("请输入%d个数:\n", SIZE);
    for (i = 0; i < SIZE; i++) {
        printf("请输入第%d个数: ", i + 1);
        scanf("%d", &arr[i]);
    }

    printf("排序前的数组：");
    for (i = 0; i < SIZE; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // 调用函数对数组进行选择排序
    selectionSort(arr, SIZE);

    printf("排序后的数组：");
    for (i = 0; i < SIZE; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}