c语法7 - 数组与字符串

概述

定义：把具有相同类型的若干变量按有序形式组织起来称为数组。

C语言数组属于构造数据类型。一个数组可以分解为多个数组元素，这些数组元素可以是基本数据类型或是构造类型。因此按数组元素的类型不同，数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。

一维数组

数组的概念和定义

我们知道，要想把数据放入内存，必须先要分配内存空间。放入4个整数，就得分配4个int类型的内存空间：

int a[4];

这样，就在内存中分配了4个int类型的内存空间，共 4×4=16 个字节，并为它们起了一个名字，叫a。

我们把这样的一组数据的集合称为数组(Array)，它所包含的每一个数据叫做数组元素(Element)，所包含的数据的个数称为数组长度(Length)，例如int a[4];就定义了一个长度为4的整型数组，名字是a。

数组中的每个元素都有一个序号，这个序号从0开始，而不是从我们熟悉的1开始，称为下标(Index)。使用数组元素时，指明下标即可，形式为：

arrayName[index]

arrayName 为数组名称，index 为下标。例如，a[0] 表示第0个元素，a[3] 表示第3个元素。

接下来我们就把第一行的4个整数放入数组：

a[0]=20;a[1]=345;a[2]=700;a[3]=22;

这里的0、1、2、3就是数组下标，a[0]、a[1]、a[2]、a[3] 就是数组元素。

下列实现一个输入多个数字，并存入数组输出：

#include int main(){    int nums[10];    int i;    //从控制台读取用户输入    for(i=0; i<10; i++){        scanf("%d", &nums[i]);     }    //依次输出数组元素    for(i=0; i<10; i++){        printf("%d ", nums[i]);    }    return 0;}

数组的定义方式：

dataType  arrayName[length];

dataType 为数据类型，arrayName 为数组名称，length 为数组长度。例如：

char ch[9];  //定义一个长度为 9 的字符型数组float m[12];  //定义一个长度为 12 的浮点型数组char ch[9];  //定义一个长度为 9 的字符型数组

需要注意的是：

1. 数组中每个元素的数据类型必须相同，对于int a[4];，每个元素都必须为 int。

2. 数组长度 length 最好是整数或者常量表达式，例如 10、20* 4 等，这样在所有编译器下都能运行通过；如果 length 中包含了变量，例如 n、4*m 等，在某些编译器下就会报错

3. 访问数组元素时，下标的取值范围为 0 ≤ index < length，过大或过小都会越界，导致数组溢出，发生不可预测的情况

数组内存是连续的

数组是一个整体，它的内存是连续的；也就是说，数组元素之间是相互挨着的，彼此之间没有一点点缝隙。下图演示了int a[4];在内存中的存储情形：「数组内存是连续的」这一点很重要，所以我使用了一个大标题来强调。连续的内存为指针操作(通过指针来访问数组元素)和内存处理(整块内存的复制、写入等)提供了便利，这使得数组可以作为缓存(临时存储数据的一块内存)使用。大家暂时可能不理解这句话是什么意思，等后边学了指针和内存自然就明白了。

数组的初始化

上面的代码是先定义数组再给数组赋值，我们也可以在定义数组的同时赋值，例如：

int a[4] = {20, 345, 700, 22};

数组元素的值由{ }包围，各个值之间以,分隔。

对于数组的初始化需要注意以下几点：

可以只给部分元素赋值。当{ }中值的个数少于元素个数时，只给前面部分元素赋值。例如：

int a[10]={12, 19, 22 , 993, 344};

表示只给 a[0]~a[4] 5个元素赋值，而后面 5 个元素自动初始化为 0。

当赋值的元素少于数组总体元素的时候，剩余的元素自动初始化为 0：

• 对于short、int、long，就是整数 0；
• 对于char，就是字符 '\0'；
• 对于float、double，就是小数 0.0。

我们可以通过下面的形式将数组的所有元素初始化为 0：

int nums[10] = {0};char str[10] = {0};float scores[10] = {0.0};

由于剩余的元素会自动初始化为 0，所以只需要给第 0 个元素赋值为 0 即可。

只能给元素逐个赋值，不能给数组整体赋值。例如给 10 个元素全部赋值为 1，只能写作：

int a[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};

而不能写作：

int a[10] = 1;

如给全部元素赋值，那么在定义数组时可以不给出数组长度。例如：

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

等价于

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

可以使用数组输出一个4x4的矩阵

#include int main(){    int a[4] = {1, 2, 3, 4};    int b[4] = {5, 6, 7, 8};    int c[4] = {9, 10 ,11, 12};    int d[4] = {13, 14, 15, 16161616};    printf("%-9d %-9d %-9d %-9d\n", a[0], a[1], a[2], a[3]);    printf("%-9d %-9d %-9d %-9d\n", b[0], b[1], b[2], b[3]);    printf("%-9d %-9d %-9d %-9d\n", c[0], c[1], c[2], c[3]);    printf("%-9d %-9d %-9d %-9d\n", d[0], d[1], d[2], d[3]);    return 0;}

数组元素逆序

#include

int main(void){ int arr[] = {1, 6, 7, 5, 9, 4, 3}; int i = 0; // 数组首元素下标 int j = sizeof(arr)/sizeof(arr[0]) - 1; //数组最后一个元素下标 int temp = 0; //打印原始数组 for (size_t m = 0; m sizeof(arr) / sizeof(arr[0]); m++){  printf("%d ", arr[m]); } printf("\n");

 while(i   temp = arr[i];  arr[i] = arr[j];  arr[j] = temp;  i++;  j--; } for (size_t n = 0; n sizeof(arr) / sizeof(arr[0]); n++){  printf("%d ", arr[n]); } printf("\n"); return 0;}

sizeof(arr)获取到所有的数组元素的下标，而sizeof(arr)/sizeof(arr[0]) - 1获取到最后一位的元素下标

通过for循环打印数组

while进行数组前后元素的交换，并向中间递进。

冒泡排序

1、比较相邻的元素。如果第一个比第二个大(小)，就交换他们两个。

2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大(小)的数。

3、针对所有的元素重复以上的步骤，除了最后已经选出的元素(有序)。

4、持续每次对越来越少的元素(无序元素)重复上面的步骤，直到没有任何一对数字需要比较，则序列最终有序。

#include 

int main(void){

 int guo[] = { 4,554,48,49,487,56,12}; int n = sizeof(guo) / sizeof(guo[0]); //数组元素个数 int temp = 0; //临时变量

 for (size_t i = 0; i -1; i++){  // 控制行  for (size_t j = 0; j -1-i; j++ ){ // 控制内层列   if(guo[j] > guo[j+1]){    temp = guo[j];    guo[j] = guo[j+1];    guo[j+1] = temp;   }  } }    for (size_t i = 0; i      printf("%d ", guo[i]); } printf("\n"); return 0;}

二维数组

二维数组概念与形式

二维数组定义的一般形式是：

dataType arrayName[length1][length2];

其中，dataType 为数据类型，arrayName 为数组名，length1 为第一维下标的长度，length2 为第二维下标的长度。

我们可以将二维数组看做一个 Excel 表格，有行有列，length1 表示行数，length2 表示列数，要在二维数组中定位某个元素，必须同时指明行和列。例如：

int a[3][4];

定义了一个 3 行 4 列的二维数组，共有 3×4=12 个元素，数组名为 a，即：

a[0][0], a[0][1], a[0][2], a[0][3]a[1][0], a[1][1], a[1][2], a[1][3]a[2][0], a[2][1], a[2][2], a[2][3]

如果想表示第 2 行第 1 列的元素，应该写作 a[2][1]。

也可以将二维数组看成一个坐标系，有 x 轴和 y 轴，要想在一个平面中确定一个点，必须同时知道 x 轴和 y 轴。

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

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

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

你可以这样认为，二维数组是由多个长度相同的一维数组构成的。

二维数组初始化

常规初始化

int arr [3][5] = {{ 2, 3, 54, 56, 7 },{2, 67, 4, 35, 9}, {1, 2, 3, 4, 5}}

不完全初始化

int arr[3][5] = {{2, 3},{2, 3, 4},{1, 2, 3, 4}}

未被初始化的赋值为0

int arr[10] = 0;则该10个元素均被赋值为0

同理

二维数组也可赋值为0

int arr[10][5] = {0}

此时获取到50个0组成的二维数组

系统自动分配行列

int arr[3][5] = {1,2,3,4,5,6,7}

无法使用下列形式的定义**

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

二维数组必须指定列值，可以不使用行值

int arr[][4] = {1, 3, 4, 6, 7};

输出

1   3

4   6

7   0

打印二维数组

#include

int main(void){    int arr[5][3] = { {1,2,3},         {4,5,6},         {7,8,9},       {10,11,12},       {13,14,15} };    int arr2[3][5] = {         {1,2,3,4,5},      {6,7,8,9,10},      {11,12,13,14,15}};    printf("第一个数组打印\n");    for(size_t i = 0;i sizeof(arr)/sizeof(arr[0]); i++){     for (size_t j = 0; j sizeof(arr[i])/sizeof(arr[i][0]);j++){      printf("%d ",arr[i][j]);  }  printf("\n"); } printf("第二个数组打印\n");  for(size_t i = 0;i sizeof(arr2)/sizeof(arr2[0]); i++){     for (size_t j = 0; j sizeof(arr2[i])/sizeof(arr2[i][0]);j++){      printf("%d ",arr2[i][j]);  }  printf("\n"); } return 0;}

二维数组输入输出

#include

int main(void){ int scores[5][3];

 int row = sizeof(scores) / sizeof(scores[0]); int col = sizeof(scores[0]) / sizeof(scores[0][0]);

 for (size_t i = 0; i       for (size_t j = 0; j //            取地址输入       scanf("%d", &scores[i][j]);   } } for (size_t i = 0; i       for (size_t j = 0; j //            取地址输入       printf("%d ", scores[i][j]);   }   printf("\n"); } return 0;}

修改为输出按二维数组行成绩求和

#includeint main(void){ int scores[5][3]; int row = sizeof(scores) / sizeof(scores[0]); int col = sizeof(scores[0]) / sizeof(scores[0][0]); for (size_t i = 0; i       for (size_t j = 0; j        scanf("%d", &scores[i][j]);   } } for (size_t i = 0; i   int sum = 0;  for (size_t j = 0; j    sum += scores[i][j];  }  printf("第%d行求和为：%d\n", i+1, sum); }

 return 0;}

修改为按列求和

#include

int main(void){ int scores[5][3];

 int row = sizeof(scores) / sizeof(scores[0]); int col = sizeof(scores[0]) / sizeof(scores[0][0]);

 for (size_t i = 0; i       for (size_t j = 0; j //            取地址输入       scanf("%d", &scores[i][j]);   } } for (size_t i = 0; i   int sum = 0;  for (size_t j = 0; j    sum += scores[j][i];  }  printf("第%d列总和：%d\n", i+1, sum); } return 0;}

多维数组

三维数组

行列层

【层】【行】【列】

int arr[2][3][4]; // 两层三行四列

三维数组大小为  ：

层*行*列*类型大小

三位数组打印与定义

#include

int main(void){//  定义一个两层三行四列的三维数组// int arr[2][3][4];// {//     { {11, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} },//     { {21, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} },//    { {31, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} },// }

    int arr[2][3][4] = {     { {11, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} },     { {21, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} } }; // 打印维数组 for (size_t i = 0; i 2; i++){  for (size_t j = 0; j 3; j++){   for(size_t k = 0;k 4; k++){    printf("%d ",arr[i][j][k]);   }   printf("\n");  }  printf("换层\n\n"); } return 0;}

特殊初始化

int arr[2][3][5] = {1,2,3,4,5,6,7,8,9,10,11};  //可自动化定义int arr[][3][5];  //可省略层数

字符数组和字符串

字符数组

#include

int main(void){ char str[5] = {'h', 'e', 'l', 'l', 'o'};

 printf("%s\n", str);

 return 0;}

字符串

char str[5] = {'h', 'e', 'l', 'l', 'o', '\0'}; //最后一位可以自动补0char str[] = "hello";

printf(“%s”) ==> 使用printf 打印字符串的时候必须碰到  **\0 **才结束,字符串和字符串数组自动补 \0

字符串数组输入

#includeint main(void){ char str[100] = {0};

 for (size_t i = 0; i 10; i++){  scanf("%c", &str[i]); } printf("str = %s\n",str); return 0;}

统计字符串中字符出现次数

#include

int main(void){    int count[26] = {0}; // 判断字符串中的每个次数//     a：97//     z: 123// 通过给一个数组下标添加累计数量的方式，记录字符串的出现次数，通过asic码   char str[11] = {0};   for (size_t i = 0; i 10; i++){    scanf("%c", &str[i]);   }

   for (size_t i = 0; i 11; i++){    int index = str[i] - 'a'; // 用户输入字符下标在count数组中的下标值    count[index]++;   }

   for (size_t i = 0; i 26; i++){    if(count[i] != 0){     printf("%c 字符在字符串中出现的次数%d\n", i+'a', count[i]);    }   }

 return 0;}

字符串操作

字符串获取带空格的字符串

一般情况下：

• 获取字符串%s， 遇到空格和\n终止
• 用于存储字符串的空间必须足够大，防止溢出

若需要获取空格，需借助正则表达式

scanf("%[^\n]", str);// 除换行之外的字符

如下代码接收空格示例：

#include

int main(void){ char str[100]; scanf("%[^\n]s", str); printf("%s\n", str); return 0;}

gets()函数

获取一个字符串，返回字符串的首地址

原型

char *gets(char *s);

输入参数，用来存储字符串的空间

返回一个字符串的首地址

#include#include#include

int main(void){ char str[100]; printf("获取字符串为：%s\n", gets(str)); return 0;}

注意:由于scanf()和gets()无法知道字符串s大小，必须遇到换行符或读到文件结尾为止才接收输入，因此容易导致字符数组越界(缓冲区溢出)的情况。不安全的。

fgets()

char *fgets(char *s, int size, FILE *stream);

参数:获取一个字符串。

s ：存储字符串的空间地址

size ：描述空间大小，会预留**/0**的存储空间，使得输入不会越界

stream：读取字符串的位置，标准输入：stdin，表示键盘

返回值：返回实际获取到的字符串首地址。

使用方法：

#include#include#include

int main(void){ char str[10]; printf("获取字符串为：%s\n", fgets(str, sizeof(str), stdin)); return 0;}

puts()

将字符串写出屏幕

int puts(coust char *s);

• 参数：待写出到屏幕的字符串

• 返回值：**成功：**非负数， 失败： -1

• puts函数会默认换行

#include#include#include

int main(void){ char str[] = "hello plotycodon\n"; int code = puts(str); printf("code = %d\n", code); return 0;}

fputs()

 int fputs(const char *str, FILE *stream);

参数：输出后不默认添加\n换行

str ：待输出的字符串

stream：输出位置(屏幕标准输出 ==> stdout)

返回：成功0， 失败-1

#include#include#include

int main(void){ char str[] = "hello plotycodon"; int code = fputs(str, stdout); printf("code = %d\n", code); return 0;}

strlen()

求字符串的长度

size_t strlen(const char *s);

参数

代求长度的字符串

返回一个有效的字符个数

碰到\0结束

#include#include#include

int main(void){ char str[] = "hello \n plotycodon\n"; printf("str = %s", str); printf("sizeof(str) = %u \n", sizeof(str)); printf("strlen(str) = %u", strlen(str)); return 0;}

实现strlen()函数

#include#include#include

//实现strlen()

int main(void){ char str[] = "hello \n plotycodon\n"; int i = 0;

 while(str[i] != '\0'){  i++; } printf("strlen(str) == %d", i);}

strcat()

拼接两个字符串

char*strcat(char* strDestination, const char* strSource);

参数为两个需要拼接的字符串，其中第一个字符串将被覆盖成新的字符串

#include #include int main(){    char str1[101] = { 0 };    char str2[50] = { 0 };    gets(str1);    gets(str2);    strcat(str1, str2);    puts(str1);    return 0;}

实现strcat

#include#include#include

int main(void){ char str1[] = "guo"; char str2[] = "jia"; char str3[100] = {0};

 int i = 0; while (str1[i] != '\0'){  str3[i] = str1[i];  i++; } // 将str1 给str3 printf("第一次循环结束的时候, i = %d, str3 == %s\n", i, str3);

 int j = 0; while(str2[j]){  str3[i+j] = str2[j];  j++; } printf("第二次循环结束的时候, i = %d, str3 == %s\n", i+j, str3);

 return 0;}

往期文章

2020-9-17

• C++语法1、类与对象

• c++语法2、c执行-命名空间-输入输出

• c++ 3、语法 数据类型

• c++ 4、语法 数组

• c++  c语言- 概述

• c++  c语言 - 控件及概述补充

• c++  c语言 - 数据类型

• c++  c语言 - 进制、原反补码、输入输出函数

• c++  c语言 - 运算符和类型转换

• c++  c语言 - 控制语句

图 | 郭嘉

文 | 郭嘉

扫码关注桔梗与少年

微信号 : if-u-remembers

新浪微博：桔梗与少年