程序设计,编写函数,查询在主函数中输入的一组相同类型数据的最大值

程序设计,编写函数,查询在主函数中输入的一组相同类型数据的最大值。输入的数据可能为整型、长整型、字符型和双精度类型。
要点分析:由于输入数据的数据类型不能确定,可能为整型、长整型、字符型和双精度型一种，在一个函数中无法完成对不同数据类型数据的数据处理,因此本程序应采用含数重载技术。

#include <iostream>
#include <string>

using namespace std;

// 函数重载，处理整型数据
int findMax(int arr[], int n) {
    int maxNum = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > maxNum) {
            maxNum = arr[i];
        }
    }
    return maxNum;
}

// 函数重载，处理长整型数据
long findMax(long arr[], int n) {
    long maxNum = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > maxNum) {
            maxNum = arr[i];
        }
    }
    return maxNum;
}

// 函数重载，处理字符型数据
char findMax(char arr[], int n) {
    char maxLetter = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > maxLetter) {
            maxLetter = arr[i];
        }
    }
    return maxLetter;
}

// 函数重载，处理双精度型数据
double findMax(double arr[], int n) {
    double maxDecimal = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > maxDecimal) {
            maxDecimal = arr[i];
        }
    }
    return maxDecimal;
}

// 主函数
int main() {
    const int size = 5;
    
    int intArr[size] = { 10, 20, 30, 40, 50 };
    long longArr[size] = { 1000000, 2000000, 3000000, 4000000, 5000000 };
    char charArr[size] = { 'a', 'b', 'c', 'd', 'e' };
    double doubleArr[size] = { 1.0, 2.0, 3.0, 4.0, 5.0 };

    int maxInt = findMax(intArr, size);
    long maxLong = findMax(longArr, size);
    char maxChar = findMax(charArr, size);
    double maxDouble = findMax(doubleArr, size);

    cout << "Max int value: " << maxInt << endl;
    cout << "Max long value: " << maxLong << endl;
    cout << "Max char value: " << maxChar << endl;
    cout << "Max double value: " << maxDouble << endl;

    return 0;
}

GPT：

#include <iostream>
#include <vector>
#include <type_traits>

// 函数重载，处理不同类型的数据
template<typename T>
T getMaxValue(const std::vector<T>& arr) {
    T maxVal = arr[0];
    for (int i = 1; i < arr.size(); ++i) {
        if (arr[i] > maxVal) {
            maxVal = arr[i];
        }
    }
    return maxVal;
}

// 函数重载，处理字符类型的数据
char getMaxValue(const std::vector<char>& arr) {
    char maxVal = arr[0];
    for (int i = 1; i < arr.size(); ++i) {
        if (arr[i] > maxVal) {
            maxVal = arr[i];
        }
    }
    return maxVal;
}

int main() {
    // 输入数据
    std::cout << "请输入一组数据（以空格分隔，输入任意非数字字符结束输入）：" << std::endl;
    std::vector<int> intData;
    std::vector<long> longData;
    std::vector<char> charData;
    std::vector<double> doubleData;

    int intInput;
    long longInput;
    char charInput;
    double doubleInput;

    while (std::cin >> intInput) {
        intData.push_back(intInput);
    }
    std::cin.clear();

    while (std::cin >> longInput) {
        longData.push_back(longInput);
    }
    std::cin.clear();

    while (std::cin >> charInput) {
        charData.push_back(charInput);
    }
    std::cin.clear();

    while (std::cin >> doubleInput) {
        doubleData.push_back(doubleInput);
    }
    std::cin.clear();

    // 计算并输出最大值
    int intMax = getMaxValue(intData);
    long long longMax = getMaxValue(longData);
    char charMax = getMaxValue(charData);
    double doubleMax = getMaxValue(doubleData);

    std::cout << "最大整数值：" << intMax << std::endl;
    std::cout << "最大长整数值：" << longMax << std::endl;
    std::cout << "最大字符值：" << charMax << std::endl;
    std::cout << "最大双精度值：" << doubleMax << std::endl;

    return 0;
}

这个修改后的代码使用函数重载来处理不同类型的数据输入。除了通用的函数模板 getMaxValue，我们还定义了一个针对字符类型的特殊化版本 getMaxValue。在主函数中，我们使用不同的 std::vector 容器来存储不同类型的输入数据。然后，分别调用适当的函数来计算并输出每种类型数据的最大值。

请注意，代码中假设整数类型为 int、长整数类型为 long、字符类型为 char，双精度类型为 double。你可以根据需要修改函数模板和函数重载的参数类型，以适应不同的数据类型。