_{C++基础教程}
——
作业及参考答案全部汇总文档
^{_节7指针高级阶段作业}

最新版本V2.0
王道C++团队
COPYRIGHT ⓒ 2021-2024. 王道版权所有

基础题篇

_Gn!

下面都是一些基础的语法、概念编程练习题。

实现动态拼接字符串

_Gn!

标准库函数strcat会将一个字符串追加到另一个字符串的末尾。

现在我们编写一个函数把两个字符串拼接起来，返回拼接的结果，但要求不改变其中任何一个字符串。其函数声明如下：

xxxxxxxxxx
1
1
char* my_strcat(const char* prefix, const char* suffix);

形参prefix表示前缀，suffix表示后缀，拼接的结果是prefix + suffix

比如：my_strcat("abc", "d")，拼接的结果是"abcd"。

思路：

1. 在堆上分配内存空间，用于存储结果字符串。

2. 将prefix和suffix两个字符串的字符信息复制进去。

参考代码如下：

参考代码：

这个问题非常简单，是一个基础的动态内存分配问题。参考代码如下：

xxxxxxxxxx
29
1
// 在堆上动态分配内存拼接两个字符串
2
char* dynamic_strcat(const char* prefix, const char* suffix) {
3
    // 计算拼接后字符串的长度
4
    int new_str_len = strlen(prefix) + strlen(suffix);
5
    char *new_str = malloc(new_str_len + 1);    // char在各平台上长度都是1，所以不用乘了
6

7
    if (new_str == NULL) {
8
        printf("ERROR: malloc failed in dynamic_strcat!\n");
9
        exit(1);
10
    }
11

12
    // 长度是精确计算得出的，不用担心越界访问
13
    strcat(strcpy(new_str, prefix), suffix);
14

15
    return new_str;
16
}
17

18
int main(void) {
19
    char str1[] = "hello";
20
    char str2[] = " world!";
21
    char* result_str = dynamic_strcat(str1, str2);  // 注意只要涉及动态内存分配，一律用指针类型。这里不能用数组类型
22

23
    puts(result_str);
24

25
    // 现在不再使用result字符串了，不要忘记free它
26
    free(result_str);
27

28
    return 0;
29
}

以上。

手动实现动态数组Vector

_Gn!

手动实现动态数组Vector，基于以下结构体定义和函数声明：

xxxxxxxxxx
27
1
typedef int ElementType;
2

3
typedef struct {
4
    ElementType *data;   // 指向堆空间的数组
5
    int size;   // 元素的个数
6
    int capacity; // 数组的容量
7
} Vector;
8

9
// 请实现下面方法
10

11
// 初始化一个Vector动态数组
12
Vector *vector_create(void);
13

14
// 销毁一个Vector动态数组，释放内存。
15
void vector_destroy(Vector *v);
16

17
// 向动态数组末尾添加一个元素
18
void vector_push_back(Vector *v, ElementType val);
19

20
// 在动态数组最前面添加元素，所有元素依次后移
21
void vector_push_front(Vector *v, ElementType val);
22

23
// 将元素val添加到索引为idx的位置，idx后面的元素依次后移
24
void vector_insert(Vector *v, int idx, ElementType val);
25

26
// 遍历打印整个Vector动态数组
27
void vector_print(Vector *v);

注意：

你应该将上述代码放在头文件中，并且自己添加头文件保护语法。

提交作业时，你应该提交头文件，实现Vector的源文件，测试源文件三个文件的代码

参考代码如下：

参考代码：

头文件加上保护语法，代码如下：

xxxxxxxxxx
32
1
#ifndef VECTOR_H
2
#define VECTOR_H
3

4
typedef int ElementType;
5

6
typedef struct {
7
    ElementType *data;   // 指向堆空间的数组
8
    int size;   // 元素的个数
9
    int capacity; // 数组的容量
10
} Vector;
11

12
// 请实现下面方法
13

14
// 初始化一个Vector动态数组
15
Vector *vector_create(void);
16

17
// 销毁一个Vector动态数组，释放内存。
18
void vector_destroy(Vector *v);
19

20
// 向动态数组末尾添加一个元素
21
void vector_push_back(Vector *v, ElementType val);
22

23
// 在动态数组最前面添加元素，所有元素依次后移
24
void vector_push_front(Vector *v, ElementType val);
25

26
// 将元素val添加到索引为idx的位置，idx后面的元素依次后移
27
void vector_insert(Vector *v, int idx, ElementType val);
28

29
// 遍历打印整个Vector动态数组
30
void vector_print(Vector *v);
31

32
#endif // !VECTOR_H

实现源文件代码：

xxxxxxxxxx
115
1
#include "vector.h"
2
#include <stdio.h>
3
#include <stdlib.h>
4

5
#define DEFAULT_CAPACITY 8
6
#define THRESHOLD 1024
7

8

9
// 在C语言中,static修饰函数表示此函数仅在当前文件内部生效
10
// 类似于C++或Java中的访问权限修饰符private
11
static void vector_resize(Vector *v) {
12
    // 只要调用这个函数肯定就是需要扩容的
13
    int old_capacity = v->capacity;
14

15
    int new_capacity = (old_capacity < THRESHOLD) ?
16
        (old_capacity << 1) :   // 容量还未超出阈值每次扩容2倍
17
    (old_capacity + (old_capacity >> 1));       // 容量超出阈值每次扩容1.5倍
18

19
    // 利用realloc重新分配动态数组
20
    // realloc惯用法
21
    ElementType *tmp = realloc(v->data, new_capacity * sizeof(ElementType));    
22
    if (tmp == NULL) {
23
        printf("realloc failed in resize_vector.\n");
24
        exit(1);    // 扩容失败，退出整个程序。或者也可以做别的处理
25
    }
26
    // 扩容成功，重新赋值Vector成员
27
    v->data = tmp;
28
    v->capacity = new_capacity;
29
}
30

31
// 初始化一个Vector动态数组
32
Vector *vector_create(void) {
33
    // 先在堆上申请结构体
34
    Vector *v = calloc(1, sizeof(Vector));
35
    if (v == NULL) {
36
        printf("calloc failed in vector_create.\n");
37
        return NULL;    // 创建失败返回空指针
38
    }
39

40
    // 申请动态数组，并初始化Vector的data成员
41
    v->data = calloc(DEFAULT_CAPACITY, sizeof(ElementType));
42
    if (v->data == NULL) {
43
        printf("malloc failed in vector_create.\n");
44
        // 不要忘记free结构体Vector，否则会导致内存泄漏
45
        free(v);
46
        return NULL;    // 创建失败返回空指针
47
    }
48

49
    // 继续初始化Vector的其它成员
50
    v->capacity = DEFAULT_CAPACITY;
51

52
    return v;
53
}
54

55
// 销毁一个Vector动态数组，释放内存。
56
void vector_destroy(Vector *v) {
57
    free(v->data);
58
    free(v);
59
}
60

61
// 向动态数组末尾添加一个元素
62
void vector_push_back(Vector *v, ElementType val) {
63
    // 先判断是否需要扩容
64
    if (v->capacity == v->size) {
65
        vector_resize(v);
66
    }
67
    // 扩容完成后或不需要扩容，即向末尾添加元素
68
    v->data[v->size] = val;
69
    v->size++;
70
}
71

72
// 在动态数组最前面添加元素，所有元素依次后移
73
void vector_push_front(Vector *v, ElementType val) {
74
    // 先判断是否需要扩容
75
    if (v->capacity == v->size) {
76
        vector_resize(v);
77
    }
78
    // 扩容完成后或不需要扩容，即从首元素开始将所有元素向后移动
79
    // 倒着遍历数组方便向后移动元素
80
    for (int i = v->size - 1; i >= 0; i--) {
81
        v->data[i + 1] = v->data[i];
82
    }
83
    // 新增的元素成为首元素
84
    v->data[0] = val;
85
    v->size++;
86
}
87

88
// 将元素val添加到索引为idx的位置，idx后面的元素依次后移
89
void vector_insert(Vector *v, int idx, ElementType val) {
90
    // 先做参数校验，避免传入非法索引
91
    if (idx < 0 || idx > v->size) {     // 做插入操作时索引合法范围是[0, size]
92
        printf("Illegal argument: idx = %d, size = %d\n", idx, v->size);
93
        exit(1);    // 直接退出进程，也可以用别的方式进行错误处理
94
    }
95
    // 判断是否需要扩容
96
    if (v->capacity == v->size) {
97
        vector_resize(v);
98
    }
99
    // 扩容完成后或不需要扩容，即从原本的idx元素开始将所有元素向后移动
100
    for (int i = v->size - 1; i >= idx; i--) {
101
        v->data[i + 1] = v->data[i];
102
    }
103
    // idx位置空出来,将它放进去
104
    v->data[idx] = val;
105
    v->size++;
106
}
107

108
// 遍历打印整个Vector动态数组
109
void vector_print(Vector *v) {
110
    printf("[");
111
    for (int i = 0; i < v->size; i++){
112
        printf("%d, ", v->data[i]);
113
    }
114
    printf("\b\b]\n");
115
}

测试用例代码：

xxxxxxxxxx
30
1
#define _CRT_SECURE_NO_WARNINGS
2
#include <stdio.h>
3
#include <stdlib.h>
4
#include "vector.h"
5

6
#define N 100
7
int main(void) {
8
    Vector *v = vector_create();
9
    if (v == NULL) {
10
        printf("error: vector_create failed in main.\n");
11
        exit(1);
12
    }
13

14
    // 测试自动扩容机制
15
    for (int i = 0; i < N; ++i) {
16
        vector_push_back(v, i + 1);
17
    }
18
    vector_print(v);    // 期望打印结果: 1-100
19

20
    // 测试头部插入新元素
21
    vector_push_front(v, 0);
22
    vector_print(v);    // 期望打印结果: 0, 1-100
23

24
    // 测试根据索引插入新元素
25
    vector_insert(v, 0, -1);
26
    vector_print(v);    // 期望打印结果: -1, 0, 1-100
27

28
    vector_destroy(v);
29
    return 0;
30
}

以上。

二级指针基础练习题

_Gn!

在main函数中定义两个局部变量：

xxxxxxxxxx
2
1
int a = 10;
2
int b = 20;

请实现以下两个函数，用于完成局部变量a和b的交换：

xxxxxxxxxx
2
1
void swap(int *pa, int *pb);
2
void swap2(int **pa, int **pb);

这两个函数都应该可以实现交换a和b的值。

参考代码如下：

参考代码如下：

xxxxxxxxxx
37
1
#define _CRT_SECURE_NO_WARNINGS
2
#include <stdio.h>
3

4
// 函数声明
5
void swap(int *pa, int *pb);
6
void swap2(int **pa, int **pb);
7

8
int main(void) {
9
    int a = 10;
10
    int b = 20;
11
    int *ptrA = &a;
12
    int *ptrB = &b;
13

14
    printf("初始值：a = %d, b = %d\n", a, b);
15

16
    // 使用一级指针交换值
17
    swap(&a, &b);
18
    printf("使用 swap 函数第一次交换后：a = %d, b = %d\n", a, b);
19

20
    // 使用二级指针交换指针
21
    swap2(&ptrA, &ptrB);
22
    printf("使用 swap2 函数再次交换后：a = %d, b = %d\n", *ptrA, *ptrB);
23

24
    return 0;
25
}
26

27
void swap(int *pa, int *pb) {
28
    int temp = *pa;
29
    *pa = *pb;
30
    *pb = temp;
31
}
32

33
void swap2(int **pa, int **pb) {
34
    int temp = **pa;
35
    **pa = **pb;
36
    **pb = temp;
37
}

以上。

二级指针/单链表练习题

_Gn!

基于以下链表结点结构体类型的定义:

xxxxxxxxxx
5
1
typedef int ElementType;
2
typedef struct node {
3
  int data;
4
  struct node* next;
5
} Node;

在main函数中定义一个head头指针等于NULL代表此时单链表为空：

xxxxxxxxxx
1
1
Node *head = NULL;

利用二级指针语法实现以下函数：

xxxxxxxxxx
8
1
// 头插法新增一个结点
2
void insert_head(Node** head, ElementType new_val);
3
// 修改第一个结点的元素值，如果链表为空，则用new_val初始化第一个结点
4
void modify_first_node(Node** head, int new_val);
5
// 尾插法新增一个结点
6
void insert_tail(Node** head, ElementType new_val);
7
// 打印单链表 格式为：1 -> 2 -> 3 ->...
8
void print_list(Node *head);

注：尾插法会稍微麻烦一些，可以放在最后实现。

参考代码如下：

参考代码：

参考代码如下：

xxxxxxxxxx
104
1
#include <stdio.h>
2
#include <stdlib.h>
3

4
typedef struct node {
5
    int data;
6
    struct node *next;
7
} Node;
8

9
// 单链表的头插法
10
void insert_head(Node **head, int new_val) {
11
    // 1.创建新节点
12
    Node *new_node = malloc(sizeof(Node));
13
    if (new_node == NULL) {
14
        printf("malloc failed in insert_head.\n");
15
        exit(1);
16
    }
17
    // 2.初始化新节点的数据域
18
    new_node->data = new_val;
19
    // 3.新结点的next指针指向原本第一个节点
20
    new_node->next = *head;
21
    // 4.将头指针指向新结点
22
    *head = new_node;
23
}
24

25
// 修改第一个结点的元素值
26
void modify_first_node(Node **head, int new_val) {
27
    if (*head == NULL) {
28
        // 当前单链表为空，此时为头插法
29
        *head = malloc(sizeof(Node));
30
        if (*head == NULL) {
31
            printf("malloc failed in modify_first_node.\n");
32
            exit(1);
33
        }
34
        (*head)->data = new_val;
35
        (*head)->next = NULL;
36
    }
37
    else {
38
        (*head)->data = new_val;
39
    }
40
}
41

42
// 优化：既然头插法已经实现了，那么也可以直接调用，而不是重新实现
43
void modify_first_node2(Node **head, int new_val) {
44
    if (*head == NULL) { // 链表为空时，初始化第一个节点
45
        insert_head(head, new_val);
46
    }
47
    else { // 链表非空时，修改第一个节点的数据
48
        (*head)->data = new_val;
49
    }
50
}
51

52
// 尾插法新增一个结点
53
void insert_tail(Node **head, int val) {
54
    // 创建新结点
55
    Node *new_node = (Node *)malloc(sizeof(Node));
56
    if (new_node == NULL) {
57
        printf("malloc failed in insert_tail.\n");
58
        exit(-1);
59
    }
60
    new_node->data = val; // 设置新节点的数据
61
    new_node->next = NULL; // 新节点将成为尾节点，其下一个节点指针为NULL
62

63
    if (*head == NULL) {
64
        // 如果链表为空，新节点即为第一个结点
65
        *head = new_node;
66
    }
67
    else {
68
        // 遍历找到当前链表的最后一个结点
69
        Node *curr = *head;
70
        while (curr->next != NULL) {
71
            curr = curr->next;
72
        }
73
        curr->next = new_node; // 将新节点追加到链表尾部
74
    }
75
}
76

77
// 打印单链表 格式为：1 -> 2 -> 3 ->...
78
void print_list(Node *head) {
79
    Node *curr = head;
80
    while (curr != NULL) {  // 遍历此单链表
81
        printf("%d", curr->data);
82
        if (curr->next != NULL) {
83
            printf(" -> ");
84
        }
85
        curr = curr->next;
86
    }
87
    printf("\n");
88
}
89

90
// 测试用例
91
int main(void) {
92
    // 初始化一个空链表
93
    Node *head = NULL;
94
    insert_head(&head, 5);
95
    insert_head(&head, 4);
96
    insert_head(&head, 3);
97
    insert_head(&head, 2);
98
    insert_head(&head, 1);
99

100
    modify_first_node(&head, 100);
101
    insert_tail(&head, 6);
102
    print_list(head);
103
    return 0;
104
}

以上。

qsort函数基础语法练习

_Gn!

给你下面一个Student，学生结构体类型的定义:

xxxxxxxxxx
5
1
// Student学生结构体类型定义
2
typedef struct {
3
  char name[25];
4
 int score;
5
} Student;

假设你有一个学生结构体对象数组，如下所示:

xxxxxxxxxx
12
1
Student stus[] = {
2
    {"Alice", 85},
3
    {"Bob", 92},
4
    {"Charlie", 85},
5
    {"David", 85},
6
    {"Eve", 92},
7
    {"Frank", 75},
8
    {"Grace", 85},
9
    {"Hannah", 95},
10
    {"Ivy", 78},
11
    {"Jack", 85}
12
};

你的任务是使用qsort函数对这个结构体数组进行排序：

1. 规则1：将全体结构体对象，按照学生成绩从高到低进行排序。

2. 规则2：先将全体结构体对象，按照学生成绩从低到高进行排序，如果成绩一致，则那么按照名字的字典顺序进行排序。

最后，你还需要实现一个函数用于打印整个学生数组：

xxxxxxxxxx
1
1
void print_students(Student stus[], int size);

参考代码如下：

参考代码如下：

可以直接用上面题目中给出的数据，不需要自己编数据了：

xxxxxxxxxx
66
1
#define _CRT_SECURE_NO_WARNINGS
2
#include <stdio.h>
3
#include <string.h>
4
#define ARR_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))
5

6
typedef struct {
7
    char name[25];
8
    int score;
9
} Student;
10

11

12
// 比较函数1：按成绩从高到低排序
13
int compare_scores_desc(const void *a, const void *b) {
14
    Student *stu1 = (Student *)a;
15
    Student *stu2 = (Student *)b;
16
    return stu2->score - stu1->score;  // 逆序排列
17
}
18

19
// 比较函数2：按成绩从低到高排序，成绩相同则按名字字典顺序排序
20
int compare_scores_asc(const void *a, const void *b) {
21
    Student *stu1 = (Student *)a;
22
    Student *stu2 = (Student *)b;
23
    if (stu1->score == stu2->score) {
24
        return strcmp(stu1->name, stu2->name);  // 字典序比较名字
25
    }
26
    return stu1->score - stu2->score;  // 正序排列
27
}
28

29
// 打印学生数组的全部对象
30
void print_students(Student stus[], int size) {
31
    for (int i = 0; i < size; i++) {
32
        printf("Name: %s, Score: %d\n", stus[i].name, stus[i].score);
33
    }
34
    printf("\n");
35
}
36

37
int main(void) {
38
    Student stus[] = {
39
        {"Alice", 85},
40
        {"Bob", 92},
41
        {"Charlie", 85},
42
        {"David", 85},
43
        {"Eve", 92},
44
        {"Frank", 75},
45
        {"Grace", 85},
46
        {"Hannah", 95},
47
        {"Ivy", 78},
48
        {"Jack", 85}
49
    };
50
    int len = ARR_SIZE(stus);
51

52
    printf("原始学生数组是:\n");
53
    print_students(stus, len);
54

55
    // 按规则1排序：成绩从高到低
56
    qsort(stus, len, sizeof(Student), compare_scores_desc);
57
    printf("将学生按照成绩由高到低排序:\n");
58
    print_students(stus, len);
59

60
    // 按规则2排序：成绩从低到高，成绩相同按名字排序
61
    qsort(stus, len, sizeof(Student), compare_scores_asc);
62
    printf("将学生按照成绩和名字综合排序:\n");
63
    print_students(stus, len);
64

65
    return 0;
66
}

以上。

扩展题篇

_Gn!

以下题目都属于扩展题。

扩展：动态字符串Vector

_Gn!

你已经手动实现了一个自己的Vector，很好，这很酷。那么请思考和完成以下扩展的题目。

现在请你回答第一个问题：

原本的动态数组用于存储int类型元素，是int类型动态数组。现在我希望你能把它变成字符串动态数组，应该怎么改代码吗？

如果仅在原本代码的基础上修改ElementType的类型，那么请你思考第二个问题：

此时Vector虽然能存字符串了，但只能存什么字符串呢？

把以上问题都考虑清楚后，请完成以下测试工作：

使用push_back函数向动态字符串数组中循环添加100个字符串元素，这些字符串依次是：

"0"

"01"

"012"

"0123"

...... "01234567890"

"012345678901"

"0123456789012"

....

添加完成后，请遍历打印这个动态字符串数组。请将这段测试动态字符串数组Vector的代码贴在答案里。

Vector的其它实现代码不需要贴进来。

注意，实现这个需求时，不需要考虑字符串的生命周期问题。

参考回答如下：

参考代码：

前两个问题的答案：

1. 只需要把ElementType的类型从int改为char *就可以了。

2. 如果只是改变ElementType的类型，那么从最佳实践出发：

   1. 这个Vector最好存储字面值字符串、全局变量等静态存储期限的字符。因为不用考虑它们的生命周期问题，它们在整个程序运行期间都生效。

   2. 如果存储局部变量字符串，那么这个Vector将不能跨函数使用。

   3. 如果存堆字符串，那么这个Vector需要管理它存储的字符串的生命周期，这就比较麻烦了。

但对于我们下面的这个需求而言：由于需要动态构建字符串，所以不可能使用字符串字面值，局部变量/全局变量字符串也不可用，所以比较好是实现就是使用堆字符串。

参考代码如下：

xxxxxxxxxx
41
1
#define _CRT_SECURE_NO_WARNINGS
2
#include <stdio.h>
3
#include <stdlib.h>
4
#include "vector.h"
5
#define N 100
6

7
int main(void) {
8
    // 在栈上创建一个Vector指针，指向堆上的结构体对象
9
    Vector* v = vector_create();
10
    if (v == NULL) {
11
        printf("Error: vector_create failed.\n");
12
        return 1;
13
    }
14
    for (int i = 0; i < N; i++) {   // 循环100次向动态字符串数组中插入字符串
15
        // 用calloc更好,它会自动初始化所有元素是空字符.这对字符串而言很关键,因为第一个空字符作为结束标志
16
        int str_len = i + 1;
17
        char* str = calloc(1, (str_len + 1));
18
        if (str == NULL) {
19
            printf("Error: calloc str failed.\n");
20
            return 1;
21
        }
22
        for (int j = 0; j <= i; j++) {
23
            str[j] = '0' + j % 10;
24
        }
25
        vector_push_back(v, str);
26
    }
27

28
    for (int i = 0; i < N; i++) {
29
        printf("%s\n", v->data[i]);
30
    }
31

32
    // 销毁动态字符串数组指向的所有堆字符串
33
    for (int i = 0; i < N; i++) {
34
        free(v->data[i]);
35
    }
36

37
    // 用完了销毁Vector
38
    vector_destroy(v);
39

40
    return 0;
41
}

以上。

扩展：错误处理宏函数

_Gn!

规范的代码应该对内存分配函数malloc、calloc、realloc的返回值做判NULL处理。因为这些函数的返回值是NULL时意味着内存分配失败，函数出错，需要做错误处理。

后续的学习中，我们还会学习很多这样的函数，需要对它们的返回值做错误处理。

如果每次都需要将错误处理的结构都重新写一遍，那确实很折磨。为了更好的复用代码，简化操作，我们建议大家把这个结构用宏函数定义出来。

可以基于以下结构定义宏函数：

xxxxxxxxxx
4
1
if (p == NULL) {
2
 printf("error: calloc failed in main.\n");
3
 exit(1);
4
}

提示，为了更好的复用性，这个宏函数最好有三个参数：

1.函数返回值。错误处理是依据函数返回值进行的，所以需要函数返回值作为参数。也就是上述结构中的p

2.函数返回值的错误标志。当返回值是这个错误标志时，做错误处理。上述代码结构中就是NULL

3.msg。错误处理时打印的报错信息。也就是"calloc failed in main."这一段。

这个宏函数的实现不唯一，也不可能做到一个宏函数统一处理所有的情况，大家可以自己想一想写一下，也可以直接参考我给的实现。

最后，你可以将这个宏函数放到你的代码模板中，这样就更方便了。

参考实现如下：

参考代码实现：

xxxxxxxxxx
13
1
#define ERROR_CHECK(ret, error_flag, msg) \
2
 do { \
3
     if ((ret) == (error_flag)) { \
4
         printf("error: %s\n", msg); \
5
         exit(1); \
6
     } \
7
 } while(0)
8

9
int main(void) {
10
    int *p = malloc(10 * sizeof(int));
11
    ERROR_CHECK(p, NULL, "malloc failed in main.");
12
    return 0;
13
}

以上。

扩展：动态内存分配以及qsort函数

_Gn!

（扩展题，可以放到最后做）

编写一个C语言程序，完成以下任务：

首先，从键盘录入一个整数，表示接下来要录入的字符串的数量。

紧接着根据这个数量，从键盘连续录入字符串，每次都会将一整行键盘录入成一个字符串

这些被录入的字符串需要存入一个字符串数组，然后将该字符串数组按照以下两种规则排序遍历打印：

1.按照字符串的长度，从长到短排序

2.先按照字符串的长度从短到长排序，长度一致的字符串按照字典顺序排序。

程序的执行图，大致如下：

注意：

使用fgets读一整行字符串的话，不要忘记去除字符串中的换行符。

假设每个字符串的长度都不会超过1024。

参考代码如下：

参考代码如下：

xxxxxxxxxx
85
1
#define _CRT_SECURE_NO_WARNINGS
2
#include <stdio.h>
3
#include <string.h>
4
#include <stdlib.h>
5

6
#define MAX_STRLEN 1024
7

8
// 字符串比较函数：按长度从长到短排序
9
int compare_length_desc(const void *a, const void *b) {
10
    /*
11
        a 和 b 是指向数组中两个待比较元素的指针。
12
        数组中的元素是char*字符串类型，指向它的指针也就是char**二级指针类型
13
        所以这里应该将a和b强转成(char**)类型，然后解引用一次
14
        才能够得到两个待比较的字符串
15
    */
16
    const char *str1 = *(const char **)a;
17
    const char *str2 = *(const char **)b;
18
    int len1 = strlen(str1);
19
    int len2 = strlen(str2);
20
    if (len1 != len2) {
21
        return len2 - len1;  // 从长到短排序
22
    }
23
    return strcmp(str1, str2);  // 如果长度相同，则按字典顺序排序
24
}
25

26
// 字符串比较函数：先按长度从短到长排序，长度一样则按字典序
27
int compare_length_asc(const void *a, const void *b) {
28
    const char *str1 = *(const char **)a;
29
    const char *str2 = *(const char **)b;
30
    int len1 = strlen(str1);
31
    int len2 = strlen(str2);
32
    if (len1 != len2) {
33
        return len1 - len2;  // 从短到长排序
34
    }
35
    return strcmp(str1, str2);  // 如果长度相同，则按字典顺序排序
36
}
37

38
int main() {
39
    int str_num;
40
    printf("请输入您要输入的字符串的个数：");
41
    scanf("%d", &str_num);
42
    // 为了避免回车符对下面录入字符串产生影响，清空缓冲区
43
    while (getchar() != '\n');
44

45
    /*
46
        申请长度是str_num的char指针数组
47
        返回值类型是void*，在接收返回值也必须给一个指针类型进行类型转换
48
        所以不能直接写char *arr[]
49
        而需要写指向指针的指针类型，也就是char**，二级指针
50
    */
51
    char **str_array = malloc(str_num * sizeof(char *));
52
    for (int i = 0; i < str_num; i++) {
53
        // 每个字符串的长度都不超过1024
54
        str_array[i] = malloc(MAX_STRLEN + 1);
55
        printf("请输入第 %d 个字符串：", i + 1);
56
        fgets(str_array[i], MAX_STRLEN + 1, stdin);
57
        // 使用strlen检查并移除换行符
58
        int length = strlen(str_array[i]);
59
        if (length > 0 && str_array[i][length - 1] == '\n') {
60
            str_array[i][length - 1] = '\0';
61
        }
62
    }
63

64
    // 按长度从长到短排序并打印
65
    qsort(str_array, str_num, sizeof(char *), compare_length_desc);
66
    printf("按长度从长到短排序的结果：\n");
67
    for (int i = 0; i < str_num; i++) {
68
        printf("%s\n", str_array[i]);
69
    }
70

71
    // 先按长度从短到长排序，长度一样则按字典序排序
72
    qsort(str_array, str_num, sizeof(char *), compare_length_asc);
73
    printf("按长度从短到长排序，长度一致时按字典顺序的结果：\n");
74
    for (int i = 0; i < str_num; i++) {
75
        printf("%s\n", str_array[i]);
76
    }
77

78
    // 释放内存
79
    for (int i = 0; i < str_num; i++) {
80
        free(str_array[i]);
81
    }
82
    free(str_array);
83

84
    return 0;
85
}

以上。

扩展：动态拼接字符串数组以及qsort函数

_Gn!

首先给定以下字符数组：

xxxxxxxxxx
9
1
char* strings[] = {
2
    "4show ",
3
    "1code.",
4
    "5cheap, ",
5
    "6is ",
6
    "7Talk ",
7
    "2the ",
8
    "3me "
9
};

请你先利用qsort函数将此字符串数组，按照逆字典顺序排序。然后将这个字符串数组中的每一个字符串，按照从前到后的顺序，拼接组装成一个新字符串，并且在拼接时删除每个子字符串的第一个字符。

这样你将得到Linux之父Linus Torvalds的名言：“Talk is cheap, show me the code.”

要求使用动态分配内存来存储结果字符串，函数声明如下：

xxxxxxxxxx
1
1
char* concat_strs(char* strings[], int count);

参考代码如下：

参考代码：

xxxxxxxxxx
60
1
#define _CRT_SECURE_NO_WARNINGS
2
#include <stdio.h>
3
#include <stdlib.h>
4
#include <string.h>
5
#define ARR_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))
6

7
// 函数声明
8
char *concat_strs(char *strings[], int count);
9
int cmp_ruler(const void *a, const void *b);
10

11
int main(void) {
12
    char *strings[] = {
13
        "4show ",
14
        "1code.",
15
        "5cheap, ",
16
        "6is ",
17
        "7Talk ",
18
        "2the ",
19
        "3me "
20
    };
21
    int count = ARR_SIZE(strings);  // 字符串数组的长度
22

23
    // 使用 qsort 对字符串数组进行逆字典序排序
24
    qsort(strings, count, sizeof(char *), cmp_ruler);
25

26
    // 调用 concat_strs 函数进行拼接合并
27
    char *result = concat_strs(strings, count);
28
    printf("拼接并排序后的字符串: %s\n", result);
29

30
    return 0;
31
}
32

33
// 字符串逆字典序比较函数
34
int cmp_ruler(const void *a, const void *b) {
35
    const char *str1 = *(const char **)a;
36
    const char *str2 = *(const char **)b;
37
    return strcmp(str2, str1);  // 逆字典顺序，所以传参要反过来
38
}
39

40
// 拼接并排序字符串数组
41
char *concat_strs(char *strings[], int count) {
42
    // 计算所有字符串的总长度，去掉每个字符串的第一个字符
43
    int total_length = 0;
44
    for (int i = 0; i < count; i++) {
45
        total_length += strlen(strings[i]) - 1; // 减去第一个字符
46
    }
47
    // 动态分配内存
48
    char *result = (char *)calloc(total_length + 1, sizeof(char)); // +1 用于存储末尾的空字符
49
    if (result == NULL) {
50
        printf("error: malloc failed in concat_strs.\n");
51
        exit(-1);
52
    }
53

54
    // 拼接所有排序后的字符串，去掉每个字符串的第一个字符
55
    for (int i = 0; i < count; i++) {
56
        strcat(result, strings[i] + 1); // 跳过第一个字符
57
    }
58

59
    return result;
60
}

以上。

The End