C语言-第四章：数组

数组

一维数组的创建和初始化

数组的创建

数组是一组相同类型元素的集合，数组的创建方式：

type_t arr_name [const_n]
    //type_t 是指数组的元素类型
    //const_n 是一个常量表达式，用来指定数组的大小

int main()
{
    //创建一个数组-存放整型-10个    
    int arr[10];
    return 0;
}

注：数组创建，[]中要给一个常量才可以，不能使用变量

数组的初始化

数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值(初始化)

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

int main()
{
    int arr[10] = { 1,2,3 };  //不完全初始化，剩下的元素默认初始化为0
    char arr2[5] = { 'a','b' };
    char arr3[5] = "ab";  //ok,放三个，第三个是\0，后两个是0，其实3个
    char arr3[5] = { 'a',98 };
    char arr4[] = "abcdef"; // 实际放了7个

    printf("%d\n", sizeof(arr4));//7
    //sizeof计算arr4所占空间大小
    //7个元素-char 7*1=7

    printf("%d\n", strlen(arr4));//6
    //strlen 求字符串长度
    //[a b c d e f \n],strlen求的是\0之前的字符个数


}

strlen和sizeof

• 没有什么关联

• strlen是求字符串长度的-只能针对字符串求长度-库函数-使用引用头文件

• sizeof计算变量，数组，类型的大小-单位是字节-操作符

  #include <stdio.h>
  #include<string.h> 
  int main()
  {
      char arr1[] = "abc";
      char arr2[] = { 'a','b','c' };
      printf("%d\n", sizeof(arr1));//4(a b c \0)
      printf("%d\n", sizeof(arr2));//3(a b c)
      printf("%d\n", strlen(arr1));//3
      printf("%d\n", strlen(arr2));//15随机值,c后面不知道，找\0不知道在哪里，所以是随机值
  
      return 0;
  }
  
  

根据数组下标打印元素

• 打印d

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

int main()
{
    char arr[] = "abcdef";  //[a] [b] [c] [d] [e] [f] [\0]
    printf("%c\n", arr[3]);
    return 0;
}

//输出d

• 打印abcdef

  #include <stdio.h>
  #include<string.h> 
  
  int main()
  {
      char arr[] = "abcdef";  //[a] [b] [c] [d] [e] [f] [\0]
     /* printf("%c\n", arr[3]);*/
      int i = 0; 
      for (i = 0; i < 6; i++)    //i<(int)strlen(arr)，strlen默认返回无符号整型
      {
          printf("%c ", arr[i]);
      }
      return 0;
  }
  

[]下标引用操作符

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

int main()
{
    int arr[] = { 1,2,3,4,5,6,7,8,9,0 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

总结

• 数组是使用下标来访问的，下标是从0开始的
• 数组的大小可以通过计算得到

一维数组在内存中的存储

打印地址

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

int main()
{
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("&arr[%d]= %p\n",i, &arr[i]);
    }
    return 0;
}

输出：
&arr[0]= 001AFB80
&arr[1]= 001AFB84
&arr[2]= 001AFB88
&arr[3]= 001AFB8C
&arr[4]= 001AFB90
&arr[5]= 001AFB94
&arr[6]= 001AFB98
&arr[7]= 001AFB9C
&arr[8]= 001AFBA0
&arr[9]= 001AFBA4
    
    //上面他们之间都差4，每个元素都是整型，每个元素4个字节，数组也是连续存放的

• 数组在内存中是连续存放的，地址也由低到高连续依次增长

二维数组的创建

二维数组的创建

//数组创建
int arr[3][4];//三行四列
char arr[3][5];
double arr[2][4];

二维数组的初始化

//数组初始化
int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};
列这里不能为空，是不能省略的，行可以省略

二维数组的使用

• 二维数组的使用依然也是通过下标的方式

• 行，列依然是从0开始的

• #include <stdio.h>
  #include<string.h> 
  
  int main()
  {
      int arr[3][4] = { {1,2,3},{4,5} };
      int i = 0;
      for (i = 0; i < 3; i++)
      {
          int j = 0;
          for (j = 0; j < 4; j++)
          {
              printf("%d ", arr[i][j]);
          }
          printf("\n");
      }
      return 0;
  }
  
  //输出：
  1 2 3 0
  4 5 0 0
  0 0 0 0
      依然通过下标来访问
  

二维数组在内存中的存储

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

int main()
{
    int arr[3][4] = { {1,2,3},{4,5} };
    int i = 0;
    for (i = 0; i < 3; i++)
    {
        int j = 0;
        for (j = 0; j < 4; j++)
        {
            printf("&arr[%d][%d] = %p\n",i,j,&arr[i][j]);
        }
       
    }
    return 0;
}

输出：
    &arr[0][0] = 008FFAC0
    &arr[0][1] = 008FFAC4
    &arr[0][2] = 008FFAC8
    &arr[0][3] = 008FFACC
    &arr[1][0] = 008FFAD0
    &arr[1][1] = 008FFAD4
    &arr[1][2] = 008FFAD8
    &arr[1][3] = 008FFADC
    &arr[2][0] = 008FFAE0
    &arr[2][1] = 008FFAE4
    &arr[2][2] = 008FFAE8
    &arr[2][3] = 008FFAEC
    
    二维数组在内存中也是连续存放的，也可以理解为是由一维数组组成的

二维数组的使用

数组作为函数参数

• 冒泡函数

  #include <stdio.h>
  #include<string.h> 
  void bubble_sort(int arr[],int sz)
  {
      //确定冒泡排序的趟数，n个元素，n-1次
      int i = 0;
                        // int sz = sizeof(arr) / sizeof(arr[0]);  //10这里就不能要了
      for (i = 0; i < sz - 1; i++)
      {
          //每一趟冒泡排序
          int j = 0;
          for (j = 0; j < sz-1-i; j++)
          {
              if (arr[j] > arr[j + 1])
              {
                  int tmp = arr[j];
                  arr[j] = arr[j + 1];
                  arr[j + 1] = tmp;
              }
          }
      }
  }
  int main()
  {
      int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
      int i = 0;
      int sz = sizeof(arr) / sizeof(arr[0]);
      //对arr进行排序，排成升序
      //arr是数组，我们对arr进行传参，实际上传递过去的是数组arr首元素的地址 &arr[0]
      bubble_sort(arr,sz);  //冒泡排序函数   //所以在这把sz传进去
      for (i = 0; i < sz; i++)
      {
          printf("%d ", arr[i]);
      }
      return 0;
  }
  
  

• break语句只用于for和switch，在if语句中不能使用，因为if不是循环语句，所以不能用break来结束

数组名是首元素地址（有两种例外）

例子

#include <stdio.h>
#include<string.h> 
int main()
{
    int arr[] = { 1,2,3,4,5,6,7 };
    printf("%p\n", arr);
    printf("%p\n", &arr[0]);
    printf("%d\n", *arr); //1 说明数组名就是首元素地址
    return 0;
}

//输出：
008FFB44
008FFB44

例外1

#include <stdio.h>
#include<string.h> 
int main()
{
    int arr[] = { 1,2,3,4,5,6,7 };

    int sz = sizeof(arr) / sizeof(arr[0]);
    //1.sizeof[数组名] - 数组名表示整个数组，sizeof（数组名）计算的是整个数组的大小，单位是字节  
    return 0;
}

例外2

#include <stdio.h>
#include<string.h> 
int main()
{
    int arr[] = { 1,2,3,4,5,6,7 };
    printf("%p\n", arr);
    printf("%p\n", &arr[0]);
    printf("%p\n", &arr);  //&arr取出的是数组的地址
   
    return 0;
}

//输出：
005DF840
005DF840
005DF840  第三个这个数组地址

补充

• sizeof （数组名），计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数组
• &数组名，取出的是数组的地址