编写一个函数，利用指针将输入的多个字符串按大小升序排序

### 回答1：
以下是一个示例函数，可以实现输入的多个字符串按大小升序排序：

void sort_strings(char** strings, int num_strings) {
    int i, j;
    char* temp;

    for (i = 0; i < num_strings - 1; i++) {
        for (j = i + 1; j < num_strings; j++) {
            if (strcmp(strings[i], strings[j]) > 0) {
                temp = strings[i];
                strings[i] = strings[j];
                strings[j] = temp;
            }
        }
    }
}

该函数接受两个参数：一个指向字符串数组的指针和字符串数组中字符串的数量。它使用嵌套的循环来比较字符串并交换它们的位置，以便按升序排序。在每次比较中，使用 `strcmp` 函数来比较两个字符串的大小。如果第一个字符串比第二个字符串大，则交换它们的位置。最终，字符串数组中的字符串将按升序排序。

### 回答2：
要编写一个函数，利用指针将输入的多个字符串按大小升序排序，我们可以按照以下步骤来完成：

1. 先确定要排序的字符串个数，然后动态申请一个二维字符数组，用于存储输入的多个字符串。

2. 考虑使用指针，编写一个函数来比较两个字符串的大小，返回值为一个整数，表示两个字符串的大小关系。例如，如果第一个字符串比第二个字符串小，则返回负数；如果两个字符串相等，则返回0；如果第一个字符串比第二个字符串大，则返回正数。

3. 编写一个函数，用于实现冒泡排序，利用第二步中的比较函数来比较每个字符串的大小，并使用指针来进行交换操作，把输入的多个字符串按大小升序排列。

4. 最后，在主函数中调用以上函数，输入多个字符串，按大小升序排序后输出结果。

以下是可能的代码实现：

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

// 定义字符串个数，可根据需要自定义修改
#define MAX_STR_NUM 5
// 定义字符串长度，可根据需要自定义修改
#define MAX_STR_LEN 20

// 比较函数，返回值为一个整数
// 如果第一个字符串比第二个字符串小，则返回负数
// 如果两个字符串相等，则返回0
// 如果第一个字符串比第二个字符串大，则返回正数
int str_cmp(const void* a, const void* b) {
    return strcmp(*(const char**)a, *(const char**)b);
}

// 冒泡排序函数
void bubble_sort(char** str, int str_num) {
    int i, j;
    char* temp;
    for (i = 0; i < str_num; i++) {
        for (j = 0; j < str_num - i - 1; j++) {
            if (str_cmp(&str[j], &str[j + 1]) > 0) {
                temp = str[j];
                str[j] = str[j + 1];
                str[j + 1] = temp;
            }
        }
    }
}

int main() {
    // 动态申请一个二维字符数组
    char** str = (char**)malloc(MAX_STR_NUM * sizeof(char*));
    int i, str_num;

    printf("请输入字符串个数（不大于%d）：\n", MAX_STR_NUM);
    scanf("%d", &str_num);
    if (str_num > MAX_STR_NUM) {
        printf("输入的字符串个数不得大于%d！\n", MAX_STR_NUM);
        exit(1);
    }

    printf("请输入%d个长度不超过%d的字符串（以空格隔开）：\n", str_num, MAX_STR_LEN - 1);
    for (i = 0; i < str_num; i++) {
        str[i] = (char*)malloc(MAX_STR_LEN * sizeof(char));
        scanf("%s", str[i]);
    }

    // 调用冒泡排序函数
    bubble_sort(str, str_num);

    printf("按大小升序排序后的字符串为：\n");
    for (i = 0; i < str_num; i++) {
        printf("%s ", str[i]);
    }

    printf("\n");

    // 释放动态申请的空间
    for (i = 0; i < str_num; i++) {
        free(str[i]);
    }
    free(str);

    return 0;
}

以上代码中，我们使用了qsort函数来自动排序，还可以使用其他的快速排序方法，如归并排序等。

### 回答3：
题目要求编写一个函数，实现输入多个字符串并按照大小升序排序。为了方便处理，我们可以将这些字符串存储在一个字符数组中，并且每个字符串之间用空字符 '\0' 分开。

接下来，我们就可以开始编写函数了。根据题目的要求，我们需要利用指针来实现字符串的排序。因此，我们需要先定义一个指向字符数组的指针，用来指向数组的首地址。

然后，我们需要编写一个 for 循环来遍历字符数组，并比较每个字符串之间的大小。在比较完成过后，我们需要进行数据的交换，以实现字符串的排序。

在排序完成后，我们就可以输出排序后的结果，即按照大小升序排列的字符串数组。

下面是具体实现：

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

#define MAX_LEN 1000

void sort(char *arr[], int n);

int main() {
    char strs[MAX_LEN];
    char *arr[MAX_LEN];
    int i = 0;

    printf("请输入多个字符串，按照回车分割，输入 exit 退出：\n");

    while (fgets(strs, MAX_LEN, stdin) != NULL) {
        strs[strlen(strs) - 1] = '\0'; // 去掉换行符
        if (strcmp(strs, "exit") == 0) {
            break;
        }
        arr[i] = (char *) malloc(strlen(strs) + 1); // 分配内存
        strcpy(arr[i], strs); // 将字符串复制到动态分配的内存中
        i++;
    }
    sort(arr, i); // 排序
    printf("\n排序后的字符串数组为：\n");
    for (int j = 0; j < i; j++) {
        printf("%s\n", arr[j]);
        free(arr[j]); // 释放内存
    }
    return 0;
}

void sort(char *arr[], int n) {
    char *temp;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (strcmp(arr[j], arr[j + 1]) > 0) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

上面的代码中，我们使用了一个字符数组 `strs` 来暂存每个输入的字符串，如果输入的字符串为 "exit" 则退出程序。然后，我们将每个字符串动态分配内存，并将它们存储到一个字符指针数组 `arr` 中。

在 `sort` 函数中，我们使用了冒泡排序算法来对字符串进行排序。最后，我们输出排序后的字符串数组，然后释放内存。

以上就是按照题目要求编写的函数的实现过程。