C语言:二维数组和字符数组

二维数组

定义

二维数组本质上是一个行列式组合,也就是说二维数组是由行和列两部分组成,属于多维数组。二维数组通过行和列解读(先行后列)

二维数组可被视为一个特殊的一维数组,也就是说,当一个数组中的每一个元素是一位数组的时候,那么这个数组就是二维数组。

语法
 数据类型 数组名[行容量][列容量];  

行容量:外层数组的数组容量

列容量:内存数组的数组容量

说明
  • 二维数组在初始化的时候,可以省略行数,系统会通过初始化后的数据自动推断行数。

  • 二维数组和一位数组一样,也可以部分初始化,未初始化的元素使用0

  • 二维数组在初始化的时候,不能省略列数,否则编译报错。

举例
 
int arr[3][3] = {{11,12,13},{21,22,23},{31,32,33}};   // 正确,等价于下面写法
 int arr[][3]  = {{11,12,13},{21,22,23},{31,32,33}};   // 正确,二维数组初始化的时候可以省略行容量,推荐
 ​
 int arr[3][3] = {{11,12},{21,22,23},{31}};            // 正确,可以未初始化部分补0,等价于下面写法
 int arr[3][3] = {{11,12,0},{21,22,23},{31,0,0}};      // 正确,支持部分初始化
 ​
 int arr[3][3] = {0};                                  // 正确,所有位置使用0补齐,推荐
 int arr[3][3] = {};                                   // 正确,所有位置使用0补齐
 int arr[3][3] = {11};                                 // 正确,除了0行0列是11外,其他都用0补齐
 ​
 int arr[][] = {{11,12,13},{21,22,23},{31,32,33}};     // 错误,编译报错,不能省略列容量
 int arr[3][] = {{11,12,13},{21,22,23},{31,32,33}};    // 错误,编译报错,不能省略列容量
 ​
 int arr[][3]  = {11,12,13,21,22,23,31,32,33};         // 正确,{}中不一定要嵌套
 int arr[][3]  = {11,12,13,21};                        // 正确,{}中不一定要嵌套
 ​

注意:在C语言中,二维数组在计算机的存储顺序是按行进行的,即第一维(行)下标变化慢,第二维的(列)下标变化快。

内存存储

注意:地址这里只是为了区分,实际的地址表示为十六进制。

应用场合

主要是应用对行列有要求的情况。比如说我们现在要存储西安粤嵌所有在班学生的成绩。

还有就是字符数组的应用,比如用数组存储学生的姓名。

double scores[35] = {..}; 一维数组初始化,存放1个班所有学生的成绩

double scores[5][40] = {{..}..} 二维数组初始化,存放5个班的学生成绩,每个班最多40人。

double scores[6][10][40] = {{{..}..}..} 三维数组初始化,存放6个校区、每校区最多10各班,每班最多40人。

特殊写法
  • 下标可以是整型表达式。如:a[2-1][2*2-1] a[1][3]

  • 下标可以是已经有值的变量或者数组元素。如:a[2*x-1][b[3][1]] []中最终需要的是一个>0的整数。

  • 数组元素可以出现在表达式中。如:b[1][2] = a[2][3]/2

  • 演示:

    数组:arr列-0列-1列-2举例说明
    行-0111213arr[0][1]数组arr的0行1列对应的元素
    行-1212223arr[1][2]数组arr的1行2列对应的元素

注意:使用数组元素的下标应在已定义数组的大小范围内;应注意区别定义数组大小和引用数组元素的区别。

初始化
  • 分行给二维数组赋初值

    int arr[3][4] = {{11,12,13,14},{21,22,23,24},{31,32,33,34}};
  • 可将所有数据写在一个{}内,按照排列顺序对运算赋值

     int arr[3][4] = {11,12,13,14,21,22,23,24,31,32,33,34};
  • 可对部分元素赋初值,其余未初始化部分自动填充0

     int arr[3][4] = {{11},{21,22},{31,32,33}};
  • 若对全部元素赋初值,自定义数组时可以省略第一维数组容量(行容量),第二维数组容量(列容量)必须指明。

     int arr[][4] = {{11,12,13,14},{21,22,23,24},{31,32,33,34}};
     int arr[][4] = {11,12,13,14,21,22,23,24,31,32,33,34};
  • 在分行赋初值时,也可以省略第1维的长度(行容量)。

     int arr[][4] = {{11,12,13},{0},{0,10}};
案例
案例1
  • 需求:二维数组的遍历

  • 分析:

    • 二维数组本质上属于行列式,遍历的时候需要借助于嵌套的for循环,外层for负责行的遍历,内层for负责列的遍历。

    • 取值:

       数组名[行容量][列容量];
    • 赋值:

       数组名[行下标][列下标] = 值;
    • 行和列的大小计算:

       // 计算行的大小
       int row_length = sizeof(数组名) / sizeof(数组名[行下标0]);
       // 计算列的大小(每一行的列数是相同)
       int col_length = sizeof(数组名[行下标0]) / sizeof(数组名[行下标0][列下标0]);
  • 代码:

     
    
    /*************************************************************************
       > File Name:    demo01.c
       > Author:       三道渊
       > Description:  
       > Created Time: 2025年07月18日 星期五 11时11分09秒
      ************************************************************************/
     ​
     #include <stdio.h>
     ​
     int main(int argc,char *argv[])
     {
         // 创建一个二维数组
         int arr[][3] = {{11},{21,22},{31,32,33}};
     ​
         // 获取行和列的大小
         int row_len = sizeof(arr) / sizeof(arr[0]);// 外层数组大小
         int col_len = sizeof(arr[0]) / sizeof(arr[0][0]);// 内层数组大小,因为每个内层数组大小一致,所以计算第一个就可以了
     ​
         // 遍历数组
         // 外层循环:遍历行
         for (int i = 0; i < row_len; i++)
         {
             // 内层循环:遍历列
             for (int j = 0; j < col_len; j++)
             {
                 // 输出元素
                 printf("%-4d", arr[i][j]);
             }
         }
         printf("\n");
     ​
         return 0;
     }
    
    
  • 运行结果:

案例2
  • 需求:矩阵的转置

  • 分析:

    • 所谓的转置,就是原本的列变行,行变列。

  • 代码:

     /*************************************************************************
       > File Name:    demo02.c
       > Author:       三道渊
       > Description:  
       > Created Time: 2025年07月18日 星期五 11时35分36秒
      ************************************************************************/
     ​
     #include <stdio.h>
     ​
     #define ROW 2
     #define COL 3
     ​
     int main(int argc,char *argv[])
     {
         // 定义循环变量
         int i,j;
     ​
         // 准备2个数组,用来存放转置前后的数列
         int arr_before[ROW][COL] = {11,12,13,21,22,23};
         int arr_after[COL][ROW] = {0};
     ​
         // 计算数组的大小
         int arr_before_row = sizeof(arr_before) / sizeof(arr_before[0]);
         int arr_before_col = sizeof(arr_before[0]) / sizeof(arr_before[0][0]);
         
         int arr_after_row = sizeof(arr_after) / sizeof(arr_after[0]);
         int arr_after_col = sizeof(arr_after[0]) / sizeof(arr_after[0][0]);
     ​
         // 循环遍历二维数组
         printf("\n转置前:\n");
         for (i = 0; i < arr_before_row; i++)
         {
             for (j = 0; j < arr_before_col; j++)
             {
                 // 打印转置前的数据
                 printf("%-4d",arr_before[i][j]);
                 // 转置:行变列,列变行
                 arr_after[j][i] = arr_before[i][j];
             }
             printf("\n");
         }
         printf("\n");
     ​
         printf("转置后:\n");
         for (i = 0; i < arr_after_row; i++)
         {
             for (j = 0; j < arr_after_col; j++)
             {
                 printf("%-4d",arr_after[i][j]);
             }
             printf("\n");
         }
         printf("\n");
     ​
         return 0;
     }
     ​
  • 运行结果:

课堂练习
  • 需求:求一个3行3列的矩阵对角线上的元素之和。

字符数组

在C语言中,支持字符串常量,不支持字符串变量。如果想要实现类似的字符串变量,C语言提供了两种实现方式:

  • 字符数组:

     char name[] = "哪吒";

  • 字符指针:

     char *name = "哪吒";

概念

元素类型为char(字符型)的数组叫做字符数组。字符数组往往是用来存储字符串数据的。需要注意的,我们C语言中的字符是字节字符(1字符 = 1字节,C语言中没有字节这个表示法,我们一般使用char表示字节,1char = 8bit)。

硬件中存放数据以bit(位)为单位,系统对于内存的操作以char(字节)为单位。系统为内存以1个字节为单位进行编号。

实验:



 char a = 'A';      // 正确
 char b = '1';      // 正确 ASCII码:49
 char c = 1;        // 正确 ASCII码:1
 char d = '\n';     // 正确 只要其对应的 ASCII码的范围在0~127之间,都属于字符
 char e = "A";      // 错误 双引号括起来的内容叫做字符串常量
 char f = '冯';     // 错误 中文字符不在0~127这个范围内
语法

一维数组:

 char 数组名[数组容量];

二维数组:

 char 数组名[行容量][列容量];

字符数组的语法就是我们之前所学的一维数组和二维数组的语法,只不过数据类型是char而已。

注意:

如果我们的char数组初始化的时候,没有完全初始化值的时候,使用\0(\0对应的ASCII值是0)进行填充。大家要注意,这里的\0只是起到一个占位或者标识的作用,我们是无法通过printf等打印输出到控制台的(不支持输出)。

比如:

 char c[8] = {'h','e','l','l','o'}; // 一维的字符数组的初始化,未初始化部分补'\0'或者 0 等价于下面写法
 char c[8] = {'h','e','l','l','o','\0','\0','\0'};
案例
案例1
  • 需求:输出一个字符序列(I LOVE YOU)

  • 代码:

     
    
    /*************************************************************************
       > File Name:    demo03.c
       > Author:       三道渊
       > Description:  
       > Created Time: 2025年07月18日 星期五 14时29分35秒
      ************************************************************************/
     ​
     #include <stdio.h>
     ​
     int main(int argc,char *argv[])
     {
         // 创建一个数组,用来存储I LOVE YOU   空格' '也是字符,对应的ASCII 为 32
         char arr[] = {'I',' ','L','O','V','E',32,'Y','O','U'};  
     ​
         // 计算数组的大小
         int len = sizeof(arr) / sizeof(arr[0]);
     ​
         // 遍历数组
         for (int i = 0; i < len; i ++) printf("%c",arr[i]);
     ​
         printf("\n");
     ​
         return 0; 
     }
     ​
案例2
  • 需求:输出一个用字符*组成的空菱形图案。

  • 代码:

     /*************************************************************************
       > File Name:    demo04.c
       > Author:       冯鹏飞
       > Description:  
       > Created Time: 2025年07月18日 星期五 14时40分11秒
      ************************************************************************/
     ​
     #include <stdio.h>
     ​
     int main(int argc,char *argv[])
     {
         // 创建一个二维数组,存放菱形
         char arr[5][5] = {
             {' ',' ','*',' ',' '},
             {' ','*',' ','*',' '},
             {'*',' ',' ',' ','*'},
             {' ','*',' ','*',' '},
             {' ',' ','*',' ',' '}
         };
     ​
         // 计算行和列的大小
         int row_len = sizeof(arr) / sizeof(arr[0]);
         int col_len = sizeof(arr[0]) / sizeof(arr[0][0]);
     ​
         // 遍历数组
         for (int i = 0; i < row_len; i++)
         {
             for (int j = 0; j < col_len; j++) printf("%c",arr[i][j]); printf("\n");
         }
     ​
         printf("\n");
     ​
         return 0;
     }
     ​
注意
  • 如果定义时,不初始化,元素值不确定(局部作用域)

     char arr1[2];   // 此时,这个数组中元素的值是随机值
     char arr2[3] = {'a','b','c'}; // 此时属于部分初始化,未初始化的元素使用 \0 填充
     char arr3[3] = {};  // 此时所有的元素使用 \0 填充
     char arr4[3] = {0}; // 此时所有的元素使用 \0 填充

  • 如果提供的字符个数大于数组长度,则按照语法错误处理(会报警告,但是能编译通过);如果字符个数小于数组长度,后面的元素自动补\0

     char arr1[2] = {'h','e','e'};   // 编译通过,但是会报警告(warning),不建议写,实际存放的是 he
     char arr2[3] = {'a'};           // 正确写法,部分初始化,未初始化部分补 \0

  • 如果提供的字符个数与数组长度相同,可以省略数组长度,系统会自动确定元素的个数,适合字符较多时。

     char arr1[] = {'b','u'}; // 正确,根据初始化元素,由系统自动计算元素个数

字符串结束标志
说明
  • C语言规定,字符串常量以字符\0作为结束标志。

  • 编译系统对字符串常量自动加一个\0作为结束标志。 char *name = "tom",实际存储为{'t','o','m','\0'}

  • 程序中往往通过判断\0来检测字符串是否结束。举例:while(arr[i] != '\0'){..}

  • \0的ASCII码是0,不是一个可显示可输出的字符,是“空操作符”。它什么都不做,不会增加有效字符,仅仅用作一个工程判别的标志或者在数组中占位。

     char a[] = {'h','i'};        // 输出:hi
     char a[] = {'h','i','\0'};   // 输出:hi
     char c[] = "hello";          // 输出:hello,实际存储:hello\0  将字符串常量赋值给字符数组   

字符数组的多样表示

我们的char数组可以以数组的形式一个一个输出每个字符;也可以以字符串的形式整体输出。

  • 演示:

     
    
    /*************************************************************************
       > File Name:    demo05.c
       > Author:       三道渊
       > Description:  
       > Created Time: 2025年07月18日 星期五 15时31分37秒
      ************************************************************************/
     ​
     #include <stdio.h>
     ​
     int main(int argc,char *argv[])
     {
         // 字符串的第1种表示:
         char s1[] = {'h','e','l','l','o',' ','w','o','r','l','d','\0'};// 字符个数:12
         // 字符串的第2种表示:
         char s2[] = {"hello world"};// ""包裹的内容是字符串常量,字符串常量默认末尾有一个\0  字符个数:12
         // 字符串的第3种表示:
         char s3[] = "hello world"; // 字符个数:12
     ​
         // 字符串的第1种输出:
         // 计算字符串所占字节数
         printf("s1=%lu,s2=%lu,s3=%lu\n", sizeof(s1), sizeof(s2), sizeof(s3)); // s1=12,s2=12,s3=12
     ​
         // 计算数组大小
         int len = sizeof(s3) / sizeof(s3[0]);
     ​
         // 遍历
         for (int i = 0; i < len; i++)
         {
             // 过滤\0
             if (s1[i] == 0 || s2[i] == '\0' || s3[i] == 0) continue;
     ​
             printf("%c,%c,%c\n", s1[i], s2[i], s3[i]);
         }
         printf("\n");
     ​
     ​
         // 字符串的第2种输出:
         printf("%s,%s,%s\n",s1,s2,s3);
         printf("\n");
     ​
         return 0;
     }
     ​
注意
  • 字符串的长度与字符数组的长度不一定相同。

      char name[] = "hello";  // 数组长度:6,字符串长度:5

  • 利用字符串常量可以对字符数组进行初始化,但不能用字符串常量对字符数组赋值。

      // 正确演示:利用字符串常量给字符数组初始化
      char arr1[] = "hello";
      
      // 错误演示:利用字符串常量给字符数组赋值
      char arr2[6];
      arr2 = "hello";  // 可以理解为,数组是一个常量

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值