c++石头剪刀布，默认参数计算4次多项式，指针数组，原创！

一共6个代码
希望回答的都是原创答案，用c++简单语句，不要从别的地方搬来

#include
#include
using namespace std;

int main() {
srand((unsigned)time(NULL)); // 用于生成随机数

int player1Score = 0; // 玩家1得分
int player2Score = 0; // 玩家2得分

// 进行三局游戏
for (int round = 1; round <= 3; round++) {
    int player1Choice, player2Choice;

    // 玩家1输入选择
    cout << "第 " << round << " 局，玩家1请输入你的选择（1=石头，2=剪刀，3=布）：";
    cin >> player1Choice;

    // 玩家2输入选择
    cout << "玩家2请输入你的选择（1=石头，2=剪刀，3=布）：";
    cin >> player2Choice;

    // 输出选择
    cout << "玩家1出了：";
    switch (player1Choice) {
        case 1: cout << "石头" << endl; break;
        case 2: cout << "剪刀" << endl; break;
        case 3: cout << "布" << endl; break;
        default: cout << "无效的选择" << endl; continue;
    }
    cout << "玩家2出了：";
    switch (player2Choice) {
        case 1: cout << "石头" << endl; break;
        case 2: cout << "剪刀" << endl; break;
        case 3: cout << "布" << endl; break;
        default: cout << "无效的选择" << endl; continue;
    }

    // 判断胜负
    if (player1Choice == player2Choice) {
        cout << "本局平局" << endl;
    } else if (player1Choice == 1 && player2Choice == 2 ||
               player1Choice == 2 && player2Choice == 3 ||
               player1Choice == 3 && player2Choice == 1) {
        cout << "玩家1赢了本局" << endl;
        player1Score++;
    } else {
        cout << "玩家2赢了本局" << endl;
        player2Score++;
    }
}

// 输出最终结果
if (player1Score > player2Score) {
    cout << "玩家1赢了比赛" << endl;
} else if (player1Score < player2Score) {
    cout << "玩家2赢了比赛" << endl;
} else {
    cout << "比赛结束，平局" << endl;
}

return 0;

}

猜拳：

#include <iostream>
#include <string>

int main() 
{
    std::string player1, player2;
    // 提示玩家1输入选择
    std::cout << "玩家1: 请输入 石头, 剪刀 或 布: ";
    std::cin >> player1;
    // 提示玩家2输入选择
    std::cout << "玩家2: 请输入 石头, 剪刀 或 布: ";
    std::cin >> player2;

    // 判断胜负
    if (player1 == player2) 
    {
        std::cout << "平局!" << std::endl;
    }
    else if ((player1 == "石头" && player2 == "剪刀") || (player1 == "剪刀" && player2 == "布") ||(player1 == "布" && player2 == "石头")) 
    {
        std::cout << "玩家1获胜!" << std::endl;
    }
    else 
    {
        std::cout << "玩家2获胜!" << std::endl;
    }
     return 0;
}

四次多项式的值

#include <iostream>
#include <cmath>

    //定义函数（带参数）
double poly(double x, double a = 1.0, double b = 0.0, double c = 0.0, double d = 0.0, double e = 0.0) 
{
    return a * pow(x, 4) + b * pow(x, 3) + c * pow(x, 2) + d * x + e;
}
int main() 
{
    // 测试函数
    std::cout << "f(2) = " << poly(2) << std::endl;
    std::cout << "f(2) = " << poly(2, 1, 1, 1, 1, 1) << std::endl;
    return 0;
}

使用数组作为函数形参，函数调用时实参为数组

#include <iostream>
using namespace std;

// 定义一个函数，将数组中的元素按照相反的顺序存放
void reverseArray(int arr[], int n) {
    // 遍历数组的前一半元素
    for (int i = 0; i < n / 2; i++) {
        // 交换第i个元素和倒数第i个元素
        swap(arr[i], arr[n - i - 1]);
    }
}

int main() {
    // 定义一个数组
    int arr[] = {1, 2, 3, 4, 5};
    // 计算数组的长度
    int n = sizeof(arr) / sizeof(arr[0]);

    // 调用函数，反转数组中的元素
    reverseArray(arr, n);

    // 输出反转后的数组
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

使用数组作为形参实现函数，函数调用时实参为指针

#include <iostream>
using namespace std;

// 定义一个函数，将数组中的元素按照相反的顺序存放
void reverseArray(int *arr, int n) {
    // 遍历数组的前一半元素
    for (int i = 0; i < n / 2; i++) {
        // 交换第i个元素和倒数第i个元素
        swap(arr[i], arr[n - i - 1]);
    }
}

int main() {
    // 定义一个数组
    int arr[] = {1, 2, 3, 4, 5};
    // 计算数组的长度
    int n = sizeof(arr) / sizeof(arr[0]);

    // 调用函数，反转数组中的元素
    reverseArray(arr, n);

    // 输出反转后的数组
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

使用指针作为函数形参实现函数，函数调用时实参为数组

#include <iostream>
using namespace std;

// 定义一个函数，将数组中的元素按照相反的顺序存放
void reverseArray(int *arr, int n) {
    // 遍历数组的前一半元素
    for (int i = 0; i < n / 2; i++) {
        // 交换第i个元素和倒数第i个元素
        swap(arr[i], arr[n - i - 1]);
    }
}

int main() {
    // 定义一个数组
    int arr[] = {1, 2, 3, 4, 5};
    // 计算数组的长度
    int n = sizeof(arr) / sizeof(arr[0]);

    // 调用函数，反转数组中的元素
    reverseArray(arr, n);

    // 输出反转后的数组
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }

使用指针作为函数形参实现函数，调用函数时实参为指针

#include <iostream>
using namespace std;

// 定义一个函数，将数组中的元素按照相反的顺序存放
void reverseArray(int *arr, int n) {
    // 遍历数组的前一半元素
    for (int i = 0; i < n / 2; i++) {
        // 交换第i个元素和倒数第i个元素
        swap(arr[i], arr[n - i - 1]);
    }
}

int main() {
    // 定义一个数组
    int arr[] = {1, 2, 3, 4, 5};
    // 计算数组的长度
    int n = sizeof(arr) / sizeof(arr[0]);

    // 调用函数，反转数组中的元素
    reverseArray(arr, n);

    // 输出反转后的数组
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

以下答案由GPT-3.5大模型与博主波罗歌共同编写：
好的，以下是我原创的C++代码：

首先，我们需要定义一个函数，用来计算多项式的值。这里我们假设多项式的系数已经存储在一个数组中了，那么函数就可以写成这样：

double polynomial(double* coefficients, int degree, double x) {
    double sum = 0;
    for (int i = 0; i <= degree; i++) {
        double term = coefficients[i];
        for (int j = 0; j < i; j++) {
            term *= x;
        }
        sum += term;
    }
    return sum;
}

这个函数接受三个参数：一个存储多项式系数的数组，多项式的次数，以及要代入多项式的值x。函数会循环遍历每一项，计算出每一项的值，然后将它们加起来得到多项式的值。

接下来，我们需要写一个函数来处理石头剪刀布游戏。这个函数应该接受两个玩家的输入（石头、剪子或布），然后根据游戏规则确定哪个玩家获胜。

int rockPaperScissors(char player1, char player2) {
    if (player1 == player2) {
        // 如果两个玩家输入的相同，平局
        return 0;
    } else if ((player1 == 'r' && player2 == 's') || 
               (player1 == 's' && player2 == 'p') ||
               (player1 == 'p' && player2 == 'r')) {
        // 如果第一个玩家胜利
        return 1;
    } else {
        // 如果第二个玩家胜利
        return 2;
    }
}

这个函数接受两个参数：两个玩家输入的字符。如果两个字符相同，那么返回0表示平局。否则，根据游戏规则返回1或2表示哪个玩家获胜。

下一步，我们需要写一个函数来计算4次多项式。这里我们使用了刚刚定义的多项式函数，把多项式系数传递给它即可。

double fourthPolynomial(double x) {
    double coefficients[] = {1, 3, -3, -1, 2};
    return polynomial(coefficients, 4, x);
}

这个函数接受一个参数x，它把多项式系数存储在一个数组中，然后调用多项式函数来计算这个多项式的值。

接下来，我们需要用指针数组来存储一些字符串，然后对它们进行操作。

void stringOperations() {
    char* myStrings[] = {
        "Hello, world!",
        "This is a test.",
        "I love programming."
    };
    
    // 打印字符串长度
    for (int i = 0; i < 3; i++) {
        std::cout << strlen(myStrings[i]) << std::endl;
    }
    
    // 反转字符串
    for (int i = 0; i < 3; i++) {
        int len = strlen(myStrings[i]);
        for (int j = 0; j < len / 2; j++) {
            char temp = myStrings[i][j];
            myStrings[i][j] = myStrings[i][len - j - 1];
            myStrings[i][len - j - 1] = temp;
        }
        std::cout << myStrings[i] << std::endl;
    }
}

这个函数首先定义了一个指针数组，里面存储了3个字符串。然后，它使用strlen函数打印出每个字符串的长度，并使用双重循环来反转每个字符串。最后，它再次打印出反转后的字符串。

最后，我们需要把所有的函数都放在一个main函数中，让程序可以运行。

int main() {
    // 计算4次多项式
    std::cout << fourthPolynomial(2) << std::endl;
    
    // 玩石头剪刀布
    std::cout << rockPaperScissors('r', 's') << std::endl;
    
    // 操作字符串
    stringOperations();
    
    return 0;
}

这个main函数调用了我们之前写的所有函数，让程序可以运行。
如果我的回答解决了您的问题，请采纳！