作业讲解:
2>有学生的信息录入功能:输入学生个数,并将学生的姓名、分数录入
#include<stdio.h>
#include<stdlib.h>
#include <string.h>
#define MAX 100 //能够容纳的总人数
int num = 0; //实际使用的个数
//定义菜单函数
void printf_menu()
{
printf("\t\t=====1、录入学生的信息=====\n");
printf("\t\t=====2、查看学生信息=====\n");
printf("\t\t=====3、求出学习最好的学生信息=====\n");
printf("\t\t=====4、按姓名将所有学生进行升序排序=====\n");
printf("\t\t=====5、按成绩将所有学生进行升序排序=====\n");
printf("\t\t=====0、退出=====\n");
}
//定义录入学生信息函数
void lulu(char student[][20],int score[])
{
//实际学生人数的录入
printf("请输入学生个数:");
scanf("%d", &num);
getchar();
//循环录入学生信息
for (int i = 0; i < num; i++) {
printf("请输入%d个学生的姓名:", i + 1);
scanf("%s", student[i]);
printf("请输入%d个学生的分数:", i + 1);
scanf("%d",& score[i]);
printf("\n");
}
printf("学生的信息录入成功\n");
}
//定义查看学生信息函数
void chakan(char student[][20],int score[])
{
printf("学生信息如下:\n");
printf("\t姓名\t成绩\n");
for (int i = 0; i < num; i++) {
printf("\t%s\t%d\n", student[i], score[i]);
}
}
//求出学习最好的学生信息
int max_1(char student[][20],int score[])
{
int max=score[0];
int maxi=0;
for(int i=1;i<num;i++)
{
if(score[i]>max)
{
max=score[i];
maxi=i;
}
}
printf("学习最好的学生为:%s,分数为:%d\n",student[maxi],score[maxi]);
}
//按姓名将所有学生进行升序排序
int xmshx(char student[][20],int score[])
{
printf("按姓名升序排后:\n");
char temp[20]=""; //名字
int maxj=0; //成绩
//排序
for(int i=1;i<num;i++)
{
for(int j=0;j<num-i;j++)
{
if(strcmp(student[j],student[j+1])>0)
{
//交换姓名
strcpy(temp,student[j]);
strcpy(student[j],student[j+1]);
strcpy(student[j+1],temp);
// 交换成绩
maxj=score[j];
score[j]=score[j+1];
score[j+1]=maxj;
}
}
}
//输出排序后学生的信息
printf("\t姓名\t成绩\n");
for(int i=0;i<num;i++)
{
printf("\t%s\t%d\n",student[i],score[i]);
}
}
//按成绩将所有学生进行升序排序
int chjjx(char student[][20],int score[])
{
printf("按成绩升序排后:\n");
char temp[20]="";
int maxj=0;
for(int i=1;i<num;i++)
{
for(int j=0;j<num-i;j++)
{
if(score[j]>score[j+1])
{
//交换姓名
strcpy(temp,student[j]);
strcpy(student[j],student[j+1]);
strcpy(student[j+1],temp);
// 交换成绩
maxj=score[j];
score[j]=score[j+1];
score[j+1]=maxj;
}
}
}
//输出排序后学生表信息
printf("\t姓名\t成绩\n");
for(int i=0;i<num;i++)
{
printf("\t%s\t%d\n",student[i],score[i]);
}
}
/****************主程序****************/
int main(int argc, const char *argv[])
{
//定义学生姓名数组
char student[MAX][20]={""}; //姓名数组
int score[MAX]={0}; //分数数组
//做个菜单
int menu=0;
while(1)
{
printf_menu(); //调用菜单函数
printf("请输入>>>");
scanf("%d",&menu);
getchar(); //吸收回车
//多分支选择
switch(menu)
{
case 1:
{
//完成录入功能
lulu(student,score);
}
break;
case 2:
{
//完成查看功能
chakan(student,score);
}
break;
case 3:
{
//完成查看学习最好的功能
max_1(student,score);
}
break;
case 4:
{
//完成姓名排序功能
xmshx(student,score);
}
break;
case 5:
{
//完成成绩排序功能
chjjx(student,score);
}
break;
case 0: exit(0); //退出程序
default:printf("您输入的功能有误,请重新输入\n");
}
}
}
运行结果:
值传递与地址传递(非常重要)
1.1值传递
1>值传递的原理
2>说明:
当普通变量作为函数参数传递时,是单向的值传递,仅仅只是将实参的值,复制一份给形参使用,形参的改变不会影响到实参的值
3>代码实现
#include<stdio.h>
//定义交换函数
void swap_1(int m, int n)
{
//完成两个数的交换
int temp = m;
m = n;
n = temp;
printf("交换后,swap_1:: m = %d, n = %d\n", m, n);
}
/*********************主程序*********************/
int main(int argc, const char *argv[])
{
//定义两个变量
int num = 520;
int key = 1314;
//调用交换函数
swap_1(num, key);
printf("交换后,main:: num = %d, key = %d\n", num, key);
return 0;
}
运行结果:
1.2地址传递
1>地址传递原理图
2>说明:
当实参传递的是数组名、指针或变量的地址(&num)时,可以理解成是地址传递
3>程序实现
#include<stdio.h>
//定义冒泡排序函数
void sort_up(int brr[], int n)
{
printf("sizeof(brr) = %ld\n", sizeof(brr)); //
//进行冒泡排序
for(int i=1; i<n; i++)
{
for(int j=0; j<n-i; j++)
{
if(brr[j] > brr[j+1])
{
int temp = brr[j];
brr[j] = brr[j+1];
brr[j+1] = temp;
}
}
}
printf("排序结束\n");
}
/****************主程序********************/
int main(int argc, const char *argv[])
{
//定义一个一位数组并初始化
int arr[5] = {1,6,9,2,4};
printf("sizeof(arr) = %ld\n", sizeof(arr)); //20
//调用冒泡排序函数,完成升序排序
sort_up(arr, 5);
//输出排序后的结果
printf("排序后:");
for(int i=0; i<5; i++)
{
printf("%d\t", arr[i]);
}
printf("\n");
return 0;
}
运行结果:
递归函数
1.1递归的概念
所谓递归,就是一个函数直接或间接的形式调用自身,这样的函数调用,我们称为递归调用
示例:
#include<stdio.h>
//定义一个讲故事函数
void say_story()
{
printf("从前有座山,山里有个庙,庙里有个老和尚给小和尚讲故事,故事里说:");
say_story();
}
int main(int argc, const char *argv[])
{
//调用讲故事函数
say_story();
return 0;
}
运行结果:
1.2递归条件
1>递归出口:用于终止递归进行进行的条件
1.3递归思想
当直接解决规模比较大的问题不能进行时,需要先解决规模较小的原理一致的问题后,大的问题得以解决时,可以考虑使用递归 逐层分解,逐层合并
案例解析
1>求n!结果
分析:
代码:
//递归函数求阶乘
#include<stdio.h>
//定义一个递归函数
int jiecheng(int n)
{
if(n==0) //递归出口
{
return 1;
}
else
{
return n*jiecheng(n-1); //递归表达式
}
}
int main(int argc, const char *argv[])
{
int n=0;
scanf("%d",&n);
int sum = jiecheng(n); //求n!
printf("%d\n",sum);
return 0;
}
运行结果:
2>求斐波那契数列第n项的值
代码:
//斐波那契
#include<stdio.h>
int fbnq(int n)
{
if(n==1|| n==2)
{
return 1;
}
else
{
return fbnq(n-1)+fbnq(n-2);
}
}
int main(int argc, const char *argv[])
{
int n=0;
printf("请输入斐波那契数列的项数:");
scanf("%d",&n);
int sum = fbnq(n);
printf("斐波那契数列第%d项的值为%d\n",n,sum);
return 0;
}
运行结果:
3>使用递归函数实现,输入一个数,输出该数据的每一位
#include<stdio.h>
void print_num(int n)
{
if(n<10)
{
printf("%d\t",n);
}
else
{
//逆序输出
printf("%d\t",n%10); //按顺序输出 n/10
print_num(n/10); //按顺序输出 n%10
}
}
int main(int argc, const char *argv[])
{
int n=0;
scanf("%d",&n);
print_num(n);
printf("\n");
return 0;
}
运行结果:
指针概述
1.1指针相关概念
1>引入目的:能够从地址的角度,找到内存中的数据,而不是以变量的角度去找,效率较高
3>指针变量:由于指针这个地址编号很难记忆,我们引入指针变量存储指针
4>指针变量中,指针存储地址,作为一个特殊的数据类型,其大小是固定的 8 字节
1.2指针变量的定义
1>定义格式:数据类型 * 指针名;
1、使用一个相同数据类型的变量的地址为其进行初始化
int num = 520;
int * ptr = # //将num的地址赋值个指针变量 ptr //定义一个指针变量ptr,指向num 2、使用一个已经初始化了的指针变量给一个新的指针变量进行初始化
int * qtr = ptr; //此时表示两个指针变量同时存储了num的地址 int *qtr = #
3、使用地址的0 就是 NULL为其初始化
int *wtr = NULL;
4、注意:没有初始化的指针变量不能直接使用,因为该指针变量中存储了一个随机地址,如果对其进行更改,可能会导致系统瘫痪
5、野指针:指向非法内存的指针称为野指针
产生情况:
1)定义指针时,没有为其进行初始化
2) 指向了一个内存空间,但是随着程序的进行,该内存空间被回收了,那么该指针也是野指针(悬空指针)
3) 数组下标越界时,访问的地址也是野指针
3>指针变量的使用:使用运算符 ‘ * ’来取得指针变量中的值,我们也称该运算为 取值运算
1、指针变量在定义时,*号只是身份的象征,表示该语句定义的是指针变量
2、指针变量使用是,*号表示一个运算,取值运算,就是取得该指针变量指向的内存空间中的值
3、总结一下 * 号在C语言中的用途
1) 表示乘号,是一个双目运算符
2) 定义指针时,是身份的象征,表示定义的是指针变量
3) 使用指针时,是取值运算符,表示取得指针变量指向的内存空间中的值
4、总结一下 & 在C语言中的用途
1) 一个&表示双目运算符 按位 与运算
2) 两个&&表示双目运算符 逻辑 与运算
3) 一个&表示单目运算符 取址运算
5、&与*在指针的方面,互为逆运算
int num = 520;
int *ptr = #
1) *&num ==> *(&num) ==> *(ptr) ==> num
2) &*ptr ==> &(*ptr) ==> &(num) ==> ptr
3) *&ptr ==>*(&ptr) ==> *(ptr的二级地址) ==> ptr
4) &*num ==>报错
示例:
#include<stdio.h>
int main(int argc, const char *argv[])
{
int num = 520;
printf("num = %d\n", num); //num的值
printf("&num = %p\n", &num); //输出变量的地址
//定义指针变量指向num
int *ptr = # //该语句执行后:num <==> *ptr
printf("ptr = %p\n", ptr); //得到的是num的地址
//通过ptr获取num的值
printf("*ptr = %d\n", *ptr); //输出的是num的值
//解释解释什么叫等价
num = 1314;
printf("*ptr = %d\n", *ptr); //输出的是num的值
*ptr = 999;
printf("num = %d\n", num); //num的值
return 0;
}
运行结果:
4>指针的大小与指针的类型之间的关系
不同数据类型的指针所占内存空间都是一样的,都是指针的大小,32位系统下为4字节,64位系统下为 8字节
指针的数据类型存在的意义,不是为了给指针分配内存空间的,而是为了指针偏移使用的
不同类型的指针,在进行指针偏移时,偏移的大小跟指针的数据类型有关
指针每偏移一个单位,内存空间就会偏移一个数据类型大小的字节数
指针指向普通变量时,指针的偏移是没有意义的,但是,指针指向数组时,指针的偏移就有了现实的意义,表示指向上一个元素或者下一个元素的地址
示例:
#include<stdio.h>
int main(int argc, const char *argv[])
{
char value_1 = 'H'; //定义字符数据
short value_2 = 520; //定义短整形数据
int value_3 = 1314; //定义整形数据
double value_4 = 3.14; //定义双精度浮点型数据
//定义指针指向普通变量
char *ptr1 = &value_1;
short *ptr2 = &value_2;
int * ptr3 = &value_3;
double *ptr4 = &value_4;
printf("ptr1 = %p\n", ptr1);
printf("ptr2 = %p\n", ptr2);
printf("ptr3 = %p\n", ptr3);
printf("ptr4 = %p\n", ptr4);
printf("*************************************\n");
printf("ptr1+1 = %p\n", ptr1+1);
printf("ptr2+1 = %p\n", ptr2+1);
printf("ptr3+1 = %p\n", ptr3+1);
printf("ptr4+1 = %p\n", ptr4+1);
return 0;
}
运行结果:
5>指针可以使用的运算
关系运算: == 判断两个指针是否指向同一个内存地址,ptr==NULL,判空指针
指针指向普通变量作为函数参数
1>指针作为函数的参数进行数据传递时,不一定是地址传递
作业
#include<stdio.h>
// 定义阶乘函数,参数n为底数,k为指数
int cifang(int n,int k)
{
// 如果指数k为0或者底数n为0,返回1
if(k==0 || n==0)
{
return 1;
}
else // 如果不是0,执行递归调用
{
// 计算n的k次幂
return n*cifang(n,k-1);
}
}
int main(int argc, const char *argv[])
{
// 定义两个整数变量n和k,用于存储用户输入的底数和指数
int n=0,k=0;
// 提示用户输入两个数
printf("请输入两个数:");
scanf("%d%d",&n,&k);
int s=cifang(n,k); // 调用cifang函数计算n的k次幂,结果存储在变量s中
printf("%d ^ %d= %d\n",n,k,s);
return 0;
}
运行结果:
#include <stdio.h>
// 定义计算字符串长度函数
int strlen_1( char *str) {
// 如果到达字符串末尾('\0'),返回0
if (*str == '\0') {
return 0;
}
else
{
// 否则,返回当前字符的1加上剩余字符串的长度
return 1 + strlen_1(str + 1);
}
}
int main(int argc, const char *argv[])
{
char str[100]=""; // 定义一个字符数组,用于存储输入的字符串
printf("请输入一个字符串:");
scanf("%s", str);
// 调用递归函数计算字符串长度,并打印结果
int len = strlen_1(str);
printf("字符串的长度是: %d\n", len);
return 0;
}
运行结果:
#include <stdio.h>
// 定义hannuota函数,用于解决汉诺塔问题
int hannuota(int n)
{
//当只有一个盘子时,直接移动到目标
if(n==1)
{
return 1;
}else
{
//2层汉诺塔=1层*2+1,n层=n-1层的*2+1
return (hannuota(n-1)*2+1);
}
}
int main(int argc, char const *argv[])
{
int n=0;
printf("请输入汉诺塔盘子的个数:");
scanf("%d",&n);
printf("需要%d次\n",hannuota(n));
return 0;
}
运行结果:
#include <stdio.h>
#include <string.h>
// 定义paixu函数,使用冒泡排序对字符串进行从大到小排序
void paixu(char *str) {
int len = strlen(str); // 获取字符串长度
int i, j;
char temp; // 用于交换字符的临时变量
// 外层循环控制比较的轮数
for (i = 1; i < len; i++) {
// 内层循环进行相邻字符的比较和交换
for (j = 0; j < len - i; j++) {
// 如果当前字符小于下一个字符,则交换它们
if (str[j] < str[j + 1]) {
//交换三部曲
temp = str[j];
str[j] = str[j + 1];
str[j + 1] = temp;
}
}
}
}
int main(int argc, const char *argv[])
{
// 定义一个字符数组,用于存储输入的字符串
char str[100]="";
printf("请输入一个字符串:");
scanf("%s", str);
// 调用paixu函数对字符串进行从大到小排序
paixu(str);
printf("排序后的字符串: %s\n", str);
return 0;
}
运行结果:
5>实现一个函数,用于检查一个字符串是否是回文字符串(正序和反序都相同)
#include <stdio.h>
#include <string.h>
// 定义huiwen函数,检查传入的字符串是否是回文
int huiwen(char *str) {
int left = 0; // 初始化左指针
int right = strlen(str) - 1; // 初始化右指针
// 循环比较左右两端的字符,直到它们相遇或交错
while (left < right) {
// 如果左右两端的字符不相等,则不是回文
if (str[left] != str[right]) {
return 0; // 返回0,表示不是回文
}
left++; // 移动左指针向右
right--; // 移动右指针向左
}
return 1; // 如果所有对应的字符都相等,则返回1,表示是回文
}
int main(int argc, const char *argv[])
{
// 定义一个字符数组,用于存储输入的字符串
char str[100]="";
printf("请输入一个字符串:");
scanf("%s", str);
// 调用huiwen函数检查字符串是否是回文
if (huiwen(str)) {
printf("'%s' 是回文字符串\n", str);
} else {
printf("'%s' 不是回文字符串\n", str);
}
return 0;
}
运行结果:
6>使用指针完成判断自己的主机存储多字节整数时,是大端存储还是小端存储
#include <stdio.h>
int main(int argc, const char *argv[])
{
int a = 0x12345678; //定义变量存储多字节整数
char *p = (char *)&a;
if(*p == 0x12)
{
printf("主机是大端存储\n");
}
else
{
printf("主机是小端存储\n");
}
return 0;
}
运行结果:
代码有问题(中间的标点符号后面需要加空格)
#include <stdio.h>
#include <string.h>
// 定义countWords函数,使用指针遍历字符串并统计单词数
int countWords(char *str)
{
// 单词计数器初始化为0
int count = 0;
char *word = str; // word指针用于定位单词的开始
while (*str != '\0') {
// 检查空格
while (*str==32) {
str++;
}
// 检查是否到达字符串末尾或遇到空格,以确定单词的边界
if (*str != '\0' && *str!=32 ) {
// 找到单词的开始
word = str;
// 移动指针到单词的末尾
while (*str != '\0' && *str!=32) {
str++;
}
// 单词结束,计数加1
count++;
}
}
return count; // 返回单词计数
}
int main(int argc, const char *argv[])
{
// 定义一个字符数组,用于存储输入的文本
char text[1000]="";
printf("请输入一段文本:");
gets(text, sizeof(text));
// 调用countWords函数统计单词数
int wordCount = countWords(text);
printf("文本中的单词数为: %d\n", wordCount); // 打印单词数
return 0;
}
运行结果: