【C语言】学习笔记第8章数组 8.1 一维数组

妖狐艹你老母 2024-03-22 09:45 38阅读 0赞

### 【C语言】学习笔记 ###

#### 文章目录 ####

*   *  【C语言】学习笔记
     *   *  第8章 数组
         *   *  8.1 一维数组
             *   *  8.1.1 数组下标
                 *  8.1.2 数组初始化
                 *  8.1.3 指示器\`C99\`
                 *  8.1.4 对数组使用sizeof运算符

#### 第8章 数组 ####

![在这里插入图片描述][09c872fbdbaa439789dbf443082e9e8b.png_pic_center]

如果程序操纵着大量的数据，那它一定是用较少的方法办到的。到这里之前，我们所见的变量都只是标量（scalar）：标量具有保存单一数据项的能力。 C 语言也支持聚合（aggregate）变量，这类变量可以存储**成组**的数值。

在 C 语言中一共有两种 聚合类型：**数组（array）和结构（structure）**。

##### 8.1 一维数组 #####

数组是含有多个数据值的数据结构，并且每个数据值具有**相同的数据类型**。这些数据值称 为**元素**（element），可以根据元素在数组中所处的位置把它们一个个地选出来。

为了声明数组，需要指明数组元素的类型和数量。例如，为了声明数组 a 有 10 个 int 类 型的元素，可以写成

int a[10];

数组的元素可以是任何类型，数组的长度可以用任何（整数）常量表达式指定。 因为程序以后改变时可能需要调整数组的长度，所以较好的方法是用宏来定义数组的长度：

#define N 10 
    ... 
    int a[N];

###### 8.1.1 数组下标 ######

为了存取特定的数组元素，可以在写数组名的同时在后边加上一个用方括号围绕的整数值 ［这被称为**对数组取下标**（subscripting）或**进行索引**（indexing）］

数组元素始终从 0 开始， 因此长度为 n 的数组元素的索引是 0~n - 1。

数组元素可以像普通变量一样使用：

a[0] = 1; 
    printf("%d\n", a[5]); 
    ++a[i];

在长度为 N 的数组 a 上的一些常见操作：

*      for (i = 0; i < N; i++) 
            a[i] = 0; /* clears a */
 *      for (i = 0; i < N; i++) 
            scanf("%d", &a[i]); /* reads data into a */
 *      for (i = 0; i < N; i++) 
            sum += a[i]; /* sums the elements of a */

C 语言不要求检查下标的范围。当下标超出范围时，程序可能执行**不可预知的行为**。

数组下标可以是任何整数表达式：

a[i+j*10] = 0;

表达式甚至可能会有副作用：

i = 0; 
    while (i < N) 
        a[i++] = 0;

【程序】数列反向

要求用户输入一串数，然后按反向顺序输出这些数：

方法是在读入数时将其存储在一个数组中，然后反向遍历数组，一个接一个地显示出数组元素。

`reverse.c`

#include <stdio.h>
    
    #define N 10
    
    int main(void) {
        
    
        int a[N], i;
    
        printf("Enter %d numbers: ", N);
    
        for (i = 0; i < N; i++)
            scanf("%d", &a[i]);
    
        printf("In reverse order:");
        for (i = N - 1; i >= 0; i--)
            printf(" %d", a[i]);
    
        printf("\n");
    
        return 0;
    }

![在这里插入图片描述][d41caf41785f458db1f8240a213b6a55.png_pic_center]

###### 8.1.2 数组初始化 ######

像其他变量一样，数组也可以在声明时获得一个初始值。但是，数组初始化的规则不太好 掌握，因此我们现在介绍一些，其他的后面细说：

*  数组初始化器（array initializer）最常见的格式是一个用**花括号括起来的常量表达式列表**，常量表达式之间用逗号进行分隔：
    
        int a[10] = {
              1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 *  如果初始化器比数组短，那么数组中剩余的元素赋值为 0：
    
        int a[10] = {
              1, 2, 3, 4, 5, 6}; 
         /* initial value of a is {1, 2, 3, 4, 5, 6, 0, 0, 0, 0} */
 *  利用这一特性，可以很容易地把数组初始化为全 0：
    
        int a[10] = {
              0}; 
         /* initial value of a is {0, 0, 0, 0, 0, 0, 0, 0, 0, 0} */
 *  初始化器**完全为空是非法的**，所以要在花括号内放上一个 0。**初始化器比要初始化的数组长也 是非法的**。
 *  如果给定了初始化器，可以省略数组的长度：
    
        int a[] = {
              1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    编译器利用初始化器的长度来确定数组的大小。数组仍然有固定数量的元素

###### 8.1.3 指示器`C99` ######

经常有这样的情况：数组中只有相对较少的元素需要进行显式的初始化，而其他元素可以 进行默认赋值。

举个栗子：

int a[15] = {
        0, 0, 29, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 48};

当然我们会感觉这样好像用初始化器好像还好，但是想象一下如果两个非0元素之间有200个0…

C99 中的指示器可以用于解决这一问题。上面的例子可以用指示器写为

int a[15] = {
        [2] = 29, [9] = 7, [14] = 48};

方括号和其中的常量表达式一起，**组成一个指示器**。

除了可以使赋值变得更简短、更易读之外，指示器还有一个优点：**赋值的顺序不再是一个 问题**，我们也可以将先前的例子重写为

int a[15] = {
        [2] = 29, [9] = 7, [14] = 48};

组成指示器的方括号里必须是整型常量表达式。如果待初始化的数组长度为 n，则每个表 达式的值都必须在 0 和 n - 1 之间。但是，如果数组的长度是省略的，指示器可以指定任意非负 整数；对于后一种情况，编译器**将根据最大的值**推断出数组的长度。

而且初始化器中可以**同时使用**老方法（逐个元素初始化）和新方法（指示器）：

int c[10] = {
        5, 1, 9, [4] = 3, 7, 2, [8] = 6};

**【程序】检查数中重复出现的数字**

接下来这个程序用来检查数中是否有出现多于一次的数字。用户输入数后，程序显示信息 Repeated digit 或 No Repeated digit：

数 28212 有一个重复的数字（即 2），而 9357 这样的数则没有。

`repdigit.c`

#include <stdio.h>
    #include <stdbool.h>
    
    int main(void) {
        
    
        bool digit_seen[10] = {
         false }; // 0和false是一样的, digit_seen 是一个全false(0) 的数组
        int digit;
        long n;
    
        printf("Enter a number: ");
        scanf("%ld", &n);
    
        while (n > 0) {
        
            digit = n % 10;
    
            if (digit_seen[digit]) {
        
                break;
            }
            digit_seen[digit] = true;
            n /= 10;
        }
    
        if (n > 0) {
        
            printf("Repeated digit\n");
        }
        else {
        
            printf("No repeated digit\n");
        }
    
        return 0;
    }

![在这里插入图片描述][4a5315fee25e4c59935c1483bd36a1c2.png_pic_center]

这个程序用到了 bool、true 和 false 等名称，它们在 C99 的`<stdbool>`头

###### 8.1.4 对数组使用sizeof运算符 ######

运算符 sizeof 可以确定**数组的大小（字节数）**。如果数组 a 有 10 个整数，那么 sizeof(a) 通常为 40（假定每个整数占 4 字节）

还可以用 sizeof 来计算数组元素（如 a\[0\]）的大小。用数组的大小除以数组元素的大小 可以得到数组的长度：

sizeof(a) / sizeof(a[0])

例如，数组 a 的清零操作可以写成如下形式：

for (i = 0; i < sizeof(a) / sizeof(a[0]); i++) 
        a[i] = 0;

如果使用这种方法，即使数组长度在日后需要改变，也不需要改变循环。

为了避免出现`变量i 的类型可能是int(有符号整型 ),sizeof 返回的值类型为 size_t（无符号 类型）`这一警告，可以将 i 的类型改成 t，或者像下面这样，将 sizeof(a) / sizeof(a\[0\])强制转换为有符号整数：

for (i = 0; i < (int) (sizeof(a) / sizeof(a[0])); i++)  
        a[i] = 0;

定义一个宏来表示常常 是很有帮助的：

#define SIZE ((int) (sizeof(a) / sizeof(a[0]))) 
    
    for (i = 0; i < SIZE; i++)  
        a[i] = 0;

> 这样看起来，就使用宏了，sizeof 的优势就没了，【这个问题我们后面会学到带参数的宏】

**【程序】计算利息**

下面这个程序显示一个表格，这个表格显示了在几年时间内 100 美元投资在不同利率下的 价值。用户输入利率和要投资的年数。投资总价值每年计算一次，表格将显示出在输入利率和 紧随其后的 4 个更高的利率下投资的总价值。程序会话如下：

Enter interest rate: 6
    Enter number of years: 5
    
    Years   6%      7%      8%      9%      10% 
      1   106.00  107.00  108.00  109.00  110.00 
      2   112.36  114.49  116.64  118.81  121.00 
      3   119.10  122.50  125.97  129.50  133.10 
      4   126.25  131.08  136.05  141.16  146.41 
      5   133.82  140.26  146.93  153.86  161.05

`interest.c`

#include <stdio.h> 
    
    #define NUM_RATES ((int) (sizeof(value) / sizeof(value[0]))) 
    
    #define INITIAL_BALANCE 100.00 
    
    
    int main(void)
    {
        
        int i, low_rate, num_years, year;
        double value[5];
    
        printf("Enter interest rate: ");
        scanf("%d", &low_rate);
    
        printf("Enter number of years: ");
        scanf("%d", &num_years);
    
        printf("\nYears");
    
        for (i = 0; i < NUM_RATES; i++) {
        
            printf("%7d%%", low_rate + i);
            value[i] = INITIAL_BALANCE;
        }
    
        printf("\n");
    
        for (year = 1; year <= num_years; year++) {
        
            printf("%3d ", year);
            for (i = 0; i < NUM_RATES; i++) {
        
                value[i] += (low_rate + i) / 100.0 * value[i];
                printf("%9.2f", value[i]);
            }
            printf("\n");
        }
    
        return 0;
    }

![在这里插入图片描述][377630cfd0224384b57791fb04a9f722.png_pic_center]

[09c872fbdbaa439789dbf443082e9e8b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/b977675ade8d4c0a983914576cda848d.png
[d41caf41785f458db1f8240a213b6a55.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/63301989fe0c465b902ceb04878efb92.png
[4a5315fee25e4c59935c1483bd36a1c2.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/02f159deef194493b1ab2eaa673bd328.png
[377630cfd0224384b57791fb04a9f722.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/37c22f6d5ae74970a4e84d33c2a48ded.png