嵌入式开发第5天(数组)

数组

一维数组

数组：由相同的类型组成，有固定个数，在内存中是连续的一片内存

类型  数组名【数组元素个数】={初值，初值....}   

初值的个数不能超出元素个数范围，可以小于

        类型：除了 bool 其余的类型都可以

int a[5] = {1,2,3,4,5};

int a[5];           //没有初始值，里面存放的是随机值。

int a[5] = {1,2};  --> int a[5]={1,2,0,0,0};//如果只有一个初值，系统会自动将后面的数据清零

   int  a[]= {1,2,3,4,5,6 };  --> int a[6]    //没有写元素个数，系统会自己计算。

int  a[]= {1,2,0,0,[89]=5,4};      //第89是5 ，90是4。2~88 系统默认为0；

int  a[]= {1,2,[89 ... 95]=5,9}    //第89~95 等于5 ，96等于9；    

使用：

下标[]:有效下标范围从0开始，有N个元素，有效下标为N-1

注意： 下标可以越界 ，但越界值非自己所定义的数组 

int a[5]={1}; printf("%d",a[5]) ;   //结果为越界值  

练习：修改数组的值int a={1,2,3,4,5,6,7,8,9,10}改为｛11,12,13，14,15,16,17,18,19,20｝

如何从键盘里面取值


int val;         scanf("%d",&val);


int a[10];       scanf("%d",&a[0]); 


注意：必记
int a[10];
通常：
a是数组名，是第一个元素的地址&a[0]
a ===========等价于===========&a[0];


1、&a表示指向整个数组的地址


int a[5]={1};


a addr    = 0xbfd7232c
a +1      = 0xbfd72330   4        a+1   ==== a+1*4     (4为数据类型大小)
&a[0]+1   = 0xbfd72330   4 &a[0]+1 ==== &a[0]+1*4 (4为数据类型大小)
&a      = 0xbfd7232c   0       &a = a = &a[0];值相等，但是是意义不同 
&a+1      = 0xbfd72340   20   &a+1  === a+4*5   (4代表数据类型大小，5代表元素个数)






char a[5]={1,3,6,9,10};


*(a+3) =   *（&a[0]+3）==a[3]
*a+3   =   a[0]+3



字符数组
char arr[6]="hello";{'h','e','l','l','o','\0'};


char arr[6]={'a','b','c','\0'};%s  %c


练习：
1、 在终端输入10值并存储到数据当中 
找到10个整形数的最大值和最小值，求这两个数之和
先设定一个参考的最大值max和一个参考的最小值min
然后逐个比较，如果有比max大或者比min小的，更改参考值。



2、读取输入，直到遇到字节#才结束，总字符不超过100个
   上报读取到的空格数目、换行符数目、其它字符的总数
   显示输入的整个字符数组

#include<stdio.h>

int main()

{

char c;

char buf[100];

int sum = 0,space=0,enter=0,other=0;

while(1)

{

if(sum < 100)

{

c = getchar();

if(c == '#')

{

break;

}

else

{

buf[sum] = c;

sum++;

}

if(c == ' ')

space++;

else if(c == '\n')

enter++;

else

other++;

}

else 

break;

}

printf("space =%d,enter=%d,other=%d",space,enter,other);

return 0;

}

3、冒泡排序法，将一组数组中的元素进行排序，排序从小到大；



int a[10];


a是数组名，是第一个元素的地址&a[0]；
例如：sizeof(a) 整个数组的大小 


字符数组 ==== 字符串
int arr[50]="sdfea";
sizeof(arr);计算结果为整个数组的长度包括“\0”；


strlen(char *s);  //计算字符串长度,不包括'\0'；




       #include <string.h>


       int strlen(const char *s);

返回值：字符串长度
const char *s：字符串的首地址；


练习：自己编写一个函数，函数实现strlen功能；




int my_strlen(const char *s)
{
int len = 0;
while(*s!='\0')
{
s++;
len++;
}


return len;
}


int main(void)
{
char a[100]="sdsadfsdfjfewsdf";
int main_len;



main_len = my_strlen(a);
printf("main_len = %d\n",main_len);


return 0;
}






函数：
模块化，黑盒子：不需要关心里面是怎么样实现，但是需要知道的输入及输出是什么


1、减少代码的重复编写，直接写一次，可以多次调用
2、函数功能可以写成一个模块，方便删除



函数定义
（函数存储类型）返回参数类型 函数名（参数） 
函数的存储类型： static 
返回参数类型  ：char short int等基本数据类型,或者是地址。需要return;
如果不需要返回值，直接写成void，代码中不需要return;


函数名:
命名规则：下划线或者字母开头，由下划线、字母、数字


参数：可以是参数列表，如果不需要参数，传void
int i,int y


char short int等基本数据类型:


char fun(void)
{
char ch;
....
return ch;
}


地址:
int *fun(const char *s)
{
int *p;
.......
return p;
}


void Delay(int i,int j)
{
int x,y;
for(x=0;x<i;x++)
for(y=0;y<j;y++);
}




void fun(int a,int b)
{
....
....
....


}




int main(int argc,char **argv)


argc    : 参数个数
argv[n] : 参数内容地址


练习：在终输入时选择执行函数的功能，参数为a，计算两个数的和，参数为s，执行两个数相减，参数为f，对数组进行冒泡排序。
#include<stdio.h>
   
int main(int argc,char **argv)
{
int a,b,c,temp,mao[10];

  switch(*argv[1])
{

case 'a': goto add;
case 's': goto sub;
case 'f': goto maopao;

}


add: 
printf("please into two number\n");
scanf("%d %d",&a,&b);
printf("%d+%d=%d\n",a,b,a+b);

return 0;


sub:  
printf("please into two number\n");


scanf("%d %d",&a,&b);
printf("%d-%d=%d\n",a,b,a-b);


return 0;



maopao:


printf("please input ten number\n");


while(b<=9)
scanf("%d",&mao[b++]);


for(c=8;c>=0;c--)
{
for(b=0;b<=c;b++)
{


if(mao[b]<mao[b+1])
{


temp=mao[b];
mao[b]=mao[b+1];
mao[b+1]=temp;

}

}


}
b=10;
while(b>0)
printf("%d ",mao[--b]);

return 0;


}







练习：自己编写代码实现strcmp、strcat；


加强版练习：随机生成6位验证码：实现输入验证，如果三次输入错误，退出程序，正确输出:Helloworld