malloc使用语句举例

下面是一个使用malloc函数动态分配内存的例子：

#include <stdio.h>
#include <stdlib.h>

int main() {
    int n = 5;
    int *arr = (int*) malloc(n * sizeof(int)); // 分配n个int类型的内存空间
    if (arr == NULL) { // 内存分配失败
        printf("Memory allocation failed.");
        return 1;
    }
    for (int i = 0; i < n; i++) {
        arr[i] = i; // 将数组元素初始化为0~4
    }
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]); // 输出数组元素
    }
    free(arr); // 释放内存
    return 0;
}

在上面的代码中，我们使用malloc函数分配了一个包含5个int类型元素的动态数组，然后将数组元素初始化为0~4，并输出了数组元素的值。最后通过调用free函数释放了动态分配的内存空间。需要注意的是，在使用完动态分配的内存空间后，一定要记得及时释放，否则会导致内存泄漏。

相关问题

$GPVTG,156.8,T,158.8,M,11.3,N,20.9,k*46 怎么分别提取出字符串中的158.8和11.3举例详细说明，说明为什么。用C语言写，详细说明。并处理错误信息和非数字的处理方法语句

这个字符串 `$GPVTG,156.8,T,158.8,M,11.3,N,20.9,k*46` 是航海数据的一种格式，用于表示航迹矢量（GPVTG）。其中包含两个方向度数，分别是真航向（True Heading, TH）156.8° 和磁航向（Magnetic Heading, MH）158.8°，以及两个速度值，一个是真速（Speed over Ground, SOG）11.3节，另一个是航行时间（Time to Destination, TTD）20.9分钟。星号 `*` 后面的 `46` 可能代表某种额外的信息或者校验码。

要从这个字符串中提取数值，我们可以使用 C 语言的字符串操作函数。这里我们主要关注的是如何提取两个角度和一个速度值。首先，我们需要定义一个结构体来存储这些值，并编写一个函数来解析字符串。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

// 定义一个结构体来保存数据
typedef struct {
    double true_heading;
    double magnetic_heading;
    double speed;
    char *additional_info; // 存储剩余字符
} GPVTGData;

// 函数来解析字符串
GPVTGData parse_GPVTG(const char *str) {
    GPVTGData data;
    char *token;
    double value;
    int is_number = 1; // 标记是否正在读取数字

    // 初始化数据
    data.true_heading = 0;
    data.magnetic_heading = 0;
    data.speed = 0;
    data.additional_info = (char *)malloc(strlen(str) + 1); // 预留空间

    token = strtok(str, ",TKMNS"); // 分割符为逗号、T（航向类型）、K（航程类型）、M/N（航向单位）
    while (token != NULL) {
        if (!strcmp(token, "T")) { // 真航向
            token = strtok(NULL, ",TKMNS");
            if (is_number && sscanf(token, "%lf", &value) == 1) {
                data.true_heading = value;
            } else {
                printf("Error: Non-numeric value for True Heading.\n");
                return data;
            }
        } else if (!strcmp(token, "M")) { // 磁航向
            token = strtok(NULL, ",TKMNS");
            if (is_number && sscanf(token, "%lf", &value) == 1) {
                data.magnetic_heading = value;
            } else {
                printf("Error: Non-numeric value for Magnetic Heading.\n");
                free(data.additional_info);
                return data;
            }
        } else if (!strcmp(token, "S") || !strcmp(token, "N")) { // 速度
            token = strtok(NULL, ",TKMNS");
            if (is_number && sscanf(token, "%lf", &value) == 1) {
                data.speed = value;
            } else {
                printf("Error: Non-numeric value for Speed.\n");
                free(data.additional_info);
                return data;
            }
        } else { // 剩余字符
            strcpy(data.additional_info, token);
            break;
        }

        token = strtok(NULL, ",TKMNS");
    }

    data.additional_info[strlen(data.additional_info) - 1] = '\0'; // 删除多余的分割符
    return data;
}

int main() {
    const char *input = "$GPVTG,156.8,T,158.8,M,11.3,N,20.9,k*46";
    GPVTGData parsed_data = parse_GPVTG(input);

    if (parsed_data.speed > 0) {
        printf("Speed: %.2f knots\n", parsed_data.speed);
    } else {
        printf("Invalid speed value.\n");
    }

    if (parsed_data.true_heading > 0) {
        printf("True Heading: %.2f degrees\n", parsed_data.true_heading);
    } else {
        printf("Invalid true heading value.\n");
    }

    if (parsed_data.magnetic_heading > 0) {
        printf("Magnetic Heading: %.2f degrees\n", parsed_data.magnetic_heading);
    } else {
        printf("Invalid magnetic heading value.\n");
    }

    return 0;
}

在这个示例中，`parse_GPVTG()` 函数首先初始化变量，然后遍历字符串，根据分割符找到每个值的位置。如果遇到非数字字符，`sscanf()` 将返回小于 1 的值，我们会认为这不是有效的数值，打印错误信息并提前结束解析。

在 `main()` 中，我们检查解析得到的速度是否有效，因为速度通常是正数。如果速度无效，我们也会显示一条错误消息。同样的逻辑也适用于其他两个航向值。

程序译码的过程是怎样的，能否举例说明

### 赫夫曼译码过程

#### 过程概述
1. **读取编码文件**：程序首先从 `CodeFile.txt` 中读取编码后的二进制字符串。
2. **初始化变量**：设置初始位置 `m` 为赫夫曼树的根节点（即 `2*n-1`），其中 `n` 是字符的数量。
3. **遍历编码字符串**：从第一个字符开始，逐位检查编码字符串中的每一个 `'0'` 或 `'1'`。
- 如果遇到 `'0'`，则移动到当前节点的左孩子。
- 如果遇到 `'1'`，则移动到当前节点的右孩子。
4. **到达叶节点**：当移动到一个没有孩子的节点时，该节点的字符就是解码出的一个字符。
5. **重置位置**：解码出一个字符后，重新将位置 `m` 设置为根节点，继续处理下一个编码字符。
6. **生成解码结果**：将解码出的所有字符依次添加到结果字符串中，并将其写入 `TxtFile.txt`。

#### 示例说明
假设我们有以下赫夫曼树：

        *(10)
       /     \
    A(3)    *(7)
           /     \
        B(2)    C(5)

对应的赫夫曼编码表为：
- `A -> 0`
- `B -> 10`
- `C -> 11`

假设编码后的字符串为 `"01011"`，我们来逐步解码这个字符串：

1. **初始状态**：
- 当前节点：`(10)`
- 编码字符串：`"01011"`

2. **第一位 '0'**：
- 移动到左孩子：`A(3)`
- 解码出字符 `A`
- 重置当前节点为 `(10)`
- 剩余编码字符串：`"1011"`

3. **第二位 '1'**：
- 移动到右孩子：`(7)`
- 重置当前节点为 `(10)`
- 剩余编码字符串：`"11"`

4. **第三位 '1'**：
- 移动到右孩子：`(7)`
- 下一位 '1'：
- 移动到右孩子：`C(5)`
- 解码出字符 `C`
- 重置当前节点为 `(10)`
- 剩余编码字符串：`""`

最终解码结果为：`"ABC"`

#### 代码实现
以下是 `Decoding` 函数的部分代码，展示了上述过程的具体实现：

void Decoding() {
    int m, i, p = 0;
    char q, *Decode, *Sentence;
    FILE *FDecodeP = fopen("C:\\Users\\a1370\\Desktop\\CodeFile.txt", "r");
    if (NULL == FDecodeP) {
        printf("打开 CodeFile.txt 文件失败!\n");
        return;
    }
    FILE *TxtFile = fopen("C:\\Users\\a1370\\Desktop\\TxtFile.txt", "w");
    if (NULL == TxtFile) {
        printf("打开 TxtFile.txt 文件失败!\n");
        return;
    }

    Sentence = (char *)malloc(TempLen * sizeof(char));
    Decode = (char *)malloc(code_num * sizeof(char));
    fgets(Decode, code_num + 1, FDecodeP);
    m = 2 * n - 1;

    for (i = 0; Decode[i] != '\0'; i++) {
        q = Decode[i];
        if (HT[m].lchild == 0) {
            Sentence[p] = HT[m].elem;
            p++;
            m = 2 * n - 1;
            i--;
        } else if (q == '0') {
            m = HT[m].lchild;
        } else if (q == '1') {
            m = HT[m].rchild;
        }
    }
    Sentence[p] = '\0';
    fputs(Sentence, TxtFile);
    printf("解码获得语句:\n%s\n", Sentence);
    printf("语句被输入 TxtFile.txt!\n");

    free(Sentence);
    free(Decode);
    fclose(FDecodeP);
    fclose(TxtFile);
}

通过上述过程，程序能够成功地将编码后的二进制字符串转换回原始的字符序列。