认识C 语言中的数组

1、什么是数组

基本概念

• 逻辑：一次性定义多个相同类型的变量，并存储到一片连续的内存中
• 示例：

数据类型  变量名  [ 元素数量 ] ;
int a[5];

• 语法释义：
  • a 是数组名，即这片连续内存的名称
  • [5] 代表这片连续内存总共分成5个相等的格子，每个格子称为数组的元素
  • int 代表每个元素的类型，可以是任意基本类型，也可以是组合类型，甚至可以是数组
• 初始化：在定义的时候赋值，称为初始化

// 正常初始化
int a[5] = {100,200,300,400,500};

int a[5] = {100,200,300,400,500,600}; // 警告，超过了数组a的存储范围，因此600会被编译器放弃
int a[ ] = {100,200,300}; // OK，自动根据初始化列表分配数组元素个数
int a[5] = {100,200,300}; // OK，只初始化数组元素的一部分

 

 

实例：

// 定义一个数组并对他的每一个元素进行初始化
int arr1 [5] = {1,2,3,4,5} ;


// 出现警告 ， 数组大小为5个元素，但是实际给的初始化元素是 8个，因此6,7,8 三个元素会被编译器'优化'
int arr2 [5] = {1,2,3,4,5,6,7,8} ;

// 正确， 初始化了数组的一部分元素，未初始化部分会默认设置为0 
int arr3 [5] = {1,2,3} ;
int arr4 [100] = {0} ;  // 定义数组arr4 并且所有的元素都被初始化为 0 

// 正确， 该数组虽没有写元素个数，但是有实际的初始化数据，
// 因此他的大小由初始化元素的数量来决定
int  arr5 [ ] = {1,2,3,4,5,6} ; 
int  arr6 [ ] = {0} ;  // 该数组的大小 4字节， 一个元素

// 正确的 该数组称为 【零长数组】
int  arr7 [0] ;

// 错误 ， 数组在定义的语句中【必须】要确定他的大小。
int  arr8[] ;

2、数组元素的引用

• 存储模式：一片连续的内存，按数据类型分割成若干相同大小的格子
• 元素下标：数组开头位置的偏移量

元素下标偏移量

 

• 示例：

int a[5]; // 有效的下标范围是 0 ~ 4
a[0] = 1;
a[1] = 66;
a[2] = 21;
a[3] = 4;
a[4] = 934;

a[5] = 62; // 错误，越界了
a    = 10; // 错误，不可对数组名赋值 

关于数组尺寸：

int arr[5] ;
printf("arr的大小：%ld\n" , sizeof(arr) ); // 20 由于元素有5个，int占4字节


int arr1 [] = {1,2,3};
printf("arr1的大小：%ld\n" , sizeof(arr1) );  // 12 由于初始化元素为3个


// 下标最大值 = 总容量  /  某一个元素的大小 ;
int len = sizeof(arr1) / sizeof(arr1[0]) ;

for (int i = 0; i < len ; i++)
{
    printf("arr1[%d]:%d\n" , i , arr1[i]);
}


// 零长数组的大小就是 0 字节
int arr2 [0] ;
printf("arr2的大小：%ld\n" , sizeof(arr2) );

3、字符数组 

• 概念：专门存放字符的数组，称为字符数组
• 初始化与元素引用：

char s1[5] = {'a', 'b', 'c', 'd', 'e'};       // s1存放的是字符序列，非字符串，即字符数组
char s2[6] = {'a', 'b', 'c', 'd', 'e', '\0'}; // s2存放了一个【字符串】字符串数组

char s3[6] = {"abcde"}; // 使用字符串直接初始化字符数组（顺利把字符串的结束标记\0存入，因此他称为字符串数组）
char s4[6] =  "abcde" ; // 大括号可以省略
char s5[5] =  {"abcde"} ; //  结束符\0没有被顺利存入字符数组中，因此他只是一个字符数组

s[0] = 'A'; // 索引第一个元素，赋值为 'A'

字符型数据实例：

char arr[5] = {"Hello"} ;
char ch[5] = {"LeiHou"};

// 能输出 Hello ， 但是Hello 输出后，有可能出现一些不可预测的字符
//  由于%s 在工作时，只有遇到 \0 才会停止工作 ....
printf("arr:%s\n" , arr );

4、多维数组

• 概念：若数组元素类型也是数组，则该数组称为多维数组
• 示例：

int a[2][3];

// 代码释义：
// 1, a[2]   是数组的定义，表示该数组拥有两个元素
// 2, int [3]是元素的类型，表示该数组元素是一个具有三个元素的整型数组

 

 

• 多维数组的语法跟普通的一维数组语法完全一致

• 初始化：

int a[2][3] = {{1,2,3}, {4,5,6}}; // 数组的元素是另一个数组

int a[2][3] = {{1,2,3}, {4,5,6}, {7,8,9}}; // 警告，越界了
int a[2][3] = {{1,2,3}, {4,5,6,7}};        // 警告，越界了
int a[2][3] = {{1,2,3,4}, {5,6,7,8}};   // 警告  ， 越界了 ， 4 和8 会被优化
int a[2][3] = {1,2,3,4,5,6,7,8};   // 警告  ， 越界了  7 和8 会被优化

// int [3]  是元素的类型
int a[ ][3] = {{1,2,3}, {4,5,6}}; // OK，自动根据初始化列表分配数组元素个数

// int [ ] 是元素类型 ，数组的类型不可以是不确定的。
int a[2][ ] = {{1,2,3}, {4,5,6}};  // 【错误】

int a[2][3] = {{1,2,3}};          // OK，只初始化数组元素的一部分

• 元素引用：

// a[0] 代表第一个元素，这个元素是一个具有 3 个元素的数组：{1,2,3}
// a[1] 代表第二个元素，这个元素也是一个具有 3 个元素的数组：{4,5,6}

printf("%d", a[0][0]); // 输出第一个数组的第一个元素，即1
printf("%d", a[1][2]); // 输出第二个数组的第三个元素，即6

 

5、数组万能拆解法

• 任意的数组，不管有多复杂，其定义都由两部分组成。
  • 第1部分：说明元素的类型，可以是任意的类型（除了函数）
  • 第2部分：说明数组名和元素个数

• 示例：

int   a[4];       // 第2部分：a[4]; 第1部分：int
int   b[3][4];    // 第2部分：b[3]; 第1部分：int [4]
int   c[2][3][4]; // 第2部分：c[2]; 第1部分：int [3][4]
int  *d[6];       // 第2部分：d[6]; 第1部分：int *
int (*e[7])(int, float); // 第2部分：e[7]; 第1部分：int (*)(int, float)

注解：

• 上述示例中，a[4]、b[3]、c[2]、d[6]、e[7]本质上并无区别，它们均是数组
• 上述示例中，a[4]、b[3]、c[2]、d[6]、e[7]唯一的不同，是它们所存放的元素类型的不同
• 第1部分的声明语句，如果由多个单词组成，C语言规定需要将其拆散写到第2部分的两边

6、数组名的含义

• 数组名有两个含义：
  • 第一含义是：整个数组
  • 第二含义是：首元素地址
• 当出现以下情形时，那么数组名就代表整个数组：
  • 在数组定义中
  • 在 sizeof 运算表达式中 sizeof(arr) --> 整个数组的大小
  • 在取址符&中 &arr
• 其他任何情形下，那么数组名就代表首元素地址。即：此时数组名就是一个指向首元素的指针。
• 示例：

int a[3];                  // 此处，a 代表整个数组
printf("%d\n", sizeof(a)); // 此处，a 代表整个数组
printf("%p\n", &a);        // 此处，a 代表整个数组，此处为整个数组的地址

int *p = a;       // 此处，a 代表首元素 a[0] 的地址，等价于 &a[0]
p = a + 1;        // 此处，a 代表首元素 a[0] 的地址，等价于 &a[0]
function(a);      // 此处，a 代表首元素 a[0] 的地址，等价于 &a[0]
scanf("%d\n", a); // 此处，a 代表首元素 a[0] 的地址，等价于 &a[0]

        C语言只有在第一含义的场合下表现为数组，其他大部分场合都表现为首元素的地址，当数组表现为首元素地址时，实际上就是一个指向其首元素的指针。数组运算实际上就是指针运算。

7、数组下标

• 数组下标实际上是编译系统的一种简写，其等价形式是：

a[i] = 100;  等价于  *(a+i) = 100;

• 根据加法交换律，以下的所有的语句均是等价的：

  a[i] = 100;
*(a+i) = 100;
*(i+a) = 100;
  i[a] = 100;

        数组运算，等价于指针运算。

8、字符串常量

• 字符串常量在内存中的存储，实质是一个匿名数组
• 匿名数组，同样满足数组两种涵义的规定
• 示例：

printf("%d\n", sizeof("abcd")); // 此处 "abcd" 代表整个数组
printf("%p\n", &"abcd");        // 此处 "abcd" 代表整个数组

printf("%c\n", "abcd"[1]); // 此处 "abcd" 代表匿名数组的首元素地址
char *p1 = "abcd";         // 此处 "abcd" 代表匿名数组的首元素地址
char *p2 = "abcd" + 1;     // 此处 "abcd" 代表匿名数组的首元素地址

 

9、零长数组（预习：结构体）

• 概念：长度为0的数组，比如 int data[0];
• 用途：放在结构体的末尾，作为可变长度数据的入口（数组是唯一个允许越界访问的媒介)
• 示例

struct node
{
    /* 结构体的其他成员 */
    // 成员1
    // 成员2
    // ... ...
    
    int   len;
    char *data[0];
};

// 给结构体额外分配 10 个字节的内存。
struct node *p = malloc(sizeof(struct node) + 10);
p->len = 10;

// 额外分配的内存可以通过 data 来使用
p->data[0] ~ p->data[9]

10、变长数组

• 概念：定义时，使用变量作为元素个数的数组。
• 要点：变长数组仅仅指元素个数在定义时是变量，而绝非指数组的长度可长可短。实际上，不管是普通数组还是所谓的变长数组，数组一旦定义完毕，其长度则不可改变。
• 示例：

int len = 5;
int a[len];  // 数组元素个数 len 是变量，因此数组 a 是变长数组

int x = 2;
int y = 3;
int b[x][y]; // 数组元素个数 x、y 是变量，因此数组 b 是变长数组
int b[2][y]; // 数组元素个数 y 是变量，因此数组 b 是变长数组
int b[x][3]; // 数组元素个数 x 是变量，因此数组 b 是变长数组

        语法：变长数组不可初始化，即以下代码是错误的：

int len = 5;
int a[len] = {1,2,3,4,5}; // 数组 a 不可初始化

课外小练习：

        1、编写一个程序，用户输入华氏温度F，程序输出摄氏温度C，结果保留2位小数。（提示：华氏温度F转化为摄氏温度C的公式为： C = 5×（F - 32）÷ 9 ）

        2、编写一个程序，接收用户的输入信息，当用户输入完成后（ ‘#’ 代表输入完成），自动统计用户输入的空格数、大小写字母数和其他字符数。

        3、编写一个程序，接受一个整数输入，然后显示所有小于或等于该数的素数。

未完待续 ......

有疑问的小伙伴可以留言一起交流讨论！！！