关于整形函数和数组传递

不是很能理解第二点要求中的把数组传递进去整形函数中是什么意思，以及后面的传递一个整型变量实现功能是可以用switch() case语句实现吗

将数组作为形参，输入一个数字也作为形参，实现对应数字的操作


#include <stdio.h>
//打印数组
void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}
//找最小值
int findMin(int arr[], int size) {
    int min = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    return min;
}
//找最大值
int findMax(int arr[], int size) {
    int max = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}
//小到大排序
void sortSmallToBig(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
//大到小排序
void sortBigToSmall(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (arr[j] < arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int func(int arr[], int size, int operation) {
    switch (operation) {
    case 0:
        return 0;
    case 1:
    {
        printf("最小值为：%d\n", findMin(arr, size));
        return findMin(arr, size);
    }
    case 2:
    {
        printf("最大值为：%d\n", findMax(arr, size));
        return findMax(arr, size);
    }
    case 3:
    {
        sortSmallToBig(arr, size);
        printf("由小到大排序: ");
        printArray(arr, 10);
        return 0;

    }
    case 4:
        sortBigToSmall(arr, size);
        printf("由大到小排序: ");
        printArray(arr, 10);
        return 0;
    default:
        printf("无效\n");
        return -1;
    }
}

int main() {
    int arr[10] = { 7, 3, 9, 1, 5, 2, 8, 4, 6, 10 };
    printf("原数组: ");
    printArray(arr, 10);
    int operation; 
    scanf("%d", &operation);
    int result = func(arr, 10, operation);
    return 0;
}

这是出题者不规范的说法，可以用switch，但是我觉得用if更好，原因是从大到小还是从小到大，用if实现代码可以共享，用switch得几乎重复写2次。

#include <stdio.h>
#define N 10
int func(int arr[], int flag)
{
    if (flag == 0) return 0;
    if (flag <= 2)
    {
        int r = arr[0];
        for (int i = 1; i < N; i++)
        {
            if ((r < arr[i] && flag == 1) || (r > arr[i] && flag == 2))
                r = arr[i];
        }
        return r;
    }
    for (int i = 0; i < N - 1; i++)
    {
        for (int j = 0; j < N - i - 1; j++)
        {
            if ((arr[j] > arr[j + 1] && flag == 3) || (arr[j] < arr[j + 1] && flag == 4))
            {
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}
int main()
{
    int arr[10] = { 9, 0, 1, 3, 2, 5, 7, 4, 8, 6 };
    func(arr, 0);
    int min = func(arr, 1);
    int max = func(arr, 2);
    printf("min = %d, max = %d\n", min, max);
    func(arr, 3);
    for (int i = 0; i < N; i++)
        printf("%d ", arr[i]);
    printf("\n");
    func(arr, 4);
    for (int i = 0; i < N; i++)
        printf("%d ", arr[i]);
    return 0;
}

min = 9, max = 0
0 1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1 0

用switch也可以

#include <stdio.h>
#define N 10
int func(int arr[], int flag)
{
    switch (flag)
    {
        case 0:
            return 0;
        case 1:
            {
                int r = arr[0];
                for (int i = 1; i < N; i++)
                {
                    if (r > arr[i])
                        r = arr[i];
                }
                return r;
            }
        case 2:
            {
                int r = arr[0];
                for (int i = 1; i < N; i++)
                {
                    if (r < arr[i])
                        r = arr[i];
                }
                return r;
            }
        case 3:
            {
                for (int i = 0; i < N - 1; i++)
                {
                    for (int j = 0; j < N - i - 1; j++)
                    {
                        if (arr[j] > arr[j + 1])
                        {
                            int tmp = arr[j];
                            arr[j] = arr[j + 1];
                            arr[j + 1] = tmp;
                        }
                    }
                }
            }
            break;
        case 4:
            {
                for (int i = 0; i < N - 1; i++)
                {
                    for (int j = 0; j < N - i - 1; j++)
                    {
                        if (arr[j] < arr[j + 1])
                        {
                            int tmp = arr[j];
                            arr[j] = arr[j + 1];
                            arr[j + 1] = tmp;
                        }
                    }
                }
            }
            break;
    }
}
int main()
{
    int arr[10] = { 9, 0, 1, 3, 2, 5, 7, 4, 8, 6 };
    func(arr, 0);
    int min = func(arr, 1);
    int max = func(arr, 2);
    printf("min = %d, max = %d\n", min, max);
    func(arr, 3);
    for (int i = 0; i < N; i++)
        printf("%d ", arr[i]);
    printf("\n");
    func(arr, 4);
    for (int i = 0; i < N; i++)
        printf("%d ", arr[i]);
    return 0;
}

这不就是让你先实现一个函数，函数有两个参数，第一个参数是数组，第二个参数是标志。根据不同标志处理这个数组然后返回结果嘛

定义一个函数，有两个形参，一个为前面定义的数组，另一个为函数功能选择参数。

switch case得麻烦一些

代码

#include <iostream>
using namespace std;

int myFunction(int arr[], int size, int flag) {

  int temp = arr[0];
  int i;

  switch (flag) {

    case 0:
      return 0;

    case 1:
      for (i = 1; i < size; i++) {
        if (arr[i] < temp) {
          temp = arr[i];
        }
      }
      return temp;

    case 2:
      for (i = 1; i < size; i++) {
        if (arr[i] > temp) {
          temp = arr[i];
        }
      }
      return temp;

    case 3:
      for (i = 0; i < size - 1; i++) {
        for (int j = i + 1; j < size; j++) {
          if (arr[i] > arr[j]) {
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
          }
        }
      }
      return 0;

    case 4:
      for (i = 0; i < size - 1; i++) {
        for (int j = i + 1; j < size; j++) {
          if (arr[i] < arr[j]) {
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;    
          }
        }
      }
      return 0;

    default:
      return -1;

  }

}

int main() {

  int array[10] = {5, -3, 9, 2, -7, -8, -4, -6, -9, -5};
  
  int result;


  result = myFunction(array, 10, 1);
  cout << "最小值 = " << result << endl;

  result = myFunction(array, 10, 2);
  cout << "最大值 = " << result << endl;

}

直接给你代码详细说明和仿真：

#include <stdio.h>

// 定义一个大小为10的整形数组，初始化为十个各不相同的非零变量
int arr[10] = {3, 7, 9, 1, 5, 8, 4, 6, 2, 10};

// 定义一个整形函数，要求可以把前面的数组传递进去，且可以传递一个整形变量
int func(int a[], int n) {
    // 定义一个变量用于存储返回值
    int result = 0;
    // 定义一个临时变量用于交换元素
    int temp;
    // 根据整形变量标志进行对应操作
    switch (n) {
        case 0: // 无操作，直接返回0
            break;
        case 1: // 找出数组中的最小并返回，保持数组原样
            // 假设第一个元素是最小的
            result = a[0];
            // 遍历数组，找出最小的元素
            for (int i = 1; i < 10; i++) {
                if (a[i] < result) {
                    result = a[i];
                }
            }
            break;
        case 2: // 找出数组中的最大值并返回，保持数组原样
            // 假设第一个元素是最大的
            result = a[0];
            // 遍历数组，找出最大的元素
            for (int i = 1; i < 10; i++) {
                if (a[i] > result) {
                    result = a[i];
                }
            }
            break;
        case 3: // 对数组进行排序，从小到大
            // 使用冒泡排序算法
            for (int i = 0; i < 9; i++) {
                for (int j = 0; j < 9 - i; j++) {
                    if (a[j] > a[j + 1]) {
                        // 交换两个元素的位置
                        temp = a[j];
                        a[j] = a[j + 1];
                        a[j + 1] = temp;
                    }
                }
            }
            break;
        case 4: // 对数组进行排序，从大到小
            // 使用冒泡排序算法
            for (int i = 0; i < 9; i++) {
                for (int j = 0; j < 9 - i; j++) {
                    if (a[j] < a[j + 1]) {
                        // 交换两个元素的位置
                        temp = a[j];
                        a[j] = a[j + 1];
                        a[j + 1] = temp;
                    }
                }
            }
            break;
        default: // 其他情况，返回-1表示无效输入
            result = -1;
    }
    return result;
}

// 主函数，用于测试功能
int main() {
    // 定义一个变量用于存储用户输入的标志
    int flag;
    // 定义一个变量用于存储函数返回值
    int res;
    // 提示用户输入标志
    printf("请输入一个整数（0-4）作为标志：\n");
    scanf("%d", &flag);
    // 调用函数，并将返回值赋给res
    res = func(arr, flag);
    // 根据标志输出不同的结果
    switch (flag) {
        case 0:
            printf("无操作，返回值为%d\n", res);
            break;
        case 1:
            printf("数组中的最小值为%d\n", res);
            break;
        case 2:
            printf("数组中的最大值为%d\n", res);
            break;
        case 3:
            printf("数组从小到大排序后为：\n");
            for (int i = 0; i < 10; i++) {
                printf("%d ", arr[i]);
            }
            printf("\n");
            break;
        case 4:
            printf("数组从大到小排序后为：\n");
            for (int i = 0; i < 10; i++) {
                printf("%d ", arr[i]);
            }
            printf("\n");
            break;
        default:
            printf("无效输入，返回值为%d\n", res);
    }
    return 0;
}

【以下回答由 GPT 生成】

问题1：

当我们将数组传递给一个整型函数时，实际上是将数组的首地址传递给函数。在C语言中，数组名会自动转换为指向数组首元素的指针，因此，我们可以通过指针来访问和操作数组的元素。

以下是一个示例代码：

#include <stdio.h>

void printArrayLength(int arr[]) {
    int length = sizeof(arr) / sizeof(arr[0]);
    printf("数组的长度为：%d\n", length);
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    printArrayLength(arr);

    return 0;
}

输出结果将是数组的长度为5。在这个例子中，printArrayLength() 函数接受一个整型数组作为参数，然后计算并打印出数组的长度。

问题2：

是的，你可以使用 switch 语句来根据不同的值执行不同的功能。以下是一个例子：

#include <stdio.h>

void performOperation(int operation) {
    switch(operation) {
        case 1:
            printf("执行操作1\n");
            // 执行操作1的代码
            break;
        case 2:
            printf("执行操作2\n");
            // 执行操作2的代码
            break;
        case 3:
            printf("执行操作3\n");
            // 执行操作3的代码
            break;
        default:
            printf("无效的操作\n");
            break;
    }
}

int main() {
    int operation;
    printf("请选择操作（1-3）：");
    scanf("%d", &operation);

    performOperation(operation);

    return 0;
}

在这个例子中，我们通过 scanf() 函数从用户输入中获取一个整数作为操作编号，并将其传递给 performOperation() 函数。根据操作编号的不同，performOperation() 函数将执行不同的功能。

注意：确保在 switch 中使用 break 语句来防止执行其他 case 的代码。

【相关推荐】

帮你找了个相似的问题, 你可以看下: https://ask.csdn.net/questions/899426
这篇博客也不错, 你可以看下计算某个日期是这一年中的的第多少天（只用switch实现）
您还可以看一下高升老师的快速入门Go语言（转行Go开发必修课程）课程中的 switch分支语句写法小节, 巩固相关知识点
除此之外, 这篇博客: 华为C语言编程规范重点笔记（学习C编程规范看这篇就够了）中的规则8.6 对于switch语句下的case语句，如果因为特殊情况需要处理完一个case后进入下一个case处理，必须在该case语句处理完、下一个case语句前加上明确的注释。部分也许能够解决你的问题。

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^