c语言myshell流程图

下面是一个简单的 C 语言 myshell 的流程图：


1. 用户输入命令。
2. 程序将输入的命令解析成一个个参数。
3. 程序判断输入的命令是否为内置命令（如 cd、exit 等）。
4. 如果是内置命令，则直接执行该命令。
5. 如果不是内置命令，则创建一个子进程执行该命令。
6. 子进程通过 exec 系列函数执行该命令。
7. 父进程等待子进程执行完毕并获取其返回值。
8. 程序输出命令的执行结果或错误信息。
9. 回到第 1 步，等待用户输入新的命令。

需要注意的是，这只是一个简单的流程图，实际上 myshell 的实现可能会更加复杂，需要考虑更多的情况，比如管道、重定向等。

相关问题

用C语言实现myshell的输入重定向功能和输出重定向功能

以下是实现输入重定向和输出重定向的代码示例：

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

#define MAX_CMD_LEN 256

int main() {
    char cmd[MAX_CMD_LEN];
    char *args[MAX_CMD_LEN];
    char *input_file, *output_file;
    int input_fd, output_fd;
    int i, j;

    while (1) {
        printf("myshell> ");
        fgets(cmd, MAX_CMD_LEN, stdin); // 读取命令行输入
        if (feof(stdin)) { // 用户输入Ctrl+D，退出程序
            printf("\n");
            break;
        }

        // 解析命令行参数
        args[0] = strtok(cmd, " \n");
        i = 1;
        while ((args[i] = strtok(NULL, " \n")) != NULL) {
            i++;
        }
        args[i] = NULL;

        // 查找输入输出重定向符号
        input_file = NULL;
        output_file = NULL;
        for (j = 0; j < i; j++) {
            if (strcmp(args[j], "<") == 0) { // 输入重定向符号
                input_file = args[j+1];
                args[j] = NULL;
                break;
            }
            if (strcmp(args[j], ">") == 0) { // 输出重定向符号
                output_file = args[j+1];
                args[j] = NULL;
                break;
            }
        }

        // 执行命令
        pid_t pid = fork();
        if (pid == -1) {
            perror("fork");
            exit(1);
        } else if (pid == 0) { // 子进程
            // 输入重定向
            if (input_file != NULL) {
                input_fd = open(input_file, O_RDONLY);
                if (input_fd == -1) {
                    perror("open input file");
                    exit(1);
                }
                if (dup2(input_fd, STDIN_FILENO) == -1) {
                    perror("dup2 input");
                    exit(1);
                }
                close(input_fd);
            }

            // 输出重定向
            if (output_file != NULL) {
                output_fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC, 0644);
                if (output_fd == -1) {
                    perror("open output file");
                    exit(1);
                }
                if (dup2(output_fd, STDOUT_FILENO) == -1) {
                    perror("dup2 output");
                    exit(1);
                }
                close(output_fd);
            }

            // 执行命令
            execvp(args[0], args);
            perror(args[0]);
            exit(1);
        } else { // 父进程
            waitpid(pid, NULL, 0);
        }
    }

    return 0;
}

在上述代码中，我们首先解析用户输入的命令行参数，查找输入输出重定向符号 `<` 和 `>`，并分别获取输入和输出文件名。接着，在子进程中，我们使用 `open()` 函数打开输入或输出文件，并使用 `dup2()` 函数将标准输入或标准输出重定向到文件描述符。最后，我们使用 `execvp()` 函数执行用户输入的命令。在父进程中，我们使用 `waitpid()` 函数等待子进程结束。

c语言编写shell程序myshell

好的，我可以为您提供一些基本的思路和参考代码。

首先，您需要了解一些基本的 shell 命令和操作符，如 cd、ls、echo、管道符、重定向等。

然后，您可以按照以下步骤编写您的 myshell：

1. 读取用户输入的命令。可以使用 fgets 函数来读取用户输入的命令。

2. 解析用户输入的命令。将用户输入的命令按照空格分割成若干个参数，并判断是否存在管道符或重定向符号等特殊操作符。

3. 根据用户输入的命令，执行相应的操作。可以使用 exec 系列函数来执行命令，使用 fork 函数来创建子进程进行执行。

4. 等待子进程执行完毕，并输出执行结果。

下面是一个简单的 myshell 程序的示例代码：

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

#define MAX_CMD_LEN 1024

int main()
{
    char cmd[MAX_CMD_LEN];

    while (1) {
        printf("myshell> ");
        fgets(cmd, MAX_CMD_LEN, stdin);
        cmd[strlen(cmd) - 1] = '\0'; // 去掉换行符

        if (strcmp(cmd, "exit") == 0) {
            break;
        }

        int pid = fork();

        if (pid == -1) {
            perror("fork");
            exit(1);
        } else if (pid == 0) {
            char *argv[MAX_CMD_LEN], *token;
            int argc = 0;

            token = strtok(cmd, " ");
            while (token != NULL) {
                argv[argc++] = token;
                token = strtok(NULL, " ");
            }
            argv[argc] = NULL;

            execvp(argv[0], argv);
            perror("execvp");
            exit(1);
        } else {
            int status;
            waitpid(pid, &status, 0);
        }
    }

    return 0;
}

当用户输入 exit 命令时，程序会退出。如果用户输入其他命令，则会创建子进程执行该命令，并等待子进程结束。在子进程中，首先将用户输入的命令解析成若干个参数，然后调用 execvp 函数执行该命令。如果 execvp 函数返回，则说明执行失败，程序会输出错误信息并退出。

希望这个示例代码能够帮到您！