C笔记（九）——数组和字符串

水深无声 2022-05-27 03:27 210阅读 0赞

数组适合处理有大量相同数据类型的数据

# 一、数组    //数组必须先定义，后引用 #

## 1.1 一维数组的定义 ##

表现形式：

> **数据类型 数组名 \[常量表达式\]**； //常量表达式中可以包括常量和符号常量，不能包含变量

**例如：int array \[10\];**   定义了一个叫array的一维数组，从array\[0\]-array\[9\]一共有10个元素，每个元素都是int型的。

### 1.1.1 数组的初始化 ###

**a. 未初始化的数组元素值是什么？**

*  静态数组和全局数组没初始化时，系统会自动将其初始化为0值；
 *  其它的比如动态数组等，会初始化为随机值

**b. 一维数组初始化的方法：**

![20200307160802977.png][]

**说明：**

（1）**array \[0\] = 10; 或者array = 10；//** 给数组中第一个元素赋值为10, 数组名表示数组首地址。

（2）**int array\[5\] = \{6, 8, 8, 10, 9\}; //**给array数组内的5个元素分别赋值为6, 8, 8, 10, 9。在给了数组的全部元素后，

"\[ \]"内的常量表达式可忽略。如：**int array\[ \] = \{6, 8, 8, 10, 9\};**

（3）也可以只给一部分元素赋值。如：**int array\[5\] = \{6, 8\}; //表示int array\[5\] = \{6, 8, 0, 0, 0\};**

int main()//一维数组输出实数和字符串
    {
        int i;
        int array[10] = {5, 4, 8, 12, 20};  //实数数组中不够的元素用0补齐，并输出显示
    
        for(i = 0; i < 10; i++)  //显示一维实数数组一般用for循环，来显示数组的全部元素
            {
                printf("array[%d] = %d\n",i, array[i]);
            }
    
         char b[10] = "abc"; //字符数组数组长度大于实际字符串长度时，只输出到遇0（‘\0’）结束。
         printf("{%s}\n",b);
    
        return 0;
    }

**运行结果：**

![70][]

### 1.1.2 更高效的数组初始化和赋值方法 ###

该方法需要包含相应的头文件：

> \#include <string.h>

更高效的**数组初始化**方法：

> memset(a, 0, sizeof(a)); //将数组a赋值为0

更高效的**数组赋值**方法：

> memcpy(b, a, sizeof(a)); //将数组a赋值给数组b

## 1.2 一维数组元素的引用 ##

>      数组元素的表示形式为：数组名 \[下标\]； //下标可以是整型常量或者整型表达式

如：a\[0\] = a\[5\] + a\[7\] - a\[2 \* 3\];

注：定义数组时用到的“数组名【常量表达式】”和引用数组元素时用到的“数组名【下标】”的区别，例如：

（1）int a\[10\];   //定义数组长度为10

**   ** （2）t = a\[6\];  //引用a数组中序号为6的元素。此时6不代表数组长度。

下面是一个排序算法的例子：

#include <iostream>
    using namespace std;
    
    int main()
    {
        int array[5] = { 6, 7, 5, 2, 4 };
        int i;
        int j, a;
        
        for (j = 0; j < 4; j++)
        {
            for (i = 0; i < 4 - j; i++)
            {
                if (array[i] > array[i + 1]) #小数在前，大数在后
                {
                    a = array[i];
                    array[i] = array[i + 1];
                    array[i + 1] = a;
                }
            }
        }
        cout << "the sorted numbers:\n" << endl;
        
        for (i = 0; i < 5; i++)
        {
            cout << "array[" << i << "] = " << array[i] << endl;
        }
        system("pause");
        return 0;
    }

结果：

![20190719191607624.png][]

## 1.3 数组在内存的存储方式 ##

数组在内存中就是一段连续的内存空间。

# 二、二维数组 #

## 2.1 二维数组定义 ##

表现形式：

> ***数据类型 数组名\[常量表达式\]\[常量表达式\]；***

**eg：float a\[3\]\[4\]，b\[5\]\[10\];   //**定义a为3\*4（3行4列）的数组，b为5\*10（5行10列）的数组。注意不能写成：float a\[3,4\],b\[5,10\];这3个元素为a\[0\]、a\[1\]、a\[2\]，每个元素又是一个包含4个元素的一维数组，如下图：

![20180415212753520][]

可以把a\[0\]，a\[1\]，a\[2\]看作是3个一维数组的名字。

上面定义的二维数组可以理解为定义了3个一维数组，即相当于：

**float a\[0\]\[4\]，a\[1\]\[4\]，a\[2\]\[4\];**  //此处可以把a\[0\]、a\[1\]、a\[2\]看作一维数组名。

注： **二维数组可被看作是一个特殊的一维数组：它的元素又是一个一维数组。C语言中，二维数组中元素排列的顺序是按行存放的，即在内存中先顺序存放第一行的元素，再存放第二行的元素。及从左到右先a00->a01->a02->a03->a10...->a23. **

## 2.2 二维数组的引用 ##

表现形式：数组名\[下标\]\[下标\]；

eg：a\[2\]\[3\];   //下标可以是整型表达式，如a\[2 - 1\]\[2 \* 2 - 1\]。

数组元素可以出现在表达式中，也可以被赋值，例如： b\[1\]\[2\] = a\[2\]\[3\] / 2;

## 2.3 二维数组的初始化 ##

（1）分行给二维数组赋初值。

int a\[3\]\[4\] = \{ \{1, 2, 3, 4\}, \{5, 6, 7, 8\}, \{9, 10, 11, 12\}\};

或者

int a\[ \]\[4\] = \{ \{1, 2, 3, 4\}, \{5, 6, 7, 8\}, \{9, 10, 11, 12\}\}; //二维数组行参数可不写，但列参数必须要写

（2）也可以将所有数据写在一个花括号里

int a\[3\]\[4\] = \{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12\};  //不如第一种方法好

（3）对部分元素赋初值

int a\[3\]\[4\] = \{ \{1\}，\{2\}，\{3\}\}；这样三行的第一个元素分别为1,2,3.其余值为0。

或者 int a\[\]\[4\] = \{ \{0,0,3\}, \{\}, \{1,10\}\};

![70 1][]

#                    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70][] #

## 2.4 数组越界： ##

行数组越界会有错误明显提示，列数组越界不会提示。由于数组在内存中是按行顺序存储，对于越界的列数组，会按顺序显示下一行某元素的值。比如对于数组a\[2\]\[3\] = \{ \{1,2,3\},\{4,6,8\}\}，其a\[2\]\[5\] = 6,而6实际上是a\[1\]\[1\]的值

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 1][]

# 三、数组做函数参数 #

变量做函数参数时，是进行值传递的，即将实参变量的值直接传给函数的形参，这样形参改变时，不会影响实参的值。**数组**做**函数参数**时，由于数组中变量较多，所以将数组的首地址传给函数进行计算最简单，即地址传递。数组的首地址即不带下标的数组名。地址传递时，实参会随形参的变化而改变。

## 3.1 向函数传递一维数组： ##

*  传递数组的首地址，形参数组和实参数组共享同一段内存
 *  通常不指定数组的长度，用另一个形参来指定数组的大小

#include <stdio.h>
    
    void Readscore(int score[], int n)
    {
    	printf("input scores:\n");
    	for (int i = 0; i < n; i++)
    	{
    		scanf_s("%d", &score[i], 4);
    	}
    }
    
    int main()
    {
    	int score[10] = { 0 };
    	int n,aver;
    	printf("The number of students: ");
    	scanf_s("%d", &n, 4);
    	Readscore(score, n);
    	for (int i = 0; i < n; i++)
    	{
    		printf("score[%d] = %d\n", i, score[i]);
    	}
    
    	system("pause");
    	return 0;
    }

![20200309102224548.png][]

## 3.2 向函数传递二维数组 ##

可省略数组第一维的长度，不能省略第二维的长度

# 四、字符串 #

c语言中没有专门的数据类型来表示字符串类型，一般用字符数组或者字符指针来处理字符串。

## 4.1 字符数组 ##

### 4.1.1 定义 ###

*  每个元素都是字符类型的数组
 *  注：数组的最后一个元素必须是‘\\0’才表示字符串

### 4.1.2 字符数组的初始化 ###

> char array\[100\] = \{'a', 'b', 'c', 'd', '\\0'\};  //100表示字符串的长度。
> 
> 等价于
> 
> char array\[100\] = "abcd"; //后面没赋值的元素在这里不显示。

**    注：字符数组中字符串的有效字符串小于字符串长度（\[\]中的数）时，多的长度不显示，不像整型那样要用0补齐。**

还可以

> char array\[\] = "hello"; //有效长度为6，多了一个结束标志‘\\0’.

若定义一个字符串数组的时候，没写数组的长度/维数，那c语言编译器会自动根据字符串的长度自动填写。

4）char array\[20\] = \{0\};//定义一个空数组。

int main9()
    {
        int num = 0;  //字符串中字符的数量
        int len = 0;  //表示字符串的长度
    
        char buf[100] = "你"; //计算该字符串长度,即字节数量
        while(buf[len++]);
        len--;  //在while循环过程中len被多计了一次,所以要减掉
        printf("The length of buf:%d\n",len); //测一个字的长度,linux中一个汉字占3个字节,一个字母1个字节
    
        char buf1[100] = "你好世界abf";  //计算该字符串有几个字符
        while(buf1[len])
        {
            if(buf1[len] < 0)
                len += 2;
            len++;
            num++;
        }
        printf("num = %d\n",num);
    
        return 0;
    }

### ![20190719203459924.png][] ###

## 4.2 字符指针 ##

（1）若字符指针指向一个字符串常量：

![20200310170643797.png][]

可修改字符指针变量指向的字符串常量，但不能改字符串常量的值

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 2][]

（2）若字符指针指向一个字符数组，则可以改字符数组保存的内容，但数组名不能改

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 3][]

即

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 4][]

## 4.3 字符数组的输入输出 ##

**字符串和字符串结束标志：**

c语言中，是将字符串作为字符数组来处理的。通常人们只关心字符串的有效长度，而不是字符串长度。所以c语言中规定了一个“字符串结束标志”：'\\0'。其表示字符串结束，其前面的字符组成字符串输出。

### 4.3.1 字符数组的输入输出 ###

字符数组输入输出的两种方式，

> scanf（）；
> 
> printf（）；

和

> gets()；
> 
> puts()；

### 4.3.1.1 第一种方式：输入输出函数 ###

1）按字符逐个输入/输出。用格式符“%c”输入或输出一个字符，见下面代码第二种方式。

2）将整个字符串一次性输入/输出。用“%s”格式符。见下面代码第一种方式。

char b[10] = "abc";  //整个字符串一次输出
         printf("{%s}\n",b);  //注意用%s格式符输出字符串时，printf函数中的输出项是字符数组名b，而不是数组元素名b[i]
    
         char b1[100] = {'I', ' ', 'a', 'm',  ' ', 'a', ' ', 'b', 'o', 'y', '!'};  //逐个字符输入输出
         for(i = 0; i < 12; i++)
          {
            printf("%c",b1[i]);
          }
         printf("\n");

*  如果利用一个scanf函数输入多个字符串，在输入时以空格分隔，以回车键作为输入完成的标志，但回车键本身并不作为字符串的一部分。例如：

char str1, str2, str3;
    scanf("%s%s%s",str1, str2, str3);  //注：scanf函数中的输入项如果是字符数组名，则不要再加地址符&

用键盘输入：

How are you?回车

显示:

How are you?

*  scanf函数会将回车、空格都认为是字符串输入结束标志。

比如:键盘输入：hello word！
    
    显示的是：hello
    空格后面的内容都没了

要解决这种问题需要用到gets（）函数

### 4.3.1.2 第二种方式：字符串处理函数 ###

### a、 gets(字符数组）；//输入字符串，类似于scanf（）； ###

注意：

1）  gets函数认为**回车**是**输入结束标志**，*空格不是*。所以用gets函数就可以实现输入带空格的字符串

2）gets和scanf一样有缓冲区溢出的问题。

3）gets不能用"%s"或者"%d"之类的字符转义，**只接受字符串的输入。即用gets函数输入的信息都是字符串类型，你输入4，也是一个char类型的。**

**4）gets和puts函数只能输入一个字符串，**

gets(str);

**不能写成**

gets（str1， str2）；

5）上面gets（str）；的结果如下：

从键盘输入：It is a computer回车

输出显示：It is a computer

> **fgets（字符数组）；**

**    1）**gets函数不检查预留缓冲区是否能够容纳用户实际输入的数据，多出来的字符会导致内存溢出。

2）fgets函数改进了这个问题，它会将缓冲区溢出的字节去掉。调用fgets函数的时候，只要保证第二个参数小于数组实际的大小，就可以避免缓冲区溢出。

3）缺点：fgets函数是为读取文件设计的，所以读取键盘时没有gets那么方便

char s[100] = {0};
    fgets(s, sizeof(s), stdin);  //固定格式。第一个参数是char的数组名，第二个参数是数组的大小。单位：字节。第三个参数stdin代表标准输入的意思

4）第二个参数sizeof（s）表示数组的大小，还可以用具体数值表示，但一旦数组大小改变，fgets也要改，所以用sizeof（s）更方便。

### b、puts（字符数组名）//将字符串输出到终端，类似于printf。 ###

puts函数自动会在输出完成之后打印一个'\\n'出来。

#include <stdio.h>
    int main(void)  //puts/fgets输入/输出字符串
    {
        char a[100] = {0};
        fgets(a, sizeof(a), stdin);
    
        puts(a);
        return 0;
    }

结果：

![70 2][]

输入上面的“hello world”字符串，下面用puts函数输出结果。

**注：gets和puts函数只用于输入输出字符串**

## 4.4 跟字符串处理有关的函数 ##

### 4.4.1 字符串追加 ###

> strcat（字符数组1，字符数组2）;

连接两个字符数组中的字符串，把字符串2接到字符串1的后面，结果放在字符数组1中。所以数组1的长度一定要留的足够大。

int main()
    {
        char str1[50] = "hello";
        char str2[] = " world!";
        printf("%s\n",strcat(str1, str2));  //合并两个字符串，将后一个字符串放到第一个字符串后面
        return 0;
    }

![70 3][]

### 4.4.2 字符串有限追加 ###

> strncat（**字符数组1，字符数组2， 追加数量）; **

“追加数量”：在合并的时候可以限制追加多少个字符

#include <stdio.h>
    #include <string.h>
    
    int main2() //strncat合并时可限制追加多少字符
    {
       char a[20] = "hello world";
    
       char str2[50] = "!1234567894579595";
       printf("%s\n",strncat(a, str2, 5));  //合并时可限制追加多少字符
       return 0;
    
    }

![70 4][]

### 4.4.3 求字符串的实际长度 ###

> strlen（字符数组名）;

**    使用这个库函数要先加**

#include <string.h>
    int main2()
    {
       char a[100] = "hello world";
       int len = strlen(a);
       printf("len =%d\n",len);  //求字符串的实际长度
       printf("%d\n",sizeof(a));//求整个字符串数组的长度
       return 0;
    }

**![70 5][]**第二个100是用sizeof函数求出来的**。**

### 4.4.4 随机数产生函数rand和srand ###

>    \#include “stdlib.h” //引用头文件 
> 
>     rand（）；//是随机数产生器，每次调用产生的随机数是一样的。

若调用rand之前先调用srand才能出现任意随机数。只要保证每次调用srand函数的时候，参数的值是不同的，那么rand函数就一定会产生不同的随机数。

#include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
    int main(void)
    {
        time_t tm = time(NULL);//得到系统时间
        printf("tm =%u\n",tm);
    
        srand(tm);//随机数种子发生器
        int i = 0;
        for(i = 0; i < 10; i++)//控制产生的随机数的数量
        {
           int value = rand();//随机数产生器
           printf("%d\n",value);
        }
    
        return 0;
    }

[20200307160802977.png]: /images/20220527/1da45d365bb24f049371cb8e05f5e6c2.png
[70]: /images/20220527/cb4c6569463c40f68019fe150357f18b.png
[20190719191607624.png]: /images/20220527/d0db304201544c119c0ea317782cde61.png
[20180415212753520]: /images/20220527/fc48e8178a774126b8ad42184a5e0f03.png
[70 1]: /images/20220527/f1880c88e38a458bac839a6524b6b88a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70]: /images/20220527/fe4027c967fa4d4c8202c5ed17e72e12.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 1]: /images/20220527/b10e3afdf49547fd9451eb60ade9eecf.png
[20200309102224548.png]: /images/20220527/b3096af3acdf49e7b5ac9d139a65cf41.png
[20190719203459924.png]: /images/20220527/b3f4f9ed85c14e48885baa33b34385bb.png
[20200310170643797.png]: /images/20220527/99460bd0a70e454fbe6117fd05cccc4e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 2]: /images/20220527/d7b202496cb543e086efc2bd8bcd3a4d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 3]: /images/20220527/03181f5a8d7647a699e7bfa576eb80ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 4]: /images/20220527/cbd6852a1e4b4dd0a56119fb8ec5f1bf.png
[70 2]: /images/20220527/2ce632878a3441b6821cbcc531541b36.png
[70 3]: /images/20220527/070d16338cc848e5b67d04c60b5e0c55.png
[70 4]: /images/20220527/3e07f675a01448d1a32452bea0152a98.png
[70 5]: /images/20220527/87a2285690b345efa58b9949444941da.png