linux，编写一个shell程序，计算用户输入的所有命令行参数的和

在Linux中，编写一个简单的Shell脚本来计算用户输入的所有命令行参数之和，可以使用下面的bash脚本：

#!/bin/bash

# 使用"$@"变量来获取所有命令行参数
sum=0
for arg in "$@"
do
    # 将每个参数转换为数字并累加
    sum=$((sum + parseInt(arg)))
done

# 打印结果
echo "命令行参数之和为: $sum"

在这个脚本中，我们首先声明了一个变量`sum`用于存储总和，并遍历所有的命令行参数`$@`。`parseInt`函数在这里是一个假设，因为Bash本身并不支持直接的整数解析功能，所以在实际应用中，你需要一个实际的函数或者工具来将字符串转换成整数，比如`bc`命令。完整的脚本可能看起来像这样：

#!/bin/bash

sum=0
for arg in "$@"
do
    sum=$(($sum + $(echo "$arg" | bc -l)))
done

echo "命令行参数之和为: $sum"

这里使用了`bc`命令来进行浮点数的计算。然后，在循环结束后，输出结果。

相关问题

linux下用C语言编写一个简易shell

以下是一个简易的shell程序，可以在Linux下用C语言编写：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>

#define MAX_LINE 80 /* 命令行最大长度 */

int main(void)
{
    char *args[MAX_LINE / 2 + 1]; /* 命令行参数 */
    char input[MAX_LINE + 1]; /* 命令行输入 */
    int should_run = 1; /* 判断是否退出shell */
    pid_t pid; /* 进程ID */

    while (should_run)
    {
        printf("osh> ");
        fflush(stdout); /* 刷新输出缓冲区 */

        fgets(input, MAX_LINE, stdin); /* 读取命令行输入 */

        /* 将输入字符串拆分为参数数组 */
        char *token;
        int i = 0;
        token = strtok(input, " \n");
        while (token != NULL)
        {
            args[i++] = token;
            token = strtok(NULL, " \n");
        }
        args[i] = NULL; /* 参数数组以NULL结尾 */

        /* 检查是否退出shell */
        if (strcmp(args[0], "exit") == 0)
        {
            should_run = 0;
            continue;
        }

        /* 创建子进程执行命令 */
        pid = fork();
        if (pid < 0) /* 创建进程失败 */
        {
            fprintf(stderr, "fork failed\n");
            return 1;
        }
        else if (pid == 0) /* 子进程 */
        {
            execvp(args[0], args); /* 执行命令 */
            fprintf(stderr, "execvp failed\n"); /* 如果execvp返回，则表示执行失败 */
            return 1;
        }
        else /* 父进程 */
        {
            wait(NULL); /* 等待子进程结束 */
        }
    }

    return 0;
}

该程序的基本思路是每次读取一行命令行输入，将输入字符串拆分为参数数组，然后创建一个子进程执行命令，等待子进程结束后再读取下一行输入。如果输入的第一个参数是“exit”，则退出程序。

、编写一个C程序作为Linux内核的shell命令行解释程序。Shell程序应该使用与Bource shell相同的方式运行程序。 增加功能以使用户可以使用“<”和“>”作为文件名前缀来重定向stdin和stdout描述符。

以下是一个简单的示例程序，用于将用户输入的命令行解释为Linux shell命令：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>

#define MAX_ARGS 256
#define MAX_COMMAND_LENGTH 1024

void execute_command(char** args, int redirect_input, int redirect_output) {
    // 创建子进程
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // 子进程运行命令
        // 如果需要重定向输入，则打开输入文件并将其作为stdin描述符
        if (redirect_input) {
            FILE* input_file = fopen(args[redirect_input], "r");
            if (input_file == NULL) {
                perror("fopen");
                exit(EXIT_FAILURE);
            }
            dup2(fileno(input_file), STDIN_FILENO);
            fclose(input_file);
        }
        // 如果需要重定向输出，则打开输出文件并将其作为stdout描述符
        if (redirect_output) {
            FILE* output_file = fopen(args[redirect_output], "w");
            if (output_file == NULL) {
                perror("fopen");
                exit(EXIT_FAILURE);
            }
            dup2(fileno(output_file), STDOUT_FILENO);
            fclose(output_file);
        }
        // 执行命令
        execvp(args[0], args);
        // 如果execvp()返回，说明命令执行失败
        perror("execvp");
        exit(EXIT_FAILURE);
    } else {
        // 等待子进程结束
        int status;
        waitpid(pid, &status, 0);
        if (WIFEXITED(status)) {
            // 子进程正常结束
            int exit_status = WEXITSTATUS(status);
            if (exit_status != 0) {
                fprintf(stderr, "Command failed with exit status %d\n", exit_status);
            }
        } else if (WIFSIGNALED(status)) {
            // 子进程被信号终止
            int signal_number = WTERMSIG(status);
            fprintf(stderr, "Command terminated with signal %d\n", signal_number);
        }
    }
}

int main() {
    char command[MAX_COMMAND_LENGTH];
    while (1) {
        // 打印提示符并等待用户输入
        printf("$ ");
        fflush(stdout);
        if (fgets(command, sizeof(command), stdin) == NULL) {
            break;
        }
        // 将命令行分割为参数列表
        char* args[MAX_ARGS];
        int num_args = 0;
        char* token = strtok(command, " \t\n");
        while (token != NULL) {
            args[num_args++] = token;
            if (num_args == MAX_ARGS - 1) {
                fprintf(stderr, "Too many arguments\n");
                break;
            }
            token = strtok(NULL, " \t\n");
        }
        args[num_args] = NULL;
        // 检查是否需要重定向输入或输出
        int redirect_input = 0;
        int redirect_output = 0;
        for (int i = 1; i < num_args; i++) {
            if (strcmp(args[i], "<") == 0) {
                if (i == num_args - 2) {
                    redirect_input = i + 1;
                } else {
                    fprintf(stderr, "Invalid input redirection\n");
                    redirect_input = -1;
                }
            } else if (strcmp(args[i], ">") == 0) {
                if (i == num_args - 2) {
                    redirect_output = i + 1;
                } else {
                    fprintf(stderr, "Invalid output redirection\n");
                    redirect_output = -1;
                }
            }
        }
        // 执行命令
        if (num_args > 0) {
            if (redirect_input >= 0 && redirect_output >= 0) {
                execute_command(args, redirect_input, redirect_output);
            } else if (redirect_input >= 0) {
                execute_command(args, redirect_input, 0);
            } else if (redirect_output >= 0) {
                execute_command(args, 0, redirect_output);
            } else {
                execute_command(args, 0, 0);
            }
        }
    }
    return 0;
}

该程序使用类似于Bash shell的方式解释命令行，并支持输入和输出重定向。用户可以使用“<”作为文件名前缀来重定向stdin描述符，使用“>”作为文件名前缀来重定向stdout描述符。例如，以下命令将从input.txt文件中读取输入并将输出写入output.txt文件：

$ ./myshell < input.txt > output.txt