C语言-数组

C 语言支持数组数据结构，数组是一个由若干相同类型变量组成的有序集合。
这里的有序是指数组元素在内存中的存放方式是有序的，即所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。

在 C 语言中，数组名表示数组的地址，即数组首元素的地址。当我们在声明和定义一个数组时，该数组名就代表着该数组的地址。数组中的元素可以通过索引访问，索引值从 0开始。C 语言还允许我们使用指针来处理数组，这使得对数组的操作更加灵活和高效。按数组元素的类型不同，数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。

一、一维数组

1、定义

（1） 数组定义

基本格式为：dataType arrayName[length];

其中，dataType 为数据类型，arrayName 为数组名，length：为数组长度。

（2）访问数组元素

基本格式为：arrayName[index]

注意：

• 数组中每个元素的数据类型必须相同。
• 数组长度 length 最好是整数或者常量表达式，例如 10、20*4 等。
• 访问数组元素时，下标的取值范围为 0 <= index < length，过大或过小都会导致数组溢出越界异常。

（3）数组内存是连续的

数组是一个整体，它的内存位置是连续的；也就是说，数组元素之间是相互挨着的，彼此之间没有一点点缝隙。

连续的内存为指针操作（通过指针来访问数组元素）和内存处理（整块内存的复制、写入等）提供了便利，这使得数组可以作为缓存（临时存储数据的一块内存）使用。

一般情况下，数组名会转换为数组的地址，需要使用地址的地方，直接使用数组名即可。

2、初始化数组

一维数组的初始化，有 3种方式：

（1）定义数组时直接对数组元素赋初值。数组元素值一般放在一对大括号中。例如：

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

（2）如果只给一部分数组元素赋值，则未赋值的元素默认为被赋值为类型默认值。例如：

int iArray[6] = {1, 2, 3}; // iArray[2] = 3, iArray[3] = 0

（3）当对全部数组元素都赋初值时，可以不指定数组长度。例如：

int iArray[] = {1, 2, 3, 4}; // 长度为4

数组长度可以使用 sizeof 运算符来获取数组的长度。

使用 sizeof 可以获得数据类型或变量在内存中所占的字节数。同样，使用sizeof 也可以获得整个数组在内存中所占的字节数。因为数组中每个元素的类型都是一样的，在内存中所占的字节数都是相同的，所以总的字节数除以一个元素所占的字节数就是数组的长度。

#include <stdio.h>
 
int main() {    
    int iArray1[6] = {1, 2, 3, 4, 5, 6};
	int iArray2[6] = {1, 2, 3};
	int iArray3[] = {1, 2, 3, 4};
	
	printf("iArray1长度：%d\n", sizeof(iArray1) / sizeof(iArray1[0]));
	printf("iArray2长度：%d\n", sizeof(iArray2) / sizeof(iArray2[0]));
	printf("iArray3长度：%d\n", sizeof(iArray3) / sizeof(iArray3[0]));
 
    return 0;
}

3、实例

实例1：

#include <stdio.h>

int main() {
    int iArray[11] = {0};

    printf("请输入手机号：\n");
    for (int index = 0; index < 11; ++index) {
        scanf("%d", &iArray[index]); //输入号码使用空格隔开
    }
    
    printf("你输入手机号为：\n");
    for (int index = 0; index < 11; ++index) {
        printf("%d", iArray[index]);
    }

    return 0;
}

实例2：

#include <stdio.h>
 
int main() {    
    float fArray[5];
	for(int i = 0; i < 5; i++){
		fArray[i] = 1.1 * i;
	}
	
	for(int i = 0; i < 5; i++){
		printf("打印 fArray[%d]：%f \n", i, fArray[i]);
	}
 
    return 0;
}

二、二维数组

多维数组是由多个长度相同的一维数组构成的。主要认识二维数组。

基本格式如下：type name[size1][size2]…[sizeN];

1、定义

（1） 数组定义

基本格式为：dataType arrayName[length1][length2];

其中，dataType 为数据类型，arrayName 为数组名，length1 为行下标的长度，length2 为列下标的长度。

（2）访问数组元素

基本格式为：arrayName[index][index]

（3）数组内存是连续的

二维数组在概念上是二维的，但在内存中是连续存放的；换句话说，二维数组的各个元素是相互挨着的，彼此之间没有缝隙。那么，如何在线性内存中存放二维数组呢？

有两种方式：

• 一种是按行排列， 即放完一行之后再放入第二行；
• 一种是按列排列， 即放完一列之后再放入第二列。

在C语言中，二维数组是按行排列的。 也就是先存放 a[0] 行，再存放 a[1] 行，最后存放 a[2] 行；每行中的 4 个元素也是依次存放。数组 a 为 int 类型，每个元素占用 4 个字节，整个数组共占用 4×(3×4)=48 个字节。

2、初始化数组

二维数组的初始化，有 3种方式：

（1）将所有数据写在一个大括号内，按照数组元素排列顺序对元素赋值。例如：

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

（2）为所有元素赋初值时，可以省略行下标，但是不能省略列下标。例如：

int iArray[][2] = {1, 2, 3, 4, 5, 6}; // 一共6个数据，分为3列，所以数组有2行。

（3）分行给数据元素赋值。例如：

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

数组长度可以使用 sizeof 运算符来获取数组的长度。

#include <stdio.h>
 
int main() {    
    int iArray1[2][2] = {1, 2, 3, 4};
	int iArray2[][2] = {1, 2, 3, 4, 5, 6};
	int iArray3[2][3] = {{1, 2, 3}, {4, 5, 6}};
	
	printf("iArray1长度：%d\n", sizeof(iArray1) / sizeof(iArray1[0][0]));
	printf("iArray2长度：%d\n", sizeof(iArray2) / sizeof(iArray2[0][0]));
	printf("iArray3长度：%d\n", sizeof(iArray3) / sizeof(iArray3[0][0]));
 
    return 0;
}

3、实例

一般使用嵌套循环来处理二维数组。

实例1：

#include <stdio.h>
 
int main(){
    
    /* 5 行 2 列的数组 */
   int iArray[5][2] = {{10,15}, {1,2}, {2,4}, {3,6},{4,8}};
   int i, j;
 
   /* 输出数组中每个元素的值 */
   for (i = 0; i < 5; i++ ) {
      for (j = 0; j < 2; j++ ) {
         printf("打印 iArray[%d][%d] = %d\n", i, j, iArray[i][j]);
      }
   }
 
    return 0;
}

三、字符数组

数组中的元素类型为字符型时称为字符数组。即字符数据中的每个元素可以存放一个字符。
字符数组的定义和访问与其他数组类型类似。

C语言中没有专门的字符串变量，没有 String类型，通常使用字符数组来存放字符串。 字符数据实际上是一系列的字符集合，不严谨的说就相当于字符串。

1、定义

基本格式为：char arrayName[length];

其中，char 为字符类型，arrayName 为数组名，length：为数组长度。

2、初始化

字符数组的初始化，有 3种方式：

（1）逐个字符赋给数组中的元素。例如：

char cArray[6] = {'H', 'e', 'l', 'l', 'o'};

（2）定义字符数组的同时进行初始化，此时可以省略数组长度。例如：

char cArray[] = {'H', 'e', 'l', 'l', 'o'};

（3）利用字符串给字符数组赋初值。例如：

char cArray[] = {"Hello"}; // 也可以不指定数组长度
// 或者，去掉 {}
char cArray[] = "Hello";

字符串长度，就是字符串包含了多少个字符（不包括最后的结束符'\0'）。
可以使用 string.h头文件中的 strlen() 函数来求字符串的长度。

#include <stdio.h>
#include <string.h>
 
int main(){    
    char cArray1[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
	char cArray2[] = {'H', 'e', 'l', 'l', 'o'};
	char cArray31[5] = {"Hello"};
	char cArray32[] = {"Hello"};
	char cArray33[] = "Hello";
	
	printf("cArray1长度：%d\n", sizeof(cArray1) / sizeof(cArray1[0]));
	printf("cArray1 strlen长度：%d\n", strlen(cArray1));
	printf("cArray2长度：%d\n", sizeof(cArray2) / sizeof(cArray2[0]));
	printf("cArray2 strlen长度：%d\n", strlen(cArray2));
	printf("cArray31长度：%d\n", sizeof(cArray31) / sizeof(cArray31[0]));
	printf("cArray31 strlen长度：%d\n", strlen(cArray31));
	printf("cArray32长度：%d\n", sizeof(cArray32) / sizeof(cArray32[0]));
	printf("cArray32 strlen长度：%d\n", strlen(cArray32));
	printf("cArray33长度：%d\n", sizeof(cArray33) / sizeof(cArray33[0]));
	printf("cArray33 strlen长度：%d\n", strlen(cArray33));

	printf("--------------\n");	
	printf("cArray2：%s\n", cArray2);
	printf("cArray2[6]：%c\n", cArray2[6]);
	printf("cArray31：%s\n", cArray31);
	printf("cArray32：%s\n", cArray32);
    
    return 0;
}

正确地初始化变量是一个良好的编程习惯，否则有时候程序可能会产生意想不到的结果，因为未初始化的变量会导致一些在内存位置中已经可用的垃圾值。

一般在字符串的最后手动添加’\0’或者初始化数组为’\0’或者数组大小多一个字节。

3、字符数组的结束标志

C语言中，使用字符数组保存字符串时，系统会自动为其添加“\0”作为结束符。
所以，在 C语言中，字符串总是以“\0”作为结尾，所以“\0”也被称为字符串结束标志，或者字符串结束符。

注意：

• “\0”是 ASCII 码表中的第 0 个字符，英文称为 NUL，中文称为“空字符”。该字符既不能显示，也没有控制功能，输出该字符不会有任何效果，它在 C语言中唯一的作用就是作为字符串结束标志。
• C语言在处理字符串时，会从前往后逐个扫描字符，一旦遇到“\0”就认为到达了字符串的末尾，就结束处理。“\0”至关重要，没有“\0”就意味着永远也到达不了字符串的结尾。
• 用字符串方式初始化比逐个字符初始化要多占一个字节，多占的这个字节用于存放字符串结束标志“\0”。

// cArray1和cArray2是等价的，cArray1系统会自动添加“\0”。
char cArray1[] = "Hello";
char cArray2[] = {'H', 'e', 'l', 'l', 'o', '\0'}; 
// 字符数组并不要求最后一个字符为“\0”，甚至可以不包含“\0”。所以下面的写法也是合法的。
char cArray3[5] = {'H', 'e', 'l', 'l', 'o'};

所以，是否加“\0”，应根据需要来决定，由于系统对字符串常量会自动加上一个“\0”。因此，为了使处理方法一直，并且便于测定字符串的实际长度，通常我们在字符数组中会人为的加上一个“\0”。

4、实例

实例1：

#include <stdio.h>

int main() {

    char cString[7] = "charge";
    char cReverse[7] = {0};
    int size;
    size = sizeof(cString);
    printf("源字符串长度：%d\n", size);

    for (int i = 0; i < 6; ++i) {
        cReverse[size - i - 2] = cString[i];
    }

    printf("源字符串：%s\n", cString);
    printf("反转之后的字符串：%s\n", cReverse);
    return 0;
}

实例2：

#include <stdio.h>
#include <string.h>
 
int main(){    
    char str[30] = {'\0'};  //将所有元素都初始化为 0，或者说 '\0'
    char c;
    int i;
	
	printf("str长度：%d\n", sizeof(str) / sizeof(str[0]));
	printf("str： strlen长度：%d\n", strlen(str));
    for(c=65,i=0; c<=90; c++,i++){
        str[i] = c;
    }
    printf("str：%s\n", str); 
	printf("str： strlen长度：%d\n", strlen(str));

    return 0;
}

– 求知若饥，虚心若愚。