给初学者的c语言

cuitlse

于 2024-07-24 19:41:11 发布

阅读量742

点赞数 17

文章标签： c语言

本文链接：https://blog.csdn.net/cuitlse/article/details/140671663

版权

C程序的基本框架
#include<stdio.h>
int main()
{
//执行的代码
return 0;
}
gcc demo.c -o demo //把a,exe 改成demo

echo %errorlevel% 错误等级

数据表现形式
变量
四要素变量值类型变量名存储单元

int 4个字节,float 4 int float 编码格式不一样不能直接用不同的占位符直接输出
float
double
char
char*

驼峰命名法

int OneYear = 20;
void One_Year ()
{
//功能模块函数写的东西
}
printf() 输出有原样输出 %占位符/格式字符printf("%d",a)
printf("小黑子你好"); //原样输出
printf("%d",a); //%占位符输出
printf() 小练习加减乘除

输入 scanf()
scanf()//z最好多个变量多个scanf()
原样输入，要输入相应的内容

scanf("%d",&data); // 不要在scanf里面+空格和其他的符号 &取地址符号
scanf("%d%d%%d"&a,&b,&c); //正确方式
scanf("a=%d,b=%d,c=%d",&a,&b,&c);//这个要将括号里面的输入完全（错误方式）
1:scanf()函数混合输入
以上方法容易出错

其他输入输出方式
getchar();
putchar();
puts();
gets();

练习题
练习题1
输入大写字母输出小写字母

练习题2
输入两个数获得两个数的加减乘除的值

练习题3
输入字符串将输入的字符串加密（在原来的基础之上往后移动四位）

总结
#include<stdio.h>
int main()
{
//原样输出
printf("jjjjj");
// %占位符输出
int a;
printf("%d",a); // %d %c %f %n.mf %-n.mf %p %x
//输入 scanf();
int b;
scanf("%d",b); //scanf()最好一个i一个i用，
//原样输入
printf("%d",b);
//其他输入\输出方法
putchar(); 输出一个字符
puts(); 输出字符串
getchar(); 获得字符（你要输入的字符串）
gets(); 获取字符串



return 0;
}
#include<stdio.h>
int main()
{
int data;
char c = 'c';
char* f = "jdio";
float ff ;

printf("原样输出\n");
printf("占位符输出%d",data);
scanf("%d",&data);
putchar('');
getchar();
puts();
gets();
/*puts(); 与printf();的区别
puts(); 只能输出字符串，自动换行
printf(); 支持多样输出。不自动换行;

*/
}
换大小写字母

#include<stdio.h>
int main()
{
char a ;
char b;
printf("请输入字母\n");
scanf("%c",&a);
b=a+32;
printf("%c",a+32);
return 0;
}
2流程控制
1,控制语句
#include<stdio.h>
int main()
{
if(){
else if()
{

}
}else{

}
for(;;)
{

}
switch()
   case:


return 0;
}
2 交换两个数字
3级交换数字
交换数字的时候要注意，要三次交换，先a<b a<c b<c

3逻辑运算
#或与非
逻辑运算if() 小练习逻辑判断或与非
if() else() 小练习
if 嵌套语句运用
#include<stdio.h>
/*
嵌套用法
*/
int main()
{
   int data1;
   int data2;
   int data3;
   printf("相亲角\n");
   puts("身体好么好1，不好0");
   scanf("%d",&data1);
   if(data1 ==1)
   {
       printf("可以考虑交友\n");
       puts("性格好么好1 不好0");
       scanf("%d",&data2);
       if(data2 == 1)
       {
           printf("身体又好又温柔,真好\n");
           puts("你有钱么");
           scanf("%d",&data2);
           if(data2 == 1)
           {
               printf("真名天子\n");
           }else{
               puts("身体很好，性格倒是不错，不过实力便是弱了些，再见");
           }

       }else{
           puts("性格不合适");
       }

   }else{
       printf("再见\n");
   }
   puts("相亲结束");

   return 0;
}
switch case 用法
错误
a3.6_switch_case.c: In function 'main':
a3.6_switch_case.c:28:2: error: too few arguments to function 'gets'
gets();
^~~~
In file included from a3.6_switch_case.c:1:
C:/MinGW64/x86_64-w64-mingw32/include/stdio.h:658:17: note: declared here
char *__cdecl gets(char *_Buffer) __MINGW_ATTRIB_DEPRECATED_SEC_WARN;

解决方法

根据提供的错误信息，可以看出在你的代码文件 “a3.6_switch_case.c” 的第28行中，调用了函数 ‘gets’，但是没有传入任何参数。然而，根据C语言的标准库函数，‘gets’ 函数需要至少一个参数来接收输入的字符串。

需要修复这个问题，你可以在调用 ‘gets’ 函数时传入一个字符数组作为参数，用于接收输入的字符串。例如：

char input[100];
gets(input);
此外，需要注意的是，‘gets’ 函数在很多编译器中已经被标记为不安全和不推荐使用的函数，因为它容易导致缓冲区溢出的安全漏洞。建议使用更安全的函数替代，如 ‘fgets’ 函数。使用 ‘fgets’ 函数的示例代码如下：

char input[100];
fgets(input, sizeof(input), stdin);
使用 ‘fgets’ 函数时，需要指定接收输入的字符数组的大小，并传入 ‘stdin’ 作为最后一个参数，表示从标准输入中读取输入。

希望这些信息对你有所帮助！如果有任何其他问题，请随时提问。
正确代码

#include<stdio.h>
int main()
{
   int data;
   char cdata;
   puts("please input the number");
   scanf("%d",&data);
   switch(data)
   {
       case 1:
       puts("1");
       break;//执行之后，跳出switch
       case 2:
       puts("2");
       break;
       case 3:
       puts("3");
       break;
       case 4:
       puts("4");
       break;
       default :
       puts("other");
       break;
   }
   getchar();
   puts("please input string");
   getchar(); // 吸收回车按键
   //gets(); //gets 不建议使用可以用 fgets();
   scanf("%c",&cdata);
   switch(cdata){
       case 'a':
       puts("ikun");
       break;
       case 'b':
       puts("小黑");
       break;
       default :
       puts("炒粉");
       break;
   }

   return 0;
}
switch 学生成绩
#include<stdio.h>
int main()
{
   int score;
   puts("请输入成绩");
   scanf("%d",&score);
   switch(score/10){
       case 0:;
       puts("比蔡徐坤还蔡徐坤");
       break;
       case 1:
       puts("你是真正的蔡徐坤");
       break;
       case 2:
       puts("进步空间巨大");
       break;
       case 3:
       puts("进步空间大");
       break;
       case 4:

       case 5:
       puts("59半步斗之气");
       break;
       case 6:
       puts("60及格");
       break;
       case 7:
       puts("70中等");
       break;
       case 8:
       puts("80良好");
       break;
       case 9:
       puts("90优秀");
       break;
       case 10:
       puts("100顶尖");
       break;
       default:
       puts("异常");
       break;

   }
   return 0;
}
调试结果

计算折扣两种方法
if
#include<stdio.h>
int main()
{
   float money;
   int luCheng;
   puts("您的路程为");
   scanf("%d",&luCheng);
   if(luCheng>=0 && luCheng<=100)
   {
       money =2;
       printf("您行驶距离为%d\n您骑行的费用为%4.2f",luCheng,money);
   }else if(luCheng>100 && luCheng<=500)
   {
       money = 2+(float)luCheng*0.008;
       printf("您行驶的距离为%d\n您骑行的费用为%4.2f",luCheng,money);
   }
   else if(luCheng>500 && luCheng<=1000)
   {
       money = 2+(float)luCheng*0.006;
       printf("您行驶的距离为%d\n您骑行的费用为%4.2f",luCheng,money);
   }
   else
   {
       money = 2+(float)luCheng*0.004;
       printf("您行驶的距离为%d\n您骑行的费用为%4.2f",luCheng,money);
   }

   return 0;
}
switch case
#include<stdio.h>
int main()
{
   float money;
   int luCheng;
   puts("please input lucheng number");
   scanf("%d",&luCheng);
   switch(luCheng)
   {
       case 0 ~ 100:
           money = 2.00;
           printf("您行驶的距离为%d\n您骑行的费用为%4.4f",luCheng,money);
           break;
       case 101~ 500:
           money = 2.00+luCheng*0.008;
           printf("您行驶的距离为%d\n您骑行的费用为%4.2f",luCheng,money);
           break;
       case 501~ 1000:
           money = 2.00+luCheng*0.006;
           printf("您行驶的距离为%d\n您骑行的费用为%4.2f",luCheng,money);
           break;
       case 999~ 5000:
           money = 2.0+luCheng*0.005;
           printf("您行驶的距离为%d\n您骑行的费用为%4.2f",luCheng,money);
           break;
       case 5001~10000   :
           money = 2.0+luCheng*0.004;
           printf("您行驶的距离为%d\n您骑行的费用为%4.2f",luCheng,money);
           break;
       default:
           money = 2.0+luCheng*0.3;
           printf("您行驶的距离为%d\n您骑行的费用为%4.2f",luCheng,money);

           break;
   }
   return 0;
}
#include<stdio.h>
int main()
{
   float money;
   int luCheng;
   puts("please input lucheng number");
   scanf("%d",&luCheng);
   switch(luCheng)
   {
       case 100:
           money = 2.00;
           printf("您行驶的距离为%d\n您骑行的费用为%4.4f",luCheng,money);
           break;
       case 500:
           money = 2.00+luCheng*0.008;
           printf("您行驶的距离为%d\n您骑行的费用为%4.2f",luCheng,money);
           break;
       case 1000:
           money = 2.00+luCheng*0.006;
           printf("您行驶的距离为%d\n您骑行的费用为%4.2f",luCheng,money);
           break;
       case 5000:
           money = 2.0+luCheng*0.005;
           printf("您行驶的距离为%d\n您骑行的费用为%4.2f",luCheng,money);
           break;
       case 10000:
           money = 2.0+luCheng*0.004;
           printf("您行驶的距离为%d\n您骑行的费用为%4.2f",luCheng,money);
           break;
       default:
           //money = 2.0+luCheng*0.3;
           printf("您行驶的距离为");/*%d\n您骑行的费用为%4.2f",luCheng,money)*/

           break;
   }
   return 0;
}
作业
计算分段函数
#include<stdio.h>

int main()
{
   int y;
   int x;
   puts("请输入一个数");
   scanf("%d",&x);
   if(x<1)
   {
       y=x;
       printf("y的值为%d",y);
   }else if(x>=1&&x<10)
   {
       y=2*x-1;
       printf("y的值为%d=2*%d-1",y,x);
   }else if(x>=10)
   {
       y=3*x-11;
       printf("y的值为%d=3*%d-11\n",y,x);
   }

   return 0;
}
运行结果

个人成绩等级划分
#include<stdio.h>
int main()
{
   int score;
   puts("please input score");
   scanf("%d",&score);
   switch(score/10)
   {
       case 1:
       case 2:
       case 3:
       case 4:
       case 5:
           printf("E不鸡格\n");
           break;
       case 6:
           printf("D鸡哥\n");
           break;
       case 7:
           printf("C中等\n");
           break;
       case 8:
           printf("B良好\n");
           break;
       case 9:
           printf("A优秀\n");
           break;
       case 10:
           printf("S顶级\n");
           break;
       default:
           printf("异常\n");
       break;

   }

   return 0;
}
4 循环运算 for while do while
while
#include<stdio.h>
void jj()
{
   int time;
   int a;
   while(a){

       a=time--;
       puts("徐坤");
   }
}
int main()
{
   int time;
   unsigned int a;
   time=2;


   while(a)
   {
       a=time--;
       puts("小黑");
   }
   return 0;
}
t--和--t的区别
t--（后置自减）先用 t 后减

--t （前置自减）t 先减后用

int t = 5;
int result1 = t--; // result1 的值为 5，然后 t 的值变为 4
int t = 5;
int result2 = --t; // result2 的值先减为 4 ,然后 t 为4
for
九九乘法表
#include<stdio.h>
//乘法表
int main()
{
   int a;
   int b;
   int c;
   for(a=1;a<10;a++)
   {
       for(b=1;b<a;b++)
       {
           c=a*b;
           printf("%d = %d*%d\n",c,a,b);
       }
printf("\n");

   }
   printf("结束\n");
   return 0;
}
break continue 的区别
for(renshu = 1; renshu <=1000; renshu++)
   {
       puts("请输入捐款数目:");
       scanf("%d",&data);

       ZongMoney = data+ZongMoney;
       if(ZongMoney >= 100000)
       {
           puts("款项已经达到标准");
           printf("钱总共有%d",ZongMoney);
           break; //结束整个循环
       }
   }
for(data =100;data<=200;data++)
   {
       if(data%3 ==0)//被3整除的数
       {
           continue; //中断一个循环
       }
       printf("%d\n",data);
   }
求取最小公倍数
#include<stdio.h>
//取最小公倍数先比较两个数的大小，最小公倍数一定>=最大的数,
//然后依次取模
int main()
{
   int data1;
   int data2;
   data1 =0;
   data2 = 0;
   int m;
   puts("请输入两个数");
   scanf("%d%d",&data1,&data2);
   m = data1 < data2?data1:data2;

   for(m;;m++)
   {
       if(m%data1==0 && m%data2==0)//
       {
           break;//中断整个循环
       }
   }
   printf("%d",m);

   return 0;
}
求取最大公约数
#include<stdio.h>
int main()
{
   int data1;
   int data2;
   puts("please input tow number ");
   scanf("%d%d",&data1,&data2);
   int i;
   int m;
   int n;
   for(i=1;i<=data1 && i<=data2;i++)
   {
       if(data1%i ==0&& data2%i ==0)
       {
           m=i;
           //break;
       }
   }
   n = data1*data2/m; //最小公倍数 == data1*data2 /最大公约数

   printf("最大公约数是%d\n最小公倍数是%d",m,n);
   return 0;
}
水仙花数
#include<stdio.h>
//求取水仙花数 ==一个3位数各位数字立方之和
// 153 ==1^3+5^3+3^3
int main()
{
   int i;
   int a;
   int b;
   int c;
   for(i=100;i<=999;i++)
   {
       c = i%10;
       b = (i/10)%10;
       a = i/100;
       if(i == a*a*a+b*b*b+c*c*c){
       printf(" %d ",i);
       }
   }

   return 0;
}
5,总结
#1 if语句
基本用法

if()//判断条件
{

//执行的模块
}else
{

}
连续判断

if()
{

}else if()
{

}else if()
{

}
嵌套用法

if()
{
if()
{
if()
{

}else{

}
}else{

}

}else{

}
switch case 用法
switch ()
{
case 1:
//执行的模块
break;
case 2:
break;
case 3:
break;
default :
break;
}
switch case 一般用于需要多种判断条件的时候

循环三剑客
fou
//基本用法
for(int i = 0;i<100;i++)
{
puts("jjjj");
}
//嵌套用法
int k;
for(int i;i<9;i++)
{
for(int j;j<i;j++)
{
k = i*j;
printf("%d=%d*%d",k,j,i);

}
printf("\n");
}
九九乘法表
#include<stdio.h>
//乘法表
int main()
{
   int a;
   int b;
   int c;
   for(a=1;a<10;a++)
   {
       for(b=1;b<=a;b++)
       {
           c=a*b;
           printf(" %d=%d*%d ",c,a,b);
       }
       printf("\n");

   }
   printf("结束\n");
   return 0;
}
while
//while 基本用法
while(time <100) //范围
{
puts("积极");//循环体
time--; //循环体
}
do while
do{

}while()
//日后再说，先循环，后判断条件
作业
求取最大公约数
#include<stdio.h>
int main()
{
   int data1;
   int data2;
   puts("please input tow number ");
   scanf("%d%d",&data1,&data2);
   int i;
   int m;
   int n;
   for(i=1;i<=data1 && i<=data2;i++)
   {
       if(data1%i ==0&& data2%i ==0)
       {
           m=i;
           //break;
       }
   }
   n = data1*data2/m; //最小公倍数 == data1*data2 /最大公约数

   printf("最大公约数是%d\n最小公倍数是%d",m,n);
   return 0;
}
最小公倍数
水仙花数
三位数 = 个个位数三次方之和
3数组
1，定义一个数组
int a[10];
// 类型符数组名常量表达式
2，初始化数组
int a[10]={1,2,3,4,5,6,7,8,9,10};//全部赋值
   int b[10]={1,2,3,4};//部分赋值
   int c[10]={0}; //全部为零
    int d[]={1,3,3,4,4,};//会根据大括号判断有多少个数
sizeof()
   sizeof()//关键字计算括号中对应数据的内存空间的大小
   size_a = sizeof(a)/sizeof(a[0]);//计算个数
   size_c = sizeof(c)/sizeof(c[0]);
   size_b = sizeof(b)/sizeof(b[0]);
3，数组编程案列
数组初始化级逆序输出
#include<stdio.h>
int main()
{
   int a[10];
   int data;
   int size;
   int sizea;
   int sizeb;
   sizea = sizeof(a);
   sizeb = sizeof(a[0]);
   size = sizeof(a)/sizeof(a[0]);
   for(data = 0;data<size;data++){
       a[data] = data;
   }
   puts("初始化");
   for(data = 0;data<size;data++)
   {
       printf("地址%p 数据%d\n",&a[data],a[data]);
   }
   puts("逆序输出");
   for(data = size;data>=0;data--)
   {
       a[data] = data;
   }
   for(data = size ;data>=0;data--)
   {
       printf("%p %d\n",&a[data],a[data]);
   }
   printf("dome\n");
   printf("%d\n",sizea);
   printf("%d",sizeb);

   return 0;
}
斐波那契数列输出
#include<stdio.h>
// a[i] = a[i-1]+a[i-2]
int main()
{
   unsigned int arr[10];
   int i;
   int size;
   arr[0]=0;
   arr[1]=1;
   size = sizeof(arr)/sizeof(arr[0]);
   for(i=2;i<size;i++)
   {

       arr[i]=arr[i-1]+arr[i-2];
   }
   for(i=0;i<size;i++)
   {
       printf(" %d ",arr[i]);
   }
   printf("dome");

   return 0;
}
冒泡排序法
#include<stdio.h>
int main()
{

   int arr[]={12,34,5,5,5,666,53,343,4343,4332,53,432,534,2,5432};
   int i;
   int j;
   int len;
   int temp;

   len = sizeof(arr)/sizeof(arr[0]);
   for(i=0;i<len-1;i++)
   {
       for(j=0;j<len-i-1;j++)
       {
           if(arr[j]<arr[j+1])
           {
               temp = arr[i];
               arr[i] =arr[i+1];
               arr[i+1] = temp;

           }

       }

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

   return 0;
}
0   1   2   3
0   1 2 3 4   2 1 3 4   2 3 1 4   2 3 4 1 1
1   2 3 4   3 2 4   3 4 2   2
2   3 4   4 3   3   3
2   4           4
i=len−1;j=len−1−i;
�
=
�
�
�
−
1
;
�
=
�
�
�
−
1
−
�
;
简单选择排序法
#include<stdio.h>
int main()
{
   int i;
   int j;
   int temp;
   int arr[]={1,2,5,6,66,5,55,6,22,6,22,55};
   int len;
   len = sizeof(arr)/sizeof(arr[0]);
   for(i=0;i<len-1;i++)
   {
       for(j=i+1;j<len;j++)
       {
           if(arr[i]<arr[j])
           {
               temp = arr[i];
               arr[i] = arr[j];
               arr[j] = temp;
           }

       }

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

   }
   printf("\ndome");
   return 0;
}
i<len−1j<leni表示比对的轮数j就是i后一位数
�
<
�
�
�
−
1
�
<
�
�
�
�
表
示
比
对
的
轮
数
�
就
是
�
后
一
位
数
4，二维数组
#include<stdio.h>
int main()
{
   //定义一个二维数组
   int arr[2][3]={{11,33,44},{33,55,66}};
   int arr1[3][3]={1,2,3,4,5,6,7,8,9};
   int i,j;
   //遍历二维数组
   for(i=0;i<2;i++)
   {
       for(j=0;j<3;j++)
       {
           printf("%d ",arr[i][j]);
       }
       printf("\n");
   }
   return 0;
}
二维数组初始化
// 二维数组行可以省掉，但是列不能省
#include<stdio.h>
//3x4数组，求其最大的元素并输出，行和列
int main()
{
   int i;
   int j;
   int max;

   int arr[3][4]={1,3,22,34,54,54,32,3,7,66,5,234};
   max = arr[0][0];

   for(i=0;i<3;i++)
   {
       for(j=0;j<4;j++)
       {

           if(max<arr[i][j])
           {
               max = arr[i][j];
           }
           printf("%d ",arr[i][j]);

       }
       printf("\n");

   }
   printf("%d %d %d",max,i,j);

   return 0;
}
4函数
函数作用
避免代码冗长

可以实现模块化设计

可以按功能进行划分

函数要先定义后使用跟变量是一样的

函数的定义
三要素
函数名（体现功能）

参数

返回值

无参数类型函数
站空位

案例
#include<stdio.h>
// 输入3个数输出相应水仙花数形式参数和实际参数名类型值相同，地址不相同

// 生命周期：被调用的时候才为形式参数申请内存空间，调用完后又被内存释放了；
int add(int data1, int data2,int data3) //形式参数
{
   int ret;
   ret = data1*data1*data1+data2*data2*data2+data3*data3*data3;

   return ret;

}

int main()
{
   int a;
   int b;
   int c;
   int ret;
   puts("请输入三个数");
   scanf("%d%d%d",&a,&b,&c);//实际参数
   ret = add(a,b,c);
   printf("%d ",ret);

   return 0;
}
#include<stdio.h>

int max(int x,int y)
{
   int ret;
   if(x<y)
   {
       ret = y;

   }else if(x>y)
   {
       ret = x;
   }else if(x=y)
   {
       ret = x =y;
   }
   //ret =a<b?a:b;//三目运算符
   return ret;

}

int main()
{
   int x;
   int y;
   puts("请输入两个数");
   scanf("%d%d",&x,&y);
   max(x,y);
   printf("最大数位%d ",max(x,y));

}
函数的嵌套
案例
#include<stdio.h>
// 四个数比较大小用函数实现
int max(int a,int b)
{
   int ret;
   ret = a>b?a:b;
   return ret;

}
int bigdata(int a, int b, int c, int d)
{
   int data;
   data = max(a,b);
   data = max(data,c);
   data = max(data,d);
   return data;
}

int main()
{
   int a;
   int b;
   int c;
   int d;
   int big;

   puts("please Input nums:");
   scanf("%d%d%d%d",&a,&b,&c,&d);
   big = bigdata(a,b,c,d);
   printf("最大数为%d",big);

   return 0;
}
这里用到了函数的嵌套法则，函数嵌套就是，当我们调用一个函数时，在这个函数又调用了其他的函数。

函数的递归
函数递归就是在函数嵌套的过程中把自己也嵌套进去了，这种情况容易出现死循环，递归不经常使用

#include<stdio.h>
//用递归的方式看年龄
int getAge(int num)
{
   int ret;
   if(num ==1)
   {
       ret =10;
   }else{
       ret = getAge(num-1)+2;
       //现在年龄就是上一个人的年龄+2 num-1就是上一个
   }
   return ret;

}

int main()
{
   int num;
   int age;
   int agge;
   puts("please Input You need num age :");
   scanf("%d",&num);
   agge = getAge(num);

   printf("%d的年龄是%d",num,agge);



   return 0;
}
以上是递归按照规律查找同学年龄的方式，

用递归求阶乘
#include<stdio.h>
#include<stdlib.h>
//递归求阶层
int getjiecheng(int a)
{
   int ret;
   if(a>=17)
   {
       printf("越界");
       exit(-1); //直接退出程序调用stdlib.h 库文件
   }
   if(a == 1)
   {
       ret = 1;

   }else{
       ret = getjiecheng(a-1)*a;
   }

   return ret;
}

int main()
{
   int a;
   int jiecheng;
   puts("please Input You Need Numm");
   scanf("%d",&a);
   jiecheng = getjiecheng(a);
   printf("%d的阶乘是%d",a,jiecheng);

   return 0;
}
用递归的方式求取阶乘。

阶乘a!=(a−1)∗a∗‘‘‘‘‘‘‘‘‘∗(a−n);;;;a!=(a−1)!∗a
阶
乘
�
!
=
(
�
−
1
)
∗
�
∗
‘
‘
‘
‘
‘
‘
‘
‘
‘
∗
(
�
−
�
)
;
;
;
;
�
!
=
(
�
−
1
)
!
∗
�
数组作为函数的参数
数组形参
根据您提供的代码和错误信息，出现了函数调用参数数量不匹配的错误。根据错误信息看，您在函数调用printArr()中没有传递足够的参数，但是函数printArr()在函数定义处声明了两个参数（int arr[]和int len）。

为了解决这个错误，您需要在函数调用printArr()中传递正确的参数数量，以匹配函数定义处的参数。根据函数定义处的声明，您需要传递一个int类型的数组和一个int类型的长度参数。

#include <stdio.h>

void printArr(int arr[], int len) {
int i;
for (i = 0; i < len; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}

int main() {
int arr[] = {1, 2, 3, 4, 5};
int len = sizeof(arr) / sizeof(arr[0]);

prin
arr 使用 sizeof 运算符的错误。警告信息指出 sizeof(arr) 返回的是指针类型 int * 的大小，而不是数组的大小。

在C语言中，当我们将数组传递给函数时，数组参数实际上是以指针的形式传递的，因此在函数内部无法通过 sizeof 运算符获取数组的大小。

#include<stdio.h>
//数组传参，形式参数的些许小问题。
// 传送过来的只是一个地址一个数组的首地址，数组首元素的地址
//形参中没有数组这个概念，即使标注数组的大小，也是无效的
//指针变量占 8个字节
void printArr(int arr[],int len)
{
   int i;
   printf("大小%d \n",len);
   for(i=0;i<len;i++)
   {
       printf("%d ",arr[i]);

   }
}

int main()
{
   int len;

   int arr[] = {1,2,3,4,5,6,7};
   len = sizeof(arr)/sizeof(arr[0]);


   printf("arr 的大小是%d\n",sizeof(arr));
   printf("arr 元素有%d个\n",len);
   printf("arr 单个元素大小是%d\n",sizeof(arr[0]));
   printArr(arr,len);//数组名代表数组首地址
   printf(&arr[0],len); //第一个元素的地址也是数组首地址
   return 0;
}
数组实参
变量名当作函数的实际参数
#include<stdio.h>
void dataa(int data)
{
   data = data +1000;
   printf("address %p, data %d",&data,data);
}

int main()
{
   int data;
   data=10;
   printf("address %p %d \n",data);
   dataa(data);
   return 0;
}
当变量为函数的实际参数的时候只是将函数中变量的值进行传递，而地址并没有传递

这两个数据的地址是不相同的

数组名当作函数实际参数
当数组名作为函数的实际参数的时候，不仅能够进行函数间的数值传递，而且能够将地址进行传递

#include<stdio.h>
int dataa(int arr[])
{
   arr[0]=arr[0]+100;
   printf("address %p ,data %d",&arr[0],arr[0]);

}
int main()
{
   int arr[] = {1,33,4,23,35};

   dataa(arr);
   printf("\naddress %p ,data %d",&arr[0],arr[0]);

   return 0;
}
地址是一样的

数组实战之计算不同班级平均分
在C语言中，当我们在函数调用中传递数组参数时，我们只需要传递数组名，而不需要使用[]符号。

为了解决这个问题，您需要在调用函数initArr()时，将数组名arr1作为参数传递，而不需要使用[]。

#include<stdio.h>
//计算两个班级的平均分 5 10
void initArr(int arr[],int len)
{
   int i;

   for(i=0;i<len;i++)
   {
       printf("请输入第%d个同学的成绩\n",i+1);
       scanf("%d",&arr[i]);
   }
   puts("dome\n");

}
void printArr(int arr[],int len)
{
   int i;
   printf("总人数是%d\n",len);
   for(i=0;i<len;i++)
   {
       printf("第%d同学成绩是%d\n",i+1,arr[i]);

   }
   puts("\ndome");
}
float getpinjunfen(int arr[],int len)
{
   int i;
   float pingjunfen;
   int sum;
   for(i=0;i<len;i++)
   {
       sum = sum+arr[i];
   }
   pingjunfen = (float)sum/len;
   return pingjunfen;

}

int main()
{
   int arr1[5];
   int arr2[10];
   float aa;
   float bb;
   int len1 = sizeof(arr1)/sizeof(arr1[0]);
   int len2 = sizeof(arr2)/sizeof(arr2[0]);


   initArr(arr1,len1);
   initArr(arr2,len2);

   printArr(arr1,len1);
   printArr(arr2,len2);

   aa = getpinjunfen(arr1,len1);
   bb = getpinjunfen(arr2,len2);
   printf("1平均分为%2.2f\n2平均分为%2.2f",aa,bb);
   printf("\n dome \n");




}
二维数组和函数的概念与实战
二维数组命名规范
int arr[][]; //错误的
int arr[][2] ={1，2，3，4，5，2，2，3，3，1，}; // 正确
int arr[2][3]// 正确
//二维数组命名除了第一个维度不需要规定边界第二维度，第n维度斗需要规定边界
// 注意两个点二维数组的类型；二维数组有多少个一维数组
二维数练习题
有3x4的矩阵，初始化并输出，然后求最大值并输出
#include<stdio.h>
// 输出4X5矩阵求最大值
void initArr();

void printArr();
int getMax();

int main()
{
   int arr[4][5];
   int max;
   int hang = 4;
   int lie = 5;


   initArr(arr,hang,lie);
   printArr(arr,hang,lie);
   max = getMax(arr,hang,lie);
   printf("最大值为%d",max);

   return 0;
}

//数组初始化
void initArr(int arr[][5],int hang,int lie)
{
   int i;
   int j;
   for(i=0;i<hang;i++)
   {
       for(j=0;j<lie;j++)
       {
           printf("第%d行，第%d列",i+1,j+1);
           scanf("%d",&arr[i][j]);
           getchar();

       }

   }
   printf("初始化完成\n");

}
//打印二维数组各个元素
void printArr(int arr[][5],int hang,int lie )
{
   int i;
   int j;
//遍历数组
   for(i=0;i<hang;i++)
   {
       for(j=0;j<lie;j++) //当把j换成i的时候，会越界
       {
           printf("%d ",arr[i][j]);
       }
       printf("\n");
   }

}
//获取最大值
int getMax(int arr[][5],int hang,int lie)
{
   int i;
   int j;
   int max;
   for(i=0;i<hang;i++)
   {
       for(j=0;j<lie;j++)
       {
           if(max<arr[i][j])
           {
               max =arr[i][j];
           }
       }
   }
   return max;
}

全局变量，外部变量，局部变量区别
#include<stdio.h>
int a = 10;
int b = 12;// 全局变量
void fun1()
{
   printf("%d\n",a);
   printf("%d\n",b);
}
int c = 1;
int d = 2; //外部变量
void fun2()
{
   printf("%d\n",c);
   printf("%d\n",c);
}

int main()
{
   int aaa =11;
   int bbb= 111; //局部变量
   fun1();
   fun2();
   printf("%d\n",a);
   printf("%d\n",b);
   return 0;
}
程序是按照自上而下的顺序进行编译的

全局变量是指变量不在函数中并且在最上面，外部变量上面有其他的函数，而且又不在函数内局部变量在函数中的变量
全
局
变
量
是
指
变
量
不
在
函
数
中
并
且
在
最
上
面
，
外
部
变
量
上
面
有
其
他
的
函
数
，
而
且
又
不
在
函
数
内
局
部
变
量
在
函
数
中
的
变
量
全局变量实战
#include<stdio.h>
//计算一个班级学生的平均分

int max;
int min;
float getAver(int arr[],int len)
{
   int i;
   int sum =0 ;

   max = min = arr[0];//确定取值范围初始化

   for(i=0;i<len;i++)
   {
       printf(" %d ",arr[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 arr[] = {22,33,3};
   int len;
   len = sizeof(arr)/sizeof(arr[0]);
   float aver;
   aver = getAver(arr,len);

   printf("最高分%d\n最低分%d\n平均分%2.2f\n",max,min,aver);
   //printf(); 有优先级先执行函数，后执行变量

   return 0;
}
作业
在C语言中，当我们声明函数的参数时，不需要使用分号(;)来表示前向声明。

void init(int a; int b) //这里的;改为，
{

}
void initt(int a,int b)
{

}
#include <stdio.h>

void initArr(int arr[], int len) {
// 在这里初始化数组
}

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

initArr(arr, len);

// 在这里使用数组

return 0;
}
1，作业代码
#include<stdio.h>
/*
   作业：输入十个数
   求最大值，及下标
*/
void initArr(int arr[],int len)
{
   int i;
   printf("请输入10个数据\n");
   for(i=0;i<len;i++)
   {
       scanf("%d",&arr[i]);


   }
   printf("\n初始化完成\n");
}

void printArr(int arr[], int len)
{
   int i;
   for(i=0;i<len;i++)
   {
       printf("%d ",arr[i]);
   }
   printf("\n打印结束");

}
int getMax(int arr[],int len)
{
   int i;
   int j;
   int max=arr[0];
   for(i=0;i<len;i++)
   {
       if(max<arr[i])
       {
           max = arr[i];
           j=i;
       }
   }

   return max;

}

int main()
{
   int arr[10];
   int len;
   int max;
   int j;
   len =sizeof(arr)/sizeof(arr[0]);

   initArr(arr,len);
   printArr(arr,len);
   max= getMax(arr,len);
   j= getj(arr,len);
   printf("最大值为%d 下标为%d",max,j);
   return 0;
}
需求：输入10个数，然后输出最大值，以及最大值的下标。

定义一个有10个元素的数组，通过数组初始化，输出数组的元素，然后再通过 getmax()找到max

然后再找到下标。

初始化数组
void initArr(int arr[],int len)
{
   int i;
   printf("请输入10个数据\n");
   for(i=0;i<len;i++)
   {
       scanf("%d",&arr[i]);


   }
   printf("\n初始化完成\n");
}
输出数组遍历数组
void printArr(int arr[], int len)
{
   int i;
   for(i=0;i<len;i++)
   {
       printf("%d ",arr[i]);
   }
   printf("\n打印结束");

}
找到最大值
int getMax(int arr[],int len)
{
   int i;
   int j;
   int max=arr[0];
   for(i=0;i<len;i++)
   {
       if(max<arr[i])
       {
           max = arr[i];
           j=i;
       }
   }

   return max;

}
找到最大值的下标值
找最大值的下标值有很多种方法，这里是简单的方法，通过再次遍历数组，找出与max相等的元素，然后将其下标读取出来。直接返回

int getj(int arr[],int len)
{
   int i;
   int j;
   int max=arr[0];
   for(i=0;i<len;i++)
   {
       if(max<arr[i])
       {
           max = arr[i]; //已经得到数组中最大的值
                           //但是下标问题，还没有解决
       }

   }
   //再次遍历数组寻找到与max的元素，这时候就可以找到下标了
   for(i = 0;i<len;i++)
   {
       if(max == arr[i])
       {
           j = i+1;
       }

   }

   return j;

}
主函数
int main()
{
   int arr[10];
   int len;
   int max;
   int j;
   len =sizeof(arr)/sizeof(arr[0]);

   initArr(arr,len);
   printArr(arr,len);
   max= getMax(arr,len);
   j= getj(arr,len);
   printf("最大值为%d 下标为%d",max,j);
   return 0;
}
2，封装冒泡排序法
#include<stdio.h>
void initArr(int arr[],int len)
{
   int i;
   int j;
   int temp;
   for(i=0;i<len-1;i++)
   {
       for(j=0;j<len-1-i;j++)
       {
           if(arr[j]<arr[j+1]) //如果前项 <后向就交换
           {
               temp = arr[j];
               arr[j]= arr[j+1];
               arr[j+1]=temp;

           }
       }

   }
   for(i=0;i<len;i++)
   {
       printf("%d ",arr[i]);
   }
   for(i=0;i<len;i++)
   {
       printf("\n%p ",&arr[i]);
   }
}
int main()
{
   int arr[] = {1,33,4,32,54,42,32,12};
   int len = sizeof(arr)/sizeof(arr[0]);

   initArr(arr,len);

   return 0;
}
封装冒泡排序法，是需要数组传参。数组传参是将地址传过去，并不只是值。

3，封装选择牌序
#include<stdio.h>
void initxuanze(int arr[],int len)
{
   int i;
   int j;
   int temp;
   for(i=0;i<len-1;i++)
   {
       for(j=i+1;j<len;j++)
       {
           if(arr[i]<arr[j])
           {
               temp = arr[j];
               arr[j] = arr[i];
               arr[i] = temp;
           }
       }
   }
   for(i=0;i<len;i++)
   {
       printf("%d ",arr[i]);
       printf("%p \n",&arr[i]);

   }

}

int main()
{
   int arr[] = {12,33,44,55,55};
   int len;
   len = sizeof(arr)/sizeof(arr[0]);

   initxuanze(arr,len);

   return 0;
}
上部分总结
初识C语言
变量标识符
int float char double
printf()
//原样输出
//占位符输出
//可以多样输出

printf("");
scanf()
流程控制
顺序结构选择结构循环结构
顺序结构
数组
函数
5指针
1，初识指针
指针变量存放地址的变量
#include<stdio.h>
int main()
{
int *p;
printf("");

return 0;
}
#include<stdio.h>

// 指针就是地址
// 指针变量就是用来存放地址的变量
// 定义一个指针变量 *标识的作用产生在定义与声明的时候
// 使用指针变量 * 运算的作用

int main()
{
   int a = 10;
   int *p; //*是标识符告诉系统我是指针变量用来保存地址
   p = &a; //p等于取地址 a

   printf("数据 %d \n",a);
   printf("地址 %p \n",&a);
   printf("数据 %d \n",*(&a)); //*是取值运算符，将内存地址的数据取出来。
   printf("指针变量访问数据 %d \n",*p);
   printf("指针变量 %d",sizeof(*p));

   return 0;
}
指针变量的类型
不同的类型决定不同访问空间的大小int∗pdata;char∗pchar决定增量
不
同
的
类
型
决
定
不
同
访
问
空
间
的
大
小
�
�
�
∗
�
�
�
�
�
;
�
ℎ
�
�
∗
�
�
ℎ
�
�
决
定
增
量
#include<stdio.h>
int main()
{
   int a = 0x1234;
   int *p    = &a;
   char *c = &a;
   printf("地址是%p 数据是%d\n",p,*p);
   printf("地址是%p 数据是%d\n",c,*c);
   printf("地址是%p 数据是%x\n",p,*p);
   printf("地址是%p 数据是%x\n",c,*c);

   printf("地址是%p 数据是%x\n",++p,*p);
   printf("地址是%p 数据是%x\n",++c,*c);

   return 0;
}
通过不同的类型 ++p 增量也会不同

访问变量通过指针访问变量通过变量名访问变量
警告，存在将int*类型的指针赋值给char*类型的指针的不兼容指针类型警告。

指针使用的场景
用函数封装两数交换的方法
#include<stdio.h>

//两个数交换
void jiaohuan(int *pdata1,int *pdata2)
{
   int temp;

       temp = *pdata1;
       *pdata1 = *pdata2;
       *pdata2 = temp;

   printf("%d %d\n",*pdata1,*pdata2);
}

int main()
{
   int data1;
   int data2;
   printf("交换前\n");
   scanf("%d%d",&data1,&data2);//输入两个数
   printf("%d %d\n",data1,data2);
   jiaohuan(&data1,&data2);
   printf("交换后\n");
   printf("%d %d\n",data1,data2);

   return 0;
}
指向指针的固定区域
错误

C语言中，整数常量的后缀用于指定整数的类型，但是FE55不是有效的后缀。

如果您想要将一个具体的地址赋值给指针变量，您需要使用合适的地址表示方法。

#include <stdio.h>

int main() {
int *p = (int *)0x61FE55; // 使用16进制表示地址

// 使用指针进行操作
*p = 10;
printf("%d\n", *p);

return 0;
}
#include<stdio.h>
int main()
{
   int a = 11;
   printf("0x%p \n",&a); //打印a的地址
   int *p = (int *)0x000000000061FE55;
   printf("0x%p \n",p); //打印上面的地址
}
#include<stdio.h>
int main()
{
   int a = 11;
   printf("0x%p \n",&a); //打印a的地址 volatile 防止系统优化
   volatile unsigned int *p = (volatile unsigned int *)0x000000000061FE55;
   printf("0x%p \n",p); //打印上面的地址
}
3，作业封装输入三个数
int∗p//定义指针变量inta;printf("
�
�
�
∗
�
/
/
定
义
指
针
变
量
�
�
�
�
;
�
�
�
�
�
�
(
"
#include<stdio.h>
//输入3个数以大到小顺序输出
void changData(int *data1,int *data2,int *data3)
{
   int a;
   int b;
   int c;
   int temp;
   printf("取值 %d %d %d\n",*data1,*data2,*data3);
   printf("取值 %p %p %p\n",*data1,*data2,*data3);
   printf("取地址 %p %p %p\n",&data1,&data2,&data3);
   if(*data1<*data2)
   {
       temp = *data1;
       *data1 = *data2;
       *data2 = temp;
   }
   if(*data1<*data3)
   {
       temp = *data1;
       *data1 = *data3;
       *data3 = temp;

   }
   if(*data2<*data3)
   {
       temp = *data2;
       *data2 = *data3;
       *data3 = temp;

   }
   printf("取地址 %d %d %d\n",&data1,&data2,&data3);
   printf("取值 %p %p %p\n",*data1,*data2,*data3);
   printf("取地址 %p %p %p\n",&data1,&data2,&data3);
   printf("%d %d %d\n",*data1,*data2,*data3);

}

int main()
{
   int data1;
   int data2;
   int data3;


   scanf("%d%d%d",&data1,&data2,&data3);
   printf("原来的顺序\n");
   printf("%d %d %d\n",data1,data2,data3);
   printf("交换后\n");

   changData(&data1,&data2,&data3);
   printf("%d %d %d",data1,data2,data3);


   return 0;
}

2 ，通过指针迎合数组
1，定义指针变量指向数组
#include<stdio.h>
int main()
{
   int arr[] = {1,3,2,43,2,55};
   int *p;
   int *q;
   int len ;
   int i;
   len = sizeof(arr)/sizeof(arr[0]);
   p = arr;
   q = arr;
   for(i =0;i<6;i++)
   {
       printf("%d ",*(p+i)); //指针的偏移偏移程度取决于类型
   }

   printf("第二元素是 %d\n",*(p+1));
   printf("第一元素是 %d\n",*q);
   return 0;
}
2，通过指针引用数组元素
1，下标法
2，指针法
1，指针偏移
指针偏移就是指针往前移或者往后移

#include<stdio.h>
int main()
{
   int arr[] = {1,3,2,43,2,55};
   int *p;
   int *q;
   int len ;
   int i;
   len = sizeof(arr)/sizeof(arr[0]);
   p = arr;
   q = arr;
   for(i =0;i<len;i++)
   {
       printf("%d ",*(p+i)); //指针的偏移偏移程度取决于类型
   }
   printf("\n");
   p = arr; // 从新回到数组首地址从新遍历数组
   for(i = 0;i<len;i++)
   {
       printf("%d ",*p++);
   }
   printf("\n");
   p = arr;
   for(i = 0;i<len;i++)
   {
       printf("%d ",*p);
       p++;
   }
   printf("\n");

   printf("第二元素是 %d\n",*(p+1));
   printf("第一元素是 %d\n",*q);
   return 0;
}
2，取内容
指针和数组名的见怪不怪

指针当作数组名下标法访问朝花夕拾

#include<stdio.h>

int main()
{
   int arr[5]= {11,3,23,4,5};
   int *p = arr;
   int i;
   int len ;
   len = sizeof(arr)/sizeof(arr[0]);
   printf("%d \n",sizeof(arr));// 4 字节 x 5 = 20
   printf("%d \n",len);
   printf("%d \n",sizeof(int *)); //用8个字节表示一个地址
   printf("%d \n",sizeof(char*));
   printf("%d \n",sizeof(float*));

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

   }
   putchar('\n');
   for(i = 0;i<len;i++)
   {
       printf("%d ",*(p+i));
   }
   putchar('\n');
   for(i = 0;i<len;i++)
   {
       //printf("%d ",*arr++); *p 是指针变量
       // arr++ 是指针常量，编译不过。
       printf("%d ",*(arr+i));
   }
   putchar('\n');
   for(i = 0;i<len;i++)
   {
       printf("%d ",*(&arr[i]));

   }

   return 0;
}
3，两种方法效率对比
函数与指针与数组的结合
封装冒泡
#include<stdio.h>
//用指针封装冒泡排序法
void initArr(int *arr,int len)
{
   int i;
   puts("初始化开始");
   for(i = 0;i<len;i++)
   {
       scanf("%d",arr++);
   }
   puts("初始化结束");
}

void printArr(int *arr,int len)
{
   int i;
   for(i = 0;i<len;i++)
   {
       printf("%d ",*arr++);
   }

}

void maopaoArr(int *arr,int len)
{
   int i;//交换的轮数
   int j;//每一轮交换的次数
   int temp;//临时变量
   for(i=0;i<len-1;i++)
   {
       for(j=0;j<len-i-1;j++)
       {
           if(*(arr+j)>*(arr+j+1))
           {
               //printf("aa ");
               temp = *(arr+j);
               *(arr+j) = *(arr+j+1);
               *(arr+j+1) = temp;

           }
       }

   }

}

int main()
{
   int arr[5];
   int len;
   len = sizeof(arr)/sizeof(arr[0]);
   puts("程序开始");
   initArr(arr,len);
   printArr(arr,len);
   maopaoArr(arr,len);
   printf("\n");
   printArr(arr,len);

   return 0;
}
封装选择
#include<stdio.h>
#define mian main
// 用指针封装选择排序
void initArr(int *arr,int len)
{
   int i;
   for(i=0;i<len;i++)
   {
       scanf("%d",arr++);
   }

}

void printArr(int *arr,int len)
{
   int i;
   for(i=0;i<len;i++)
   {
       printf("%d ",*arr++);
   }
}

void xuanze(int *arr,int len)
{
   int i;
   int j;
   int temp;
   for(i = 0;i<len-1;i++)
   {
       printf("bb\n");
       for(j=i+1;j<len;j++)
       {
           printf("aa\n");
           if(*(arr+j)>*(arr+i))
           {

               temp = *(arr+i);
               *(arr+i) = *(arr+j);
               *(arr+j) = temp;

           }

       }
   }


}

int mian()
{
   int arr[5];
   int len ;
   len = sizeof(arr)/sizeof(arr[0]);
   initArr(arr,len);
   printArr(arr,len);
   xuanze(arr,len);
   printf("\n");
   printArr(arr,len);

   return 0;
}
封装交换
#include<stdio.h>
// 数组翻转
void initArr(int *arr ,int len)
{
   int i;
   for(i =0;i<len;i++)
   {
       scanf("%d",arr++);
   }

}

void printArr(int *arr,int len)
{
   int i;
   for(i =0;i<len;i++)
   {

       printf("%d ",*arr++); //*取值运算符（在这里是）
   }

}

void fanzhuan(int *arr,int len)
{
   int i;
   int j;
   int temp;
   for(i = 0;i<len/2;i++)
   {
       j = len-1-i;
       temp = *(arr+i);
       *(arr+i) = *(arr+j);
       *(arr+j) = temp;

   }

}

int main()
{
   int arr[5];
   int len ;
   len = sizeof(arr)/sizeof(arr[0]);
   printf("%d \n",len);
   initArr(arr,len);
   printArr(arr,len);
   printf("dome\n");

   fanzhuan(arr,len);
   printArr(arr,len);

   return 0;
}
3，二维数组地址的认知
1，二维数组第一维数组的每一个元素都是一个数组。
intarr[][];arr[0]+1;//第一个数组的第二个元素arr[0]//子数组的名字也是子数组的首地址
�
�
�
�
�
�
[
]
[
]
;
�
�
�
[
0
]
+
1
;
/
/
第
一
个
数
组
的
第
二
个
元
素
�
�
�
[
0
]
/
/
子
数
组
的
名
字
也
是
子
数
组
的
首
地
址
arr[0]+1;指针指向子数组的时向后偏移了一位指向了子数组首地址的后一位
�
�
�
[
0
]
+
1
;
指
针
指
向
子
数
组
的
时
向
后
偏
移
了
一
位
指
向
了
子
数
组
首
地
址
的
后
一
位
#include<stdio.h>
int main()
{
   int arr[3][4]={{1,2,33,2},{33,11,44,55},{5,32,12,345}};

   printf("父数组的地址是：%p 偏移%p\n",arr,arr+1); //父亲偏移了16
   printf("子数组的地址是：%p 偏移%p\n",arr[0],arr[0]+1);//孩子偏移了4
   printf("子数组的地址是：%p 偏移%p\n",*(arr+0),*(arr+0)+1);//孩子偏移了4


   return 0;
}
二维数组地址写法应用
int a[3][4];
a; //表示
a[0]+1;//第0行第1列 *(a+0)+1
a[1], *(a+1);
&a[1] a+1
a[2],*(a+2);
a[1]+2 ,*(a+1)+2, &a[1][2]; //取1 2 地址
*(a[1][2]) ,*(*(a+1)+2), *(&a[1][2] ) ,*(a[1]+2) ,a[1][2] //取1 ， 2值
4，数组指针
1，初识数组指针
int (*p) 指针变量

*（）取值运算符

int arr[3][4] = ;
int (*p)[4]; //定义一个数组指针
p = arr;
能不能定义一个指针，指针偏移的时候也偏移对应的数组 // 数组指针定义一个指针指向数组 // 数组指针才是真正等同于二维数组的名字

#include<stdio.h>
int main()
{
   int arr[3][4]={{1,3,34,2},{21,34,5,54},{21,5,54,22}};
   int i;
   int j;
   for(i = 0;i<3;i++)
   {
       for(j = 0;j<4;j++)
       {
           printf("%d ",arr[i][j]);


       }

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


       }

       printf("\n");
   }

   putchar('\n');
   // 能不能定义一个指针，指针偏移的时候也偏移对应的数组
   // 数组指针定义一个指针指向数组
   // 数组指针才是真正等同于二维数组的名字

   int (*p1)[4]; //数组指针定义方式
   p1 = arr;
   for(i = 0;i<3;i++)
   {
       for(j = 0;j<4;j++)
       {
           printf("%d ",*(*(p1+i)+j));


       }

       printf("\n");
   }

   return 0;
}
2，数组指针和二维数组的配合
#include<stdio.h>
// 用户输入行列的值然后输出行列对应的数字
void initscanfhanglie(int *hang,int *lie )
{
   puts("请输入行和列");
   scanf("%d%d",hang,lie);
   puts("输入完成");
}

int getdata(int (*p)[4],int hang,int lie)
{
   int data;
   data = *(*(p+hang)+lie);

   return data;

}

int main()
{
   int arr[3][4] = {{11,3,4,2},{33,55,66,22},{334,65,7,90}};
   //用户行列数
   int hang,lie;
   int data;
   initscanfhanglie(&hang,&lie);

   //获取行列对应的数字
   data = getdata(arr,hang,lie);
   printf("%d %d %d",hang,lie,data);

   return 0;
}
5，函数指针
1，定义函数指针
函数名就是地址数组名也是地址

在程序中定义一个函数，编译系统为函数代码分配存储空间，，这段存储空间的起始地址

（入口地址）就是这个函数的指针。

2，定义函数指针变量
int a;
int *p;

char c;
char *p;

int (*p)(int a,int b); ///定义函数指针
int *p(int a,int b);
函数指针的好用的地方
根据程序运行过程的不同情况，调用不同的函数
练习题输入a b 根据 1，2，3模式 1，求最大值 2，求最小值 3，求和
#include<stdio.h>
#include<stdlib.h>
//输入两个数有3个模式 1最大值 2最小值 3求和
int getMax(int data1,int data2)
{
   int max;
   max = data1>data2?data1:data2;
   return max;
}
int getMin(int data1,int data2)
{
   int min;
   min = data1<data2?data1:data2;
   return min;
}
int getSum(int data1,int data2)
{
   int sum;
   sum = data1+data2;
   return sum;
}
int getmode(int data1,int data2, int (*pfunc)(int,int))
{
   int ret ;
   ret = pfunc(data1,data2);

   return ret;
}

int main()
{
   int a;
   int b;
   int ret;
   printf("请输入两个数\n");
   scanf("%d%d",&a,&b);
   putchar('\n');
   printf("请输入对应的模式 1 最大值，2最小值，3求和\n");
   int cmd;
   int (*pfunc)(int,int);
   scanf("%d",&cmd);

   switch(cmd)
   {
       case 1:
           pfunc =getMax;
       break;
       case 2:
           pfunc = getMin;
       break;
       case 3:
           pfunc =getSum;
       break;
       default:
           printf("错误\n");
           exit(-1);
       break;
   }
   ret = getmode(a,b,pfunc);
   printf("输入的两个数为%d %d \n %d结果为%d",a,b,cmd,ret);

   return 0;
}
回调函数
指针数组
一个数组中的元素均为指针类型的数据成为指针数组。

指针数组中每一个元素存放一个地址，相当于一个指针变量

int (*p)[2]; //这个是指向一推数组的指针变量
int a;
int b;
int c;
int d;

int *p[3] = {&a,&b,&c}; //指针数组
int *p[2][3];
3，使用函数指针
1，函数调用概念和变量一样
直接访问（变量名，函数名）

间接访问（指针函数指针）

4，指针数组和数组指针的区别
数组指针（pointer to an array）：

数组指针指的是一个指针，它指向一个数组的内存块。

数组指针的声明包括指针名和所指向数组的元素类型，但不包括数组大小。

通过解引用数组指针加上索引来访问数组中的元素。

示例代码

int (*arr)[10];//声明一个指针，指向一个具有10个元素的数组
int arr[10]; //数组

int (*ptr)[10]; // 声明一个指针，指向包含10个整数元素的数组
int arr[10]; // 声明一个包含10个整数元素的数组
ptr = &arr; // 将数组的地址赋值给指针
(*ptr)[0] = 5; // 通过指针访问数组元素，并赋值
指针数组（array of pointers）：

指针数组是一个数组，在数组中的每个元素都是指针，指向不同的内存块。

指针数组的声明包括指针数组的名字和每个指针所指向的数据类型。

指针数组的每个元素都可以指向不同类型的数据（指针类型除外）。

示例代码：

int *arr[5]; // 声明一个包含5个指针元素的指针数组
int num1 = 5, num2 = 10, num3 = 15;
arr[0] = &num1; // 指针数组的第一个元素指向 num1
arr[1] = &num2; // 指针数组的第二个元素指向 num2
arr[2] = &num3; // 指针数组的第三个元素指向 num3
*arr[0] = 7; // 通过指针数组访问并修改所指向的数据
数组指针指向一个数组的内存块，而指针数组是一个包含指针的数组。

数组指针的声明形式为 elementType (*ptr)[size]，而指针数组的声明形式为 elementType *arr[size]。

数组指针可以通过解引用和索引操作访问数组元素，指针数组可以通过索引操作访问每个指针所指向的对象。

数组指针和指针数组的应用场景和使用方式有所不同，具体取决于程序的需求。

5，指针函数
指针函数就是返回值是指针变量的函数

int *a(int a,int b)
{
int *p;
p = &a;
return p;

}
#include<stdio.h>
int *getPosPerson(int pos,int (*arr)[4])
{
   int *p;
   p = (int *)arr+pos;
   return p;
}

int main()
{
   int arr[3][4] = {
       {11,33,54,43},
       {80 ,94,76,98},
       {79,80,76,45},
   };
   int pos;
   int *ppos;

   printf("请输入学生的学号0 1 2\n");
   scanf("%d",&pos);
   ppos = getPosPerson(pos,arr);
   for(int i = 0;i<4;i++)
   {
       printf("%d ",*ppos++);
   }
   return 0;
}
6，二级指针
#include<stdio.h>
int main()
{
int data1 = 100;
int *p;
p = &data;
printf("%p ",p);
int **p2;
p2 =&p;
printf(" p的地址是%p ",p2);
return 0;
}
#include<stdio.h>
int main()
{
   int data = 100;
   int *p = &data; //P保存的是data的地址；
   printf("data的地址是%p \n",p);
   int**p2=&p;
   p2 =&p;
   int a = (int )**p2;
   printf("pp2 保存的是 p的地址 %p \n",p2);
   printf("*p2 是%p \n",*p2);
   printf("**p2 是%p ,",**p2);

   return 0;
}
1，野指针
定义一个指针变量如果我们没有给这个指针变量要保存的地址那这个指针变量就是一个野指针。系统会随机为这个指针变量分配保存的地址。

int *p; //p后面没有要保存的地址，所以这个指针变量就是野指针
6，字符串
1，字符串就是字符数组
1，定义的几种格式
#include<stdio.h>
int main()
{
int *char = "holle word";
}
#include<stdio.h>
int main()
{
   //比较蠢的方式
   char arr[]={'f','e','e','r','w','e','r','f','s'};
   //比较人性的方式
   char arr1[]="hello";
   //比较常用的方式
   char *arr2 = "困困";


   int len =sizeof(arr)/sizeof(arr[0]);
   int i;
   for(i=0;i<len;i++)
   {
       printf("%c",arr[i]);
   }
   putchar('\n');

   printf("%s\n",arr1);
   printf("%s\n",arr2);

   return 0;

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

int main()
{
   int a;
   int data1[] = {1,2,3,4,5};
   char cdata[] = {'h','o','l','l','e'};
   char cdata1[] = "holle";
   a = len (data1);
   printf("%d ",a);

   return 0;
}
2，和整型数组在存储上的区别
字符串多了一个 ‘ \0’ 长度多了一个字节

#include<stdio.h>
int main()
{
   //字符串和字符数组的区别
       //字符串存储比字符数组多了‘\0’结束标志

   int data1[] = {1,2,3,4,5};
   char data2[] = {'f','e','e','r','t','h','e','n','\0'};

   char data3[] = "feerthen";
   char *data4 = "feerthen";
   int len;
   int len1;
   int len2;
   int len3;
   len = sizeof(data1)/sizeof(data1[0]);
   len1 = sizeof(data2)/sizeof(data2[0]);
   len2 = sizeof(data3)/sizeof(data3[0]);//字符串多了一个'\0'结束标志
   len3 = sizeof(data4)/sizeof(data4);

   printf("%d \n",len);
   printf("%d \n",len1);
   printf("%d \n",len2);
   printf("%d \n",len3);

   return 0;
}
3，sizeof和strlen的区别
sizeof() 计算字符串所有的元素（包括''\0'）

strlen() 只计算有效部分

#include<stdio.h>
#include<string.h>
int main()
{
   char data[] = "hello";
   printf("data sizeof :%d\n",sizeof(data));
   printf("data strlen :%d\n",strlen(data));

   return 0;
}
4，动态开辟字符串
1，malloc 动态开辟内存空间
free(p); //把前面malloc申请的空间释放掉。防止内存泄露，防止悬挂指针。

realloc(p,newlen); //realloc 是在 malloc分配地址不够的情况下进行扩容地址

memset(p,'\0',12); //把p里面的12 个字节全部初始化成 ‘\0’

p = (char*)malloc(12); //动态开辟12个字节

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

int main()
{
   char *p; //野指针
   p = (char *)malloc(1);// p有了具体的内存指向
   *p = 'c';

   free(p);   //把前面malloc申请的空间释放掉。防止内存泄露，防止悬挂指针。

   printf("p的字符是%c\n",*p);
   printf("%p\n",p);

   p = (char*)malloc(12); //动态开辟12个字节

   printf("扩容前的地址%x\n",p);
   int len = strlen("jfiopeqqp12345321421421414126678");
   int newlen = len-2+1;

   realloc(p,newlen); //realloc 是在 malloc分配地址不够的情况下进行扩容地址

   memset(p,'\0',12); //把p里面的12 个字节全部初始化成\0

   printf("扩容后的地址%x\n",p);



   p = strcpy(p,"jfiopeqqp12345321421421414126678");
   puts(p);

   //printf("%s",p);

   return 0;
}
5，几种字符串常用的API
strcpy()
char* copy(char*p,char*str)
{
   if(p == NULL||str == NULL)
       return NULL;
   char* ber;
   ber =p;
   while(*str != '\0')
   {
       *p = *str;
       p++; //指针偏移
       str++;
   }
   *p = '\0';//循环结束时+一个'\0'结束标志
   return ber;
}
char* copy1(char* p,char*str)
{
   if(p == NULL||str == NULL)
       return NULL;
   char* ber;
   ber =p;
   while(*str != '\0')
       *p++ = *str++;
   *p = '\0';//循环结束时+一个'\0'结束标志
   return ber;

}
char* copy2(char* p,char*str)
{
   if(p == NULL||str == NULL)
       return NULL;
   char* ber;
   ber =p;
   while((*p++=*str++) != '\0');
       *p = '\0';//循环结束时+一个'\0'结束标志
   return ber;
}
strncopy()
这种方式有点bug

char* ncopy(char*p,char*str,int count)
{
   if(p == NULL||str == NULL)
       return NULL;
   char* ber;
   ber =p;
   while(*str != '\0',count>0)
   {
       *p = *str;
       p++; //指针偏移
       str++;
       count--;
   }
   //当我们字节的值大于所需要拷贝内容的字节时，用这个
   if(count >0)
   {
       while(count>0)
       {
           count--;
           *p++ = '\0';
       }
       return ber;
   }
   *p = '\0';//循环结束时+一个'\0'结束标志
   return ber;
}
这种方式考虑就很全了

当 count 大于要复制的内容时，后面的字节我不知道有什么东西，有可能会产生不可估量的影响，所以要对后面剩余的字节进行填充。

当 count 小于复制内容时，会出现越界，所以我们要当count等于0时给一个结束标志。

char* ncopy1(char*p,char*str,int count)
{
   if(p == NULL||str == NULL)
       return NULL;
   char* ber = p;
   while(count && (*p++ = *str++))
       count--;
   if(count)
       while(--count)
           *p++='\0';
   return ber;

}
dst ：destination的缩写 src：source的缩写 strcpy ： string copy

char* strcpy(char*dst, const char *src)
{
   if ((dst == NULL) || (src == NULL))
       return NULL;
   char *ret = dst; //[1]
   while ((*dst ++= *src++) != '\0')； //[2]
       return ret; //[3]
}
const ：防止在赋值的给dst的时候发生改变；
ret ：return ，返回的是dst的首地址。
while ((*dst ++= *src++) != ‘\0’)；当 *src =‘\0’ 的时候为false while（）结束。

assert() 断言函数
assert() 他是一个宏他的作用就是用来测试程序是否有问题偶尔用几下

如果用完可以用 #define NDEBUG 让assert()失效

**所在头文件：<assert.h>*

*函数原型：void assert (int expression);*

*参数：expression即要检测的表达式*

*返回值：无返回值*

“断言”在语文中的意思是“断定”、“十分肯定地说”，在编程中是指对某种假设条件进行检测，如果条件成立就不进行任何操作，如果条件不成立就捕捉到这种错误，并打印出错误信息，终止程序执行。

assert() 会对表达式expression进行检测：

如果expression的结果为 0（条件不成立），那么断言失败，表明程序出错，assert() 会向标准输出设备（一般是显示器）打印一条错误信息，并调用 abort() 函数终止程序的执行。

如果expression的结果为非 0（条件成立），那么断言成功，表明程序正确，assert() 不进行任何操作。
———————————————— 版权声明：本文为CSDN博主「桦秋静」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：assert断言函数简介_assert函数_桦秋静的博客-CSDN博客

assert(expression) 使用方法

#include<stdio.h>
#include<assert.h>

int main()
{
   int a;
   int b;
   scanf("%d%d",&a,&b);
   float c = (float)a/b;
   assert(b!=0); //当b=0的时候表示断言失败其会想设备打印一条信息，
                       //而后通过abort()函数终止程序运行
   printf("%2.2f",c);

   return 0;
}
assert() 检测的时候表达式写简单点，一般是一个assert()检测一个表达式。如果一个assert()检测多个表达式，就不知道是哪个表达式有问题，无法正确排除错误。

assert(expression1);
assert(expression2);
assert() 不用会改变环境的语句作为断言的表达式

#include<stdio.h>
#include<assert.h>

int main()
{
   int a;
   int i;
   while(i<=100)
   {
       ++i;
       assert(++i<100); //当i 到100的时候终止运行了
       printf("aaaa%d\n",i);

   }
   return 0;
}
在 Debug 模式下运行，程序循环到第 101 次时，i 的值为 100，++i <= 100不再成立，断言失败，程序终止运行。

而在 Release 模式下运行，编译参数中设置了 NDEBUG 宏（如果编译器没有默认设置，那么需要你自己来设置），assert() 会失效，++i <= 100这个表达式也不起作用了，while() 无法终止，成为一个死循环。

定义了 NDEBUG 宏后，assert(++i <= 100)会被替换为((void)0)。

导致程序在 Debug 模式和 Release 模式下的运行结果大相径庭的罪魁祸首就是++运算，我们本来希望它改变 i 的值，逐渐达到 while 的终止条件，但是在 Release 模式下它失效了。
———————————————— 版权声明：本文为CSDN博主「桦秋静」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：assert断言函数简介_assert函数_桦秋静的博客-CSDN博客

修改后的代码

把，++i 移出来

#include<stdio.h>
#include<assert.h>

int main()
{
   int a;
   int i;
   while(i<=100)
   {
       ++i;
       assert(100); //当i 到100的时候终止运行了
       printf("aaaa%d\n",i);

   }

   return 0;
}
字符串拼接 strcat() 实现
字符拼接 strcat( str, ber ) 可以将 ber 的字符串拼接到 str 的尾部

1，调用方式

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

int main()
{
   char str[120] = "我们shi_ikun";
   char*p = "苍天已死，黄天当立";

   strcat(str,p);
   puts(str);
   return 0;
}
效果

2，自己写strcat()拼接函数

char* Mystrcat(char* dst,const char* src)
{
   char* der = dst;
   while(*dst)
       dst++;
   while((*dst++=*src++)!='\0');
       return der;
}
char* Mystrcat1(char* dst,const char* src)
{
   assert(dst !=NULL ); //断言如果=NULL就报错
   assert(src !=NULL);
   char* der = dst;
   while(*dst!='\0')
       *dst++;
   while(*src!='\0')
       *dst++=*src++;
   return der;
}
#include<stdio.h>
#include<assert.h>
char* Mystrcat(char* dst,const char* src)
{
   char* der = dst;
   while(*dst)
       dst++;
   while((*dst++=*src++)!='\0');
       return der;
}
char* Mystrcat1(char* dst,const char* src)
{
   assert(dst !=NULL ); //断言如果=NULL就报错
   assert(src !=NULL);
   char* der = dst;
   while(*dst!='\0')
       *dst++;
   while(*src!='\0')
       *dst++=*src++;
   return der;
}

char* strcopy(char* dst,char* src)
{
   assert(dst !=NULL ); //断言如果=NULL就报错
   assert(src !=NULL);
   char*der = dst;
   while((*dst++ = *src++)!='\0');
   *dst ='\0';
   return der;
}

int main()
{
   char c[123] = "苍天已死，黄天当立" ;
   char* p = " 岁在甲子，天下大吉";
   char*a =Mystrcat1(c,p);
   puts(a);
   return 0;
}
字符比较strcmp()的使用与实现
int strcmp(const char* s1,const char* s2);
//若s1 = s2 返回0 s1<s2 返回负数；s1>s2 返回正数；
   // 比的是 ASII码值


int strncmp(const char* s1, const char* s2, size_t n);
   //功能是将s1与s2进行比较，最多比较前n个字节
   //若s1=s2 （字符串）返回0;
   //若S1>S2 (字符串) 返回 >0的数;
   //若s1<s2 （字符串）返回<0 的数


调用 strcmp()

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

int main()
{
   char* a1 = "iz";
   char* a2 = "ik";
   int ret = strcmp(a1,a2);
   printf("ret = %d",ret);
   return 0;

}
自己手写 strcmp()比较函数

int cdeclstrcmp (const char * src, const char * dst)
{
int ret = 0 ;
while( !(ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
++src, ++dst;
if ( ret < 0 )
ret = -1 ;
else if ( ret > 0 )
ret = 1 ;
return( ret );
}

我们要看的是while循环这个语句， ! (ret = (unsigned char )src - (unsigned char )dst)意思是拿指针变量src所指向的字符值（即src）减去指针变量dst所指向的字符值（即dst），差值赋给ret，再取非运算，最后与dst进行与运算；拿abc例，第一次因为a=a，则执行++src,++dst；2次自加后，ret值为负，跳出while语句，执行if语句的判断，输出为-1；这里要注意的是： 1.unsigned char是强制转换类型。 2.若src和dst都为空串，返回值是多少呢？因为空串不是指地址为空，还是有地址的，这样就很明确了。

#include<stdio.h>

//字符比较函数
int Mystrcmp(const char* s1,const char* s2)
{
   int der = 0;
   int str1 = 0;
   int str2 = 0;
   char* backstr1 = s1;
   char* backstr2 = s2;
   while(*s1 && *s2 && (*s1==*s2))
   {
       s1++;
       s2++;
   }
   if(*s1||*s2)
   {
       s1 = backstr1;
       s2 = backstr2;
       while(*s1)
       {
           str1+=*s1;
           s1++;
       }
           while(*s2)
       {
           str2+=*s2;
           s2++;
       }

   }
   der = backstr1 - backstr2;
   if(der<0)
   {
       der = -1;
   }
   if(der >0)
   {
       der =1;

   }
   return der;

}

int main()
{
   char* a = "ikun";
   char* b = "icao";
   int a1;
   int a2;
   a2 = cdeclstrcmp(a,b);
   a1 = Mystrcmp(a,b);
   printf("%d",a2);

}
7，结构体 struct
1，结构体的定义 struct
结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合，也叫结构。

通俗的来说其实就是，开辟一个新的变量来存储这个变量的不同属性，比如，学生成绩，它有语数外三科成绩，因为这三科成绩属于同一个人。**

结构体可以说是 C语言面向对象的工具

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

struct Student
{
int num;
int age;
char sex;
char name[32];
double score;
char addr[32];
};

int main()
{
struct Student stu1;
stu1.num = 1;
stu1.age = 14;
stu1.sex = 'w';
strcpy(stu1.name,"蔡徐坤");
stu1.score = 98.3;
strcpy(stu1.addr,"贵阳");

printf("学号：%d\n",stu1.num);
printf("年龄：%d\n",stu1.age);
printf("性别：%c\n",stu1.sex);
printf("名字：%s\n",stu1.name);
printf("分数：%2.2lf\n",stu1.score);
printf("地址：%s\n",stu1.addr);
return 0;
}

2，结构体和数组
结构体数组是指一个数组里面的每一个元素都是一个结构体。每一个元素都包含了这个结构体里面所定义的所有属性。

访问结构体其内部定义的属性时有两种访问方式，一种是通过变量名，一种是通过结构体指针

变量名 struct Student s.num。通过 . 来访问结构体内部属性

结构体指针 p->num 通过 -> 来访问结构体内部的属性

结构体里面存放的数据的地址是连续的，结构体里存放的每一个数据地址都是独立的

结构体所占内存空间大小 = 结构体里面所有数据字节之和。

printf("age: %d name: %s\n",kun.age,kun.name);//以变量名直接访问结构体里面不同类型的变量。用"."
printf("age: %d name: %s",ps->age,ps->name);//通过结构体指针直接访问结构体内部数据。用"->"

结构体数组的运用

#include<stdio.h>

struct Student
{
int num;
char name[32];
int age;
char sex;
double score;
char addr[32];
};

int main()
{
int arr[3] = {1,3,2};
int len ;
int i;
struct Student arr2[3] = {
{1,"蔡徐坤",18,'w',98.5,"贵阳"},
{2,"李素",21,'m',92.2,"六盘水"},
{3,"徐坤",73,'m',100,"北京"}
};
len = sizeof(arr2)/sizeof(arr2[0]);
for(i = 0;i<len;i++)
{
printf("学号：%d 姓名：%s 年龄：%d 性别：%c 分数：%-2.2lf 地址：%s\n",
arr2[i].num,arr2[i].name,arr2[i].age,arr2[i].sex,arr2[i].score,arr2[i].addr);
}
return 0;
}
选票系统

此过程分为初始化候选人，唱票环节，打印选票数据，输出最终的选票结果。

#include<stdio.h>
#include<string.h>
struct Xuanmin
{
char name[32];
int tickets;
};

int main()
{
struct Xuanmin ikun[3];
struct Xuanmin max;
int feipiao;
int i,j;
int len ;
int ticketer = 5;
char tmpName[32];
int mak;

len = sizeof(ikun)/sizeof(ikun[0]);
//初始化，环节
for(i = 0;i<len;i++){
ikun[i].tickets = 0;
printf("请输入第%d候选人的名字\n",i+1);
scanf("%s",&ikun[i].name);
}
//唱跳环节
for(i = 0;i<5;i++)
{
mak = 0;
printf("请输入您投票人的名字\n");
memset(tmpName,'\0',sizeof(tmpName));
scanf("%s",&tmpName);

for(j = 0;j<len;j++)
{
if(strcmp(tmpName,ikun[j].name)==0)
{
ikun[j].tickets++;
mak = 1;
}
}
if(mak ==0){
printf("没有此候选人 \n");
feipiao++;
}
}

for(i = 0;i<len;i++)
{
printf("名字：%s 票数：%d\n",ikun[i].name,ikun[i].tickets);
}
max = ikun[0];
for(i=0;i<len;i++){
if(max.tickets<ikun[i].tickets)
{
max = ikun[i];
}
}

printf("%s以%d票当选，废票有%d\n",max.name,max.tickets,feipiao);


return 0;
}
用typedef 关键字和结构体运用

#include<stdio.h>
#include<string.h>
typedef struct
{
int ticker;
char name[32];
}Expectant;

案例

#include<stdio.h>
#include<string.h>
typedef struct
{
int ticker;
char name[32];
}Expectant;

int main()
{
Expectant arr[3];
Expectant *parr;
Expectant max;
int i,j;
int take = 5;
char tmpName;
int make;
int feipiao = 0;

int len = sizeof(arr)/sizeof(arr[0]);

for(i = 0;i<len;i++)
{
printf("请输入第%d个候选人姓名： ",i+1);
arr[i].ticker = 0;
scanf("%s",&arr[i].name);
}
for(i = 0;i<take;i++)
{
make = 0;
printf("请输入您选举候选人的名字\n");
memset(&tmpName,'\0',sizeof(tmpName));
scanf("%s",&tmpName);
for(j = 0;j<take;j++){
if(strcmp(&tmpName,arr[j].name)==0)
{
arr[j].ticker++;
make = 1;
}
}
if(make == 0)
{
printf("没有此候选人\n");
feipiao++;
}
getchar();
}



for(i=0;i<len;i++)
{
printf("候选人姓名：%s 票数：%d 废票有：%d\n ",arr[i].name,arr[i].ticker,feipiao);
}
max = arr[0];
for(i = 0;i<len;i++)
{
if(max.ticker<arr[i].ticker)
{
max = arr[i];
}
}
printf("恭喜 %s以 %d 票当选省委书记!!!!!!!!\n",max.name,max.ticker);


return 0;
}

1，结构体指针
1,用变量访问结构体里面的属性就要用 ‘.’

2,用指针间接访问结构体里面的属性用‘->’

#include<stdio.h>
#include<string.h>
typedef struct
{
int ticker;
char name[32];
}Expactant;

int main()
{
Expactant arr[3];
Expactant *parr;
Expactant max;
parr = arr;
//Expactant max;
int i,j;
int len ;
char tempname[32];
int take=5;
int make = 0;

len = sizeof(arr)/sizeof(arr[0]);
//初始化arr
for(i=0;i<len;i++)
{
parr->ticker =0;
printf("第%d号候选人姓名：\n",i+1);
scanf("%s",parr->name);
parr++;
}
//唱票环节
parr = arr;
make = 0;
for(i=0;i<take;i++)
{
printf("请输入您选择的候选人\n");
memset(tempname,'\0',sizeof(tempname));
scanf("%s",&tempname);

parr = arr;
for(j = 0;j<len;j++){
if(strcmp(tempname,parr->name)==0)
{
parr->ticker++;
make = 1;
}parr++;
}
if(make == 0)
{
printf("没有候选人\n");
}

}

parr=arr;
for(i=0;i<len;i++)
{
printf("候选人名字:%s 候选人票数%d\n",parr->name,parr->ticker);
parr++;
}
//指针++每次都会遍历到数组尾巴，下次遍历要记得从新把指针指向数组首地址
max = arr[0];
parr = arr;
for(i = 0;i<len;i++)
{
if(max.ticker<parr->ticker)
max.ticker = arr[i].ticker;
parr++;
}
printf("恭喜%s 以%d 的票数当选省委书记!!!!!!!\n",max.name,max.ticker);
return 0;
}
2，结构体指针，数组，函数结合
所需要的头文件

以及结构体

#include<stdio.h>
#include<string.h>
#include <stdlib.h>
typedef struct
{
int ticker;
char name[32];
}Expactant;
结构体指针函数初始化候选人

Expactant *initXm(Expactant*p,int *pn)
{
int i;
int tmpename;
if(p == NULL){
printf("请输入参与竞选的人数\n");
scanf("%d",pn);
p = (Expactant*)malloc(*pn*sizeof(Expactant));
}
for(i = 0;i<*pn;i++)
{
p->ticker = 0;
printf("请输入第%d个选民的名字：\n",i+1);
scanf("%s",p->name);
p++;
}
return p-*pn;
}
唱票环节

int getWot(Expactant *p,int len )
{
Expactant *pbak = p;
int i,j;
int feip = 0;
char tempname[32];
//int take=5;
int make = 0;
make = 0;
p->ticker = 0;
for(i=0;i<len;i++)
{
printf("请输入您选择的候选人\n");
memset(tempname,'\0',sizeof(tempname));
scanf("%s",&tempname);

p = pbak; //把pbak给到p让p回到首地址
for(j = 0;j<len;j++){
if(strcmp(tempname,p->name)==0)
{
p->ticker++;
make = 1;
}
p++;
}
if(make == 0)
{
printf("没有候选人\n");
feip++;
}

}
return feip;
}
输出函数

void printXm(Expactant*p,int pn)
{
int i;
for(i=0;i<pn;i++)
{
printf("名字：%s,票数：%d\n",p->name,p->ticker);
p++;
}
}

主函数

int main()
{
int feip;
Expactant *XM = NULL;
int len = 0;
XM = initXm(XM,&len);
printXm(XM,len);

//getWot(XM,len );
feip = getWot(XM,len);
printf("废票有%d\n",feip);
printXm(XM,len);
return 0;
}
4，联合体/共用体基本概念
**联合体 union {}** 联合体就是共用体，联合体是多种数据类型共同使用一个空间，也就是说，共用体里面的数据类型不管有多少种，多少个，他们的**地址**是一样的。共用体最大地址是由共用体里面最大的数据类型决定的。共用体里面哪个数据类型所占的字节最大就确定这个共用体占了多少个字节。例如：如果最大数据类型是 double 一个double 八个字节就说明这个共用体就有八个字节的内存空间。
共用体的基本用法

union St{
int num;
int age;
char[32] name;
};

int main()
{
union St s1;
s1.num = 1; //为共用体 num属性赋值
printf("%d ",s1.num);
return 0;
}
#include<stdio.h>

struct TestT
{
int idata;
char cdata;
double ddata;
};

union TestU
{
int idata;
char cdata;
double ddata;

};

int main()
{
struct TestT t1 = {1,'a',9.2};
union TestU u1;
u1.idata = 2;
u1.cdata = 'c';
u1.ddata = 89.2;
//union TestU u2;
//u2.cdata = 'd';
//union TestU u3;
//u3.ddata = 2.3;



printf("t1 idata = %d\n",t1.idata);
printf("t1 cdata = %c\n",t1.cdata);
printf("t1 cdata = %2.2lf\n",t1.ddata);
printf("t2 cdata = %d\n",u1.idata);
printf("t2 cdata = %p\n",&u1.idata);
printf("t2 cdata = %c\n",u1.cdata);
printf("t2 cdata = %p\n",&u1.cdata);
printf("t2 cdata = %2.2lf\n",u1.ddata);
printf("t2 cdata = %p\n",&u1.ddata);



return 0;
}
2，联合体的作用
联合体（union）是C语言中的一种特殊数据类型，它允许在同一内存位置存储不同类型的成员变量。联合体的大小等于其最大成员的大小。

联合体的主要作用是节省内存空间。通过使用联合体，可以在相同的内存位置上存储不同类型的数据，从而避免为每种类型分配独立的内存空间。

除了节省内存外，联合体还可以用于以下几个方面：

存储不同类型的数据：联合体允许在不同时间存储不同类型的数据。你可以根据需要在联合体中使用一个成员，而其他成员则被忽略。

数据类型的转换：联合体可以用于进行类型转换。通过在不同类型的成员之间进行赋值，可以将数据从一种类型转换为另一种类型。

给成员起别名：联合体可以为不同的成员变量提供相同的内存位置，这样可以为这些成员变量起不同的别名，方便访问。

需要注意的是，联合体在同时存储不同类型的数据时，只能使用一个成员来访问数据，而其他成员的值会被覆盖。因此，在使用联合体时要确保正确地访问和操作成员变量，以避免出现意外的结果。

共用体的应用

#include<stdio.h>

struct St
{
char name[32] ;
int age;
char sex;
char zhiye;
union {
int class;
char kemu[32];
}mes;

};

int main()
{
int i;
int len;
struct St arr[3];
len = sizeof(arr)/sizeof(arr[0]);

fleg:
for(i=0;i<3;i++)
{
printf("请输入您的职业。\n[s]:学生，[t]:老师\n");

scanf("%c",&(arr[i].zhiye));
//if(arr[i].zhiye !='s'||arr[i].zhiye!='t'){
//goto fleg;
//printf("输入错误，请从新输入\n");
// }
if(arr[i].zhiye =='s')
{
printf("请输入班级\n");
scanf("%d",&(arr[i].mes.class));
printf("请输入您的名字\n");
scanf("%s",&(arr[i].name));
}
if(arr[i].zhiye == 't')
{
printf("请输入您授课的科目\n");
scanf("%s",&(arr[i].mes.kemu));
printf("请输入您的名字\n");
scanf("%s",&(arr[i].name));
}
getchar();
if(arr[i].zhiye!='s' && arr[i].zhiye!= 't')
{
printf("输入错误，请从新输入\n");
goto fleg;
}
//getchar();
}
for(i = 0;i<3;i++)
{
if(arr[i].zhiye =='s')
printf("学生姓名：%s 班级；%d\n",arr[i].name,arr[i].mes.class);
if(arr[i].zhiye == 't')
printf("教师姓名：%s 科目：%s\n",arr[i].name,arr[i].mes.kemu);

}


return 0;
}
3，枚举类型enum
如果一个变量只有几种可能的值，比如星期几 son mon tus wed thu fri sat

在C语言中，枚举类型（enumeration）用于定义一组具有命名值的常量。枚举类型允许用一个易记的名字来表示一组相关的常量，增强了代码的可读性和可维护性。

枚举类型的定义格式如下：

enum 枚举类型名 {
枚举常量1,
枚举常量2,
...
};
其中，枚举类型名是你为枚举类型起的名字，可以根据需要自定义。

在枚举类型的定义中，你可以列出多个枚举常量，每个枚举常量用逗号分隔。枚举常量通常是大写字母命名，以表示它们是常量。

以下是一个示例，展示如何定义一个表示颜色的枚举类型：

#include <stdio.h>

enum Color {
RED,
GREEN,
BLUE
};

int main() {
enum Color color1;
enum Color color2;

color1 = RED;
color2 = BLUE;

printf("Color1: %d\n", color1);
printf("Color2: %d\n", color2);

return 0;
}
在上述示例中，我们定义了一个名为 Color 的枚举类型，包含了三个枚举常量 RED、GREEN 和 BLUE。然后，在 main 函数中声明了两个枚举类型的变量，并将其中的一个变量赋值为 RED，另一个为 BLUE。最后，通过 %d 格式说明符将枚举常量打印为整数值。

输出结果为：

Color1: 0
Color2: 2
每个枚举常量都会被赋予一个默认的整数值，从0开始递增。在上面的示例中，RED 被赋值为0，GREEN 没有直接赋值，默认为1，BLUE 被赋值为2。

你也可以在定义枚举时为每个枚举常量指定特定的值，如：

enum Month {
JAN = 1,
FEB = 2,
MAR = 3,
...
};
这样，JAN 的值为1，FEB 的值为2，以此类推。

定义一个 enum类型

enum WeekDay {xinqi1,xinqi2,xinqi3,xinqi4,xinqi5,xinqi6,xinqi7};
// 默认情况下第一个元素是0
可以忽略枚举类型名直接定义枚举变量，枚举类型里面的元素名字不能重复

enum {w,e,q,r,s}w1,w2;
4，typedef关键字介绍
给已有的变量取名字，配合结构体使用可以不用写struct 开头

1，typedef 定义作用
在C语言中，typedef 关键字用于为已有的数据类型起一个新的名字。它提供了一种简化和增强代码可读性的方式，使数据类型的定义更加清晰和易于理解。

typedef 的定义格式如下：

typedef 旧类型名新类型名;
通过使用 typedef，你可以为已有的数据类型起一个新的别名。这个别名就可以像原始类型一样使用，但是它的名称更具有描述性，更方便理解。

以下是一些 typedef 的使用示例：

#include <stdio.h>

typedef int 整数; // 为 int 类型定义别名为整数
typedef float 小数; // 为 float 类型定义别名为小数

typedef struct {
int 年;
int 月;
int 日;
} 日期; // 为结构体类型定义别名为日期

int main() {
整数 a = 10;
小数 b = 3.14;

日期 d = {2023, 8, 2};

printf("a: %d\n", a);
printf("b: %f\n", b);
printf("日期: %d-%d-%d\n", d.年, d.月, d.日);

return 0;
}
在上述示例中，我们使用 typedef 分别为 int 类型定义了别名整数，为 float 类型定义了别名小数，以及为结构体类型定义了别名日期。这样，我们可以直接使用这些别名来声明变量，并使用它们的更具描述性的名称。

typedef 还可以对指针类型进行别名定义，例如：

typedef int* 整数指针;
这样，整数指针就成为 int* 类型的别名。

使用 typedef 可以提高代码的可读性，使数据类型的含义更加明确，降低阅读和理解代码的难度。

2，案例
#include<stdio.h>

typedef struct
{
int num;
char name[32];
int age;

}person,*pperson; //*pperson 是指针变量

void print(person p)
{
printf("号数: %d 姓名：%s 年龄：%d\n",p.num,p.name,p.age);
//printf("号数: %d 姓名：%s 年龄：%d\n",p.num,p.name,p.age);

}
void print1(pperson p) //这里p是指针变量 pperson 是我们人为定义的结构体指针变量类型
{
printf("号数: %d 姓名：%s 年龄：%d\n",p->num,p->name,p->age);
}

int main()
{
person p1 = {1,"简佳人儿",23};
person p2 = {2,"肥嘟嘟",19};

pperson pp1 = &p1;
pperson pp2 = &p2;

print(p1);
print(p2);
print1(pp1);
print1(pp2);



return 0;
}
结构体类型之间不能直接进行比较操作。因此，在比较两个结构体类型的对象时，编译器会报错。

如果你需要比较两个结构体对象的某个字段的值，则可以使用该字段的具体值进行比较。比如，假设 struct Xuanmin 中有一个字段 score，你希望比较两个结构体对象的 score 字段的值大小，可以通过 ikun[i].score 和 max.score 来获取这两个对象的 score 值，然后进行比较。

#include <stdio.h>

struct Xuanmin {
int score;
};

int main() {
struct Xuanmin ikun[3] = { {80}, {90}, {70} };
struct Xuanmin max = {0};
int i;

for (i = 0; i < 3; i++) {
if (ikun[i].score > max.score) {
max = ikun[i];
}
}

printf("Max score: %d\n", max.score);

return 0;
}
在上述示例中，我们通过比较 ikun[i].score 和 max.score 的值来找到最高分数的结构体对象。

a3.6_switch_case.c: In function 'main': a3.6_switch_case.c:28:2: error: too few arguments to function 'gets' gets(); ^~~~ In file included from a3.6_switch_case.c:1: C:/MinGW64/x86_64-w64-mingw32/include/stdio.h:658:17: note: declared here char *cdecl gets(char *_Buffer) MINGW_ATTRIB_DEPRECATED_SEC_WARN;

需要修复这个问题，你可以在调用 ‘gets’ 函数时传入一个字符数组作为参数，用于接收输入的字符串。例如：

希望这些信息对你有所帮助！如果有任何其他问题，请随时提问。

2023-07-25 10:36

F:\AIOT\IOT\a_1_C语言基础\第三章流程控制>gcc a3.7_switch_case_xueshengchengji.c a3.7_switch_case_xueshengchengji.c: In function 'main': a3.7_switch_case_xueshengchengji.c:25:12: error: expected ';' before ':' token case 0:~6:;

根据提供的错误信息，可以看到在你的代码文件 “a3.7_switch_case_xueshengchengji.c” 的第25行中，出现了语法错误。错误提示显示在 ‘case’ 语句块的冒号 “:” 之前缺少了一个分号 “;”。

在 switch 语句中，每个 case 后面的语句块结束之前需要加上分号。请检查你的代码，查找并修复这个错误。

正确示例：

case 0:
case 1:
// 执行语句块
break;
错误示例（缺少分号）：

case 0: // 错误：缺少分号
case 1:
// 执行语句块
break;
希望这个解答对你有所帮助！如有任何其他问题，请随时提问。

2023-07-25 14:44

t--和--t的区别

“t–” 和 “–t” 都是 C 语言中的操作符，用于对变量进行自减操作。它们的区别在于它们的执行时机和返回值：

“t–”（后置自减操作符）：先使用变量 t 的当前值，然后再将 t 的值减 1。

执行时机：t-- 是在当前语句执行完之后再进行自减操作。

返回值：t-- 的返回值是变量 t 自减前的值。

示例代码：

int t = 5;
int result1 = t--; // result1 的值为 5，然后 t 的值变为 4
“–t”（前置自减操作符）：先将 t 的值减 1，然后再使用变量 t 的新值。

执行时机：–t 是在当前语句执行之前就进行自减操作。

返回值：–t 的返回值是变量 t 自减后的值。

示例代码：

int t = 5;
int result2 = --t; // t 的值先减为 4，然后 result2 的值为 4
总结：

如果你希望先使用变量的值再进行自减操作，可以使用后置自减操作符 “t–”。

如果你希望先进行自减操作再使用变量的值，可以使用前置自减操作符 “–t”。

需要注意的是，无论是 “t–” 还是 “–t” 都会改变变量 t 的值。因此，在使用时请根据具体需求选择合适的自减操作符。

希望这个解答对你有所帮助！如果还有其他问题，请随时提问。

2023-07-25 15:35

a3.13_for1.c: In function 'main': a3.13_for1.c:15:8: warning: passing argument 1 of 'puts' makes pointer from integer without a cast [-Wint-conversion] puts('a'); ^~~ In file included from a3.13_for1.c:1: C:/MinGW64/x86_64-w64-mingw32/include/stdio.h:672:32: note: expected 'const char *' but argument is of type 'int' int _cdecl puts(const char *Str);

根据提供的错误信息，可以看到在你的代码文件 “a3.13_for1.c” 的第15行中，调用了函数 ‘puts’，但是传入的参数是一个字符常量 ‘a’，而不是一个字符串。

‘puts’ 函数的参数类型应该是一个指向字符的指针，即字符串。而单引号括起来的 ‘a’ 表示一个字符，而不是字符串。

要修复这个问题，你需要将参数传递为字符串，即将参数用双引号括起来。示例代码如下：

puts("a");
这样就将字符常量 ‘a’ 转换为了字符串 “a”，然后作为参数传递给了 ‘puts’ 函数。

希望这个解答对你有所帮助！如果还有其他问题，请随时提问。

2023-07-25 16:26

最大公约数

求两个数的最大公约数有多种方法，其中常见的有辗转相除法和欧几里得算法（辗转相减法）两种。

辗转相除法（也称为欧几里得算法）：

基本思想：假设两个数为 a 和 b，通过反复用较小数去除较大数取余，直到余数为 0，则最后一个非零余数即为最大公约数。

具体步骤：

将 a 除以 b，得到余数 r1。

将 b 除以 r1，得到余数 r2。

后续继续将 r1 除以 r2，如此反复，直到余数 ri 为 0。

最后一个非零余数 ri-1 即为最大公约数。

示例代码如下：

int gcd(int a, int b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
辗转相减法：

基本思想：假设两个数为 a 和 b，通过反复用较大数减去较小数，直到两个数相等或其中一个数为 0，则最后一个非零数即为最大公约数。

具体步骤：

如果 a 等于 b，则 a 为最大公约数。

如果 a 大于 b，则 a 减去 b，得到差值 c，再次使用 c 和 b 进行比较。

如果 b 大于 a，则 b 减去 a，得到差值 c，再次使用 c 和 a 进行比较。

如此反复，直到两个数相等或其中一个数为 0。

最后一个非零数即为最大公约数。

示例代码如下：

int gcd(int a, int b) {
while (a != b) {
if (a > b) {
a -= b;
} else {
b -= a;
}
}
return a;
}
可以根据需要选择其中一种方法来求解最大公约数。这些示例代码中的函数 gcd(a, b) 接受两个整数参数 a 和 b，并返回它们的最大公约数。

希望这个解答对你有所帮助！如果还有其他问题，请随时提问。

2023-07-25 17:21

size_t

size_t 是C语言中的一个数据类型，它用于表示内存大小或对象的大小。它是无符号整数类型，通常是一个无符号整数的别名。

在C标准库中，很多函数的参数或返回值的类型使用了 size_t，例如 strlen 函数的返回值类型就是 size_t。

size_t 的大小在不同的平台上可能会有所不同，但通常它是足够大以容纳任何对象的大小。它是一种机器相关的类型，在 32位系统上一般是 32位，在 64位系统上一般是 64位。

使用 size_t 类型的一个常见用法是在内存分配函数（如 malloc、realloc、calloc）中指定分配的字节数。此外，它还可以用于循环计数器以及表示数组的索引等场景。

下面是一个使用 size_t 的示例：

#include <stdio.h>

int main() {
size_t n = 10;
size_t i;

for (i = 0; i < n; i++) {
printf("%zu\n", i);
}

return 0;
}
在打印循环计数器的时候，使用 %zu 格式说明符来输出 size_t 类型的值。

希望这个解答对你有所帮助！如果还有其他问题，请随时提问。

2023-08-01 11:08

size_t源码

size_t 是 C 语言的标准库类型，通常由编译器提供。它的具体实现可以在编译器的头文件中找到。

size_t 的定义通常位于 <stddef.h> 头文件中，该头文件中还定义了其他与大小相关的类型和宏。

以下是一个 stddef.h 头文件中可能包含的 size_t 的简化示例定义：

#ifndef _SIZE_T
#define _SIZE_T

typedef /*implementation-defined*/ size_t;

#endif /* _SIZE_T */
具体的实现细节可以因编译器而异。在不同的平台和编译器上，size_t 的具体定义可能存在差异。在上述示例中，size_t 被定义为一个 implementation-defined 的类型。具体来说，它可能是 unsigned int、unsigned long、unsigned long long 等。

使用特定的编译器来编译代码时，可以查看其相应的标准库头文件，以了解 size_t 的实际定义。例如，在使用 GCC 编译器的情况下，可以查看 /usr/include/stddef.h 文件。

需要注意的是，虽然可以查看 size_t 的实现，但为了编写可移植的代码，应该始终使用标准库头文件 stddef.h 中定义的 size_t，而不是直接依赖于具体实现。

希望这能回答你的问题！如果还有其他问题，请随时提问。

2023-08-01 11:09

0取反得到什么

在计算机中，对整数进行取反操作是一种按位操作，通常使用位求反（bitwise NOT）运算符进行。

当一个整数进行位求反运算时，将会对其所有位进行取反操作，即将所有二进制位的0变为1，将所有二进制位的1变为0。

例如，对于二进制数 0000 0000，也就是十进制数 0，进行位求反运算后，结果为 1111 1111，也就是十进制数 -1。

需要注意的是，位求反运算会根据数据类型的大小仅对有效的位进行操作。例如，对于32位整数，位求反运算只会对前32位进行取反，如果有更高位的话，不会受到影响。

请记住，对于有符号整数，取反操作将会得到其按位取反后的结果，而不是取负数的操作。如果要得到一个有符号整数的相反数，应使用负号（取负）运算符。

希望这个解答对你有所帮助！如果还有其他问题，请随时提问。

2023-08-01 19:17

a_8.1_jiegoutichushi.c: In function 'main': a_8.1_jiegoutichushi.c:19:12: error: assignment to expression with array type stu1.name = "ikun";

根据你提供的错误信息，请注意在C语言中，数组是一种特殊的数据类型，无法直接使用赋值操作符将一个字符串赋值给一个数组。出现错误的原因是你尝试将一个字符串赋值给 stu1.name 这个数组。

如果你想给一个数组赋值，可以使用字符串拷贝函数 strcpy 或字符串赋值函数 strncpy 来完成。这两个函数可以将一个字符串复制到数组中。

示例代码如下：

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

struct Student {
char name[20];
int age;
};

int main() {
struct Student stu1;

// 使用 strcpy 函数将字符串赋值给数组
strcpy(stu1.name, "ikun");
stu1.age = 18;

printf("Name: %s\n", stu1.name);
printf("Age: %d\n", stu1.age);

return 0;
}
在上述示例中，我们使用 strcpy 函数将字符串 “ikun” 复制到 stu1.name 数组中。这样就可以给数组赋值了。

当然，要确保目标数组有足够的空间来容纳要复制的字符串，以免发生内存溢出的情况。在使用字符串拷贝函数时应当特别注意。

希望这个解答对你有所帮助！如果还有其他问题，请随时提问。

2023-08-01 19:59

a_8.3_struct_array_xuanpiao.c: In function 'main': a_8.3_struct_array_xuanpiao.c:54:9: error: invalid operands to binary < (have 'struct Xuanmin' and 'struct Xuanmin') if(max<ikun[i])

根据你提供的错误信息，请注意在C语言中，结构体类型之间不能直接进行比较操作。因此，在比较两个结构体类型的对象时，编译器会报错。

示例代码如下：

请根据你的实际需求，选择要比较的字段，并进行相应的更改。

希望这个解答对你有所帮助！如果还有其他问题，请随时提问。

2023-08-02 09:51

a_8.4_struct_pointer.c: In function 'main': a_8.4_struct_pointer.c:13:11: error: assignment to expression with array type ps->name ="蔡徐坤";

根据你提供的错误信息，请注意在C语言中，数组是一种特殊的数据类型，无法直接使用赋值操作符将一个字符串赋值给一个数组。出现错误的原因是你尝试将一个字符串赋值给 ps->name 这个数组。

如果你想给一个数组赋值，可以使用字符串拷贝函数 strcpy 或字符串赋值函数 strncpy 来完成。这两个函数可以将一个字符串复制到数组中。

示例代码如下：

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

struct Student {
char name[20];
int age;
};

int main() {
struct Student s;
struct Student *ps;

ps = &s;

strcpy(ps->name, "蔡徐坤");
ps->age = 18;

printf("Name: %s\n", ps->name);
printf("Age: %d\n", ps->age);

return 0;
}
在上述示例中，我们使用 strcpy 函数将字符串 “蔡徐坤” 复制到 ps->name 数组中。这样就可以给结构体中的数组字段赋值了。

当然，要确保目标数组有足够的空间来容纳要复制的字符串，以免发生内存溢出的情况。在使用字符串拷贝函数时应当特别注意。

希望这个解答对你有所帮助！如果还有其他问题，请随时提问。

2023-08-02 10:26

a_8.11_struct_union.c:22:21: note: (near initialization for 'u1') a_8.11_struct_union.c:22:25: warning: excess elements in union initializer union TestU u1= {2,'d',9.3};

根据你提供的警告信息，请注意在C语言中，联合（union）是一种特殊的数据类型，它只能存储其中一个成员的值。在初始化联合时，只能为其中一个成员赋值。

发生警告的原因是你在初始化联合时给了多余的元素。在你的代码中，联合 u1 的定义如下：

union TestU u1 = {2, 'd', 9.3};
根据警告信息，联合 u1 包含了超过一个成员的初始化值。联合只能存储一个成员的值，因此，应该只使用一项初始化值。

你可以根据需要选择给联合的一个成员赋值，如下所示：

union TestU {
int num;
char character;
float decimal;
};

int main() {
union TestU u1 = {2}; // 给联合的整型成员赋值

// 其他代码...

return 0;
}
在上面的示例中，我们给联合 u1 的整型成员 num 赋值为2。这样，联合 u1 就只有一个成员的初始化值，不会出现警告。

需要注意的是，在使用联合时需谨慎，确保正确地访问和操作联合的成员。

希望这个解答对你有所帮助！如果还有其他问题，请随时提问。

2023-08-02 16:24

联合体的作用

联合体（union）是C语言中的一种特殊数据类型，它允许在同一内存位置存储不同类型的成员变量。联合体的大小等于其最大成员的大小。

联合体的主要作用是节省内存空间。通过使用联合体，可以在相同的内存位置上存储不同类型的数据，从而避免为每种类型分配独立的内存空间。

除了节省内存外，联合体还可以用于以下几个方面：

存储不同类型的数据：联合体允许在不同时间存储不同类型的数据。你可以根据需要在联合体中使用一个成员，而其他成员则被忽略。

数据类型的转换：联合体可以用于进行类型转换。通过在不同类型的成员之间进行赋值，可以将数据从一种类型转换为另一种类型。

给成员起别名：联合体可以为不同的成员变量提供相同的内存位置，这样可以为这些成员变量起不同的别名，方便访问。

希望这个解答对你有所帮助！如果还有其他问题，请随时提问。

2023-08-02 19:44

枚举类型的定义

枚举类型的定义格式如下：

enum 枚举类型名 {
枚举常量1,
枚举常量2,
...
};
其中，枚举类型名是你为枚举类型起的名字，可以根据需要自定义。

在枚举类型的定义中，你可以列出多个枚举常量，每个枚举常量用逗号分隔。枚举常量通常是大写字母命名，以表示它们是常量。

以下是一个示例，展示如何定义一个表示颜色的枚举类型：

输出结果为：

你也可以在定义枚举时为每个枚举常量指定特定的值，如：

enum Month {
JAN = 1,
FEB = 2,
MAR = 3,
...
};
这样，JAN 的值为1，FEB 的值为2，以此类推。

希望这个解答对你有所帮助！如果还有其他问题，请随时提问。

2023-08-02 20:53

typedef 的定义作用

在C语言中，typedef 关键字用于为已有的数据类型起一个新的名字。它提供了一种简化和增强代码可读性的方式，使数据类型的定义更加清晰和易于理解。

typedef 的定义格式如下：

以下是一些 typedef 的使用示例：

typedef 还可以对指针类型进行别名定义，例如：

typedef int* 整数指针;
这样，整数指针就成为 int* 类型的别名。

使用 typedef 可以提高代码的可读性，使数据类型的含义更加明确，降低阅读和理解代码的难度。

希望这个解答对你有所帮助！如果还有其他问题，请随时提问。

2023-08-02 21:24

a_8.7_struct_puinter3_hanshu.c: In function 'printArr': a_8.7_struct_puinter3_hanshu.c:58:48: error: subscripted value is neither array nor pointer nor vector printf("候选人姓名： %s 候选人票数：%d",arr[i].name,arr[i].tickets);

根据你提供的错误信息，编译错误发生在函数 printArr 中的 printf 语句。错误提示说，订阅的值既不是数组、指针，也不是向量。

问题在于你使用了 . 运算符来访问结构体数组 arr 中的成员变量。然而，结构体数组应使用索引操作符 [] 来访问特定的元素。

要解决这个错误，你需要将 . 运算符改为 [] 索引操作符，代码如下所示：

printf("候选人姓名： %s 候选人票数：%d", arr[i].name, arr[i].tickets);
通过使用 [] 索引操作符，你可以正确地访问结构体数组中特定索引位置的结构体，并访问其成员变量。

希望这个解答对你有所帮助！如果还有其他问题，请随时提问。

a_8.6.1_struct_pointer.c: In function 'main': a_8.6.1_struct_pointer.c:13:10: error: assignment to expression with array type s1.name = "坤坤";

根据你提供的错误信息，编译错误发生在 main 函数中的第 13 行。错误提示说，你尝试将一个表达式赋值给一个数组类型的表达式。

问题在于你尝试将字符串常量赋值给结构体 s1 的 name 成员，但是 name 成员是一个数组类型，不能直接进行赋值操作。

要解决这个错误，你可以使用字符串拷贝函数 strcpy 来将字符串常量赋值给结构体 s1 的 name 成员。需要确保结构体 s1 的 name 成员数组足够大以容纳字符串常量。

以下是一个修改后的示例：

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

struct Student {
char name[20];
int age;
float gpa;
};

int main() {
struct Student s1;

strcpy(s1.name, "坤坤");
s1.age = 20;
s1.gpa = 3.8;

printf("姓名：%s\n", s1.name);
printf("年龄：%d\n", s1.age);
printf("GPA：%f\n", s1.gpa);

return 0;
}
在上述示例中，我们引入了头文件 <string.h>，并使用 strcpy 函数将字符串常量 "坤坤" 复制到结构体 s1 的 name 成员中。

使用字符串拷贝函数 strcpy 可以安全地将字符串复制到结构体数组中，确保不会发生缓冲区溢出等问题。

希望这个解答对你有所帮助！如果还有其他问题，请随时提问。

a_8.6.2_struct_pointer_app.c: In function 'main': a_8.6.2_struct_pointer_app.c:29:10: warning: passing argument 1 of 'memset' makes pointer from integer without a cast [-Wint-conversion] memset(tmpName,'\0',sizeof(tmpName));

根据你提供的警告信息，警告发生在 main 函数中的第 29 行。警告说，你将整数类型的值作为指针传递给了 memset 函数。

问题在于 tmpName 是一个字符数组，而 memset 函数需要使用指针作为第一个参数，以指定要设置的内存块的起始地址。然而，你传递给 memset 函数的 tmpName 是一个数组名，当作为参数传递时，会隐式地转换为指向数组首元素的指针，所以产生了警告。

要解决这个警告，你可以使用数组的地址（即数组名前加上 & 符号）作为 memset 函数的第一个参数。

以下是一个修改后的示例：

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

struct Student {
char name[20];
int age;
float gpa;
};

int main() {
struct Student s1;

char tmpName[20];
strcpy(tmpName, "坤坤");
memset(&tmpName, '\0', sizeof(tmpName));

printf("姓名：%s\n", s1.name);
printf("年龄：%d\n", s1.age);
printf("GPA：%f\n", s1.gpa);

return 0;
}
在上述示例中，我们首先定义了一个临时的字符数组 tmpName，并使用 strcpy 函数将字符串常量 "坤坤" 复制到 tmpName 中。然后，我们使用 memset 函数来将 tmpName 数组的内容初始化为全零。注意，在向 memset 函数传递 tmpName 的地址时，我们使用了 & 符号来获取数组的地址。

这样，我们可以避免警告，并正确地使用 memset 函数对数组进行内存初始化。

希望这个解答对你有所帮助！如果还有其他问题，请随时提问。

a_8.7_struct_pointer5_hanshu.c: In function 'main': a_8.7_struct_pointer5_hanshu.c:78:9: warning: passing argument 1 of 'printf' from incompatible pointer type [-Wincompatible-pointer-types] printf(XM,len);

根据你提供的警告信息，警告发生在 main 函数中的第 78 行。警告说，你将一个不兼容的指针类型作为参数传递给了 printf 函数的第一个参数。

问题在于在 printf 函数的第一个参数中，你传递了 XM，而 XM 是一个指向字符数组 char XM[20] 的指针。然而，printf 函数期望的第一个参数是一个字符串格式的连续字符序列，而不是一个指针。

要解决这个警告，你应该传递一个格式字符串，而不是指针。你可以使用 %s 占位符来表示字符串，并在 printf 函数的第一个参数中提供格式字符串和需要打印的变量。

以下是一个修改后的示例：

#include <stdio.h>

void printInfo(char *name, int age) {
printf("姓名：%s\n", name);
printf("年龄：%d\n", age);
}

int main() {
char XM[20] = "小明";
int age = 18;

printInfo(XM, age);

return 0;
}
在上述示例中，我们定义了一个函数 printInfo，接受一个字符指针 name 和一个整数 age 作为参数。在 printInfo 函数内部，我们使用 %s 占位符来打印字符串，并使用 %d 占位符来打印整数。

在 main 函数中，我们传递了 XM 字符数组和 age 变量作为参数调用了 printInfo 函数。

这样，我们可以避免警告，并正确地打印字符串和整数变量。

希望这个解答对你有所帮助！如果还有其他问题，请随时提问

cuitlse

关注

17
点赞
踩
7

收藏

觉得还不错? 一键收藏
1
评论
给初学者的c语言

dst ++= src++的时序问题首先：dst= *src 然后：dst++和src++顺序不定,不同的编译器可能顺序不同 ———————————————— 版权声明：本文为CSDN博主「七六伍」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。在不同的平台和编译器上，size_t 的具体定义可能存在差异。———————————————— 版权声明：本文为CSDN博主「桦秋静」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
复制链接

扫一扫