新手学习嵌入式day4(数组）

一丶数组

1.概念：
            具有一定顺序的若干变量的集合

2.定义格式：
                  存储类型 数据类型 数组名[元素个数];
                  int arr[5];
                  数组名：代表数组的首地址，地址常量，不能为左值，不能被赋值 
                  访问元素：数组名[下标]，下标的范围：0 ~ n-1 n：元素个数
                  arr[0]：访问第一个元素
                  arr[3]：访问第四个元素
                  注意不要越界，数组越界可能不会报错，需要自己注意

3.特点： 
             数据类型相同，元素的数据类型要和数组的数据类型一致
             内存连续

4.注意：
           （1）.标的范围：0 ~ n-1
           （2）.数组名命名需要符合标识符的命名规
           （3)  .在同一个函数中，数组名不能与其他变量名相同
5.分类：
           一维数组，二维数组，多维数组

二丶一维数组

1.定义格式
                  存储类型 数据类型 数组名[元素个数];
                  int arr[5];
                  数组名：代表数组的首地址，地址常量，不能为左值，不能被赋值 
                  访问元素：数组名[下标]，下标的范围：0 ~ n-1 n：元素个数
                  arr[0]：访问第一个元素
                  arr[3]：访问第四个元素
                  注意不要越界，数组越界可能不会报错，需要自己注意

2. 初始化
  (1).全部初始化：
                         int a[5] = {1, 2, 3, 4, 5}; // 1 2 3 4 5

 （2）.未初始化：
                          int a[3]; //随机值
                          a[0]=1；
                          a[1]=2;
                          a[2]=3;

（3）.部分初始化：
                          int a[5] = {1, 2, 3}; // 1 2 3 0 0，未被初始化的值为0

3.引用
        （1）.  必须先定义数组后引用
        （2）.   每次只能引用一个数组元素，若想要引用所有的元素需要循环遍历
        （3）. 引用数组元素防止越界，越界是危险的，虽然编译器有时不会报错
        （4）.  打印数组元素地址用格式："%p"

4.遍历数组
          将循环变量作为下标，循环遍历数组

#include<stdio.h>
int main(int argc,char *argv())
{
	int arr[5]={1,2,3,4,5};
	for(int a=0;a<5;a++)
	printf("%d\n",arr[a]);
	return 0;
}

5.数组大小

          （1）.sizeof(数组名);
          （2）.数据类型的大小 * 元素个数;

三丶清零函数

1.bzero

           #include <strings.h>
           void bzero(void *s, size_t n);
           功能：将数组的内存空间设置为0
           参数：s：要清空的数组的首地址
           n：数组的大小（字节）
           返回值：无
2.memset

             #include <string.h>
             void *memset(void *s, int c, size_t n);
             功能：将数组的内存空间设置为某一个值
             参数：s：要清空的数组的首地址
             c：你要设置的值
             n：数组的大小（字节）
            返回值：清空的数组的首地址

四丶字符数组

1.形式
          (1)  char a[] = {'a', 'b', 'c'}; // 逐个字符赋值
          (2)  char b[] = "hello"; // 字符串常量赋值 sizeof(b) = 6
          (3)  char c[] = {"hello"}; // 字符串常量赋值 sizeof(c) = 6
          注意：字符串赋初值时经常省略数组的长度，以后面实际赋值为准,要注意数组越界问题

2.输入输出
     输入：（1)  char buf[32] = {};
                  scanf("%s", buf); // 从终端输入字符串到数组buf。但是遇到空格或者\n会结束
                   如果想要包含空格就 sacnf("%[^\n]", buf); // 直到遇到\n结束
                  （2)  gets
                          char *gets(char *s);
                         功能：从终端获取字符串
                         参数：目标字符串的首地址
                         返回值：目标字符串的首地址
                         注意：谨慎使用、使用时会保警告，不检查数组越界

     输出：（1)  printf("%s\n", buf); // 遇到 \0 就会结束

           （2)  puts
                    int puts(const char *s)
                    功能：向终端输出字符串
                    参数：s：要输出字符串的首地址
                    返回值：输出字符的个数

3.计算字符串的实际长度
             （1）for循环遍历，找到 \0 的位置
            （ 2）strlen函数，求字符串的实际长度，不包含\0

4.sizeof和strlen的区别​​​​​​
             （1）.  sizeof是关键字；strlen是函数
             （2）.  sizeof计算数据所占空间字节大小；stelen计算字符串的实际个数
             （3）.  在元素个数省略的情况下，sizeof包括\0，strlen不包括 \0，在这情况下计算字符串长度sizeof比strlen大1

五丶二维数组

1.格式：
           存储类型 数据类型 数组名[行数][列数];
           int a[2][3];

2.访问元素：
            数组名[行下标][列下标] (下标范围，0 ~ 行数-1 0 ~ 列数-1)
            a[0][0]：第一行第一列的元素
            a[1][2]：第二行第三列的元素
            注意：行数可以省略，但是列数不能省略,如 int a[][3];
           二维数组元素个数 = 行数 * 列数

3.数组名
          a：表示第一行的首地址
         a+1：表示第二行的首地址

4.初始化

（1)  全部初始化：
               int a[2][3] = {1, 2, 3, 4, 5, 6}; // 1 2 3 4 5 6 顺序赋值
               int a[2][3] = {{1, 2, 3},{4, 5, 6}}; // 1 2 3 4 5 6 按行赋值
（2)  部分初始化：
              int a[2][3] = {1, 2, 3, 4}; // 1 2 3 4 0 0
              int a[2][3] = {{1, 2}, {4, 5}}; // 1 2 0 4 5 0
（3)  未初始化：
              int a[2][3]; // 随机数，需要单独赋值

5.内存分配
          a：第一行的首地址
         a[0]：第一行第一列的地址
         a+1：第二行的首地址
         a[1]：第二行第一列的地址

6.计算大小
         sizeof(数组名); == 数据类型大小 * 行数 * 列数;

7.遍历二维数组

         for循环嵌套，外层循环变量表示行下标，内层循环变量表示列下标

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int arr[2][3] = {1, 2, 3, 4, 5, 6};
    for (int m = 0; m < 2; m++)
    {
        for (int n = 0; n < 3; n++)
        {
            printf("%d ", arr[m][n]);
        }
        printf("\n");
    }
    return 0;
}