1．用c语言编程，打开/etc/passwd文件，找出已经注册的普通用户账号 2．用c语言实现多进程编程，主进程每隔1秒获取当前系统时间写入某文件，子进程打开该文件，读取文件的内容并显示在屏幕上。

### 回答1：
这是一个关于使用C语言编程的问题。题目要求打开/etc/passwd文件，找出已经注册的普通用户账号2，并使用C语言实现多进程编程，每隔1秒获取当前系统时间写入某文件，子进程打开该文件，读取文件的内容并在屏幕上显示。

### 回答2：
1. 用c语言编程，打开/etc/passwd文件，找出已经注册的普通用户账号

在Linux系统中，用户的账号信息保存在/etc/passwd文件中，我们可以使用c语言来读取该文件并找出已注册的普通用户账号。具体方法如下：

1）打开/etc/passwd文件

我们可以使用fopen()函数来打开/etc/passwd文件，并返回一个文件指针。代码如下：

FILE *fp;
fp = fopen("/etc/passwd", "r");

2）读取文件内容并查找普通用户账号

我们可以使用fgets()函数逐行读取文件内容，并使用strtok()函数拆分每行内容，判断是否为普通用户账号。代码如下：

char line[256];
char *token;

while (fgets(line, 256, fp)) {
token = strtok(line, ":");
if (strcmp(token, "root") != 0) {
printf("%s\n", token);
}
}

在以上代码中，我们首先定义了一个line数组来保存每行文件内容，使用fgets()函数逐行读取/etc/passwd文件中的内容并保存到line数组中。然后，我们使用strtok()函数拆分line数组中的内容，以“:”为分隔符将每个字段拆分开来。若第一个字段不为“root”，则说明该账号为普通用户账号，输出该账号名。

3）关闭文件指针

完成文件读取后，我们需要使用fclose()函数关闭文件指针，释放资源。代码如下：

fclose(fp);

综上，我们可以将以上代码封装为一个函数，如下所示：

void findNormalUser() {
FILE *fp;
char line[256];
char *token;

fp = fopen("/etc/passwd", "r");
while (fgets(line, 256, fp)) {
token = strtok(line, ":");
if (strcmp(token, "root") != 0) {
printf("%s\n", token);
}
}
fclose(fp);
}

2. 用c语言实现多进程编程，主进程每隔1秒获取当前系统时间写入某文件，子进程打开该文件，读取文件的内容并显示在屏幕上。

在Linux系统中，我们可以使用fork()函数创建子进程，从而实现多进程编程。使用c语言编写程序，主进程每隔1秒获取当前系统时间并写入某个文件中，子进程不断打开该文件并读取文件内容并显示在屏幕上。具体方法如下：

1）使用fork()函数创建子进程

我们可以使用fork()函数创建一个子进程，并通过返回值判断当前代码处于主进程还是子进程中。代码如下：

int pid = fork();
if (pid == 0) {
// 子进程
} else if (pid > 0) {
// 主进程
} else {
// 创建子进程失败
}

在以上代码中，我们首先使用fork()函数创建一个子进程，并通过返回值判断当前代码处于主进程还是子进程中。若pid等于0，则说明当前代码处于子进程中，需要执行读取文件内容并显示的操作。若pid大于0，则说明当前代码处于主进程中，需要执行写入文件的操作。若pid小于0，则说明创建子进程失败，需要进行错误处理。

2）在主进程中实现写入文件的操作

我们可以使用fopen()函数打开一个文件，并使用fprintf()函数向文件中写入内容。主进程每隔1秒获取当前系统时间并写入该文件，代码如下：

FILE *fp;
time_t time_now;
struct tm *tm_now;
char str_now[32];

while (1) {
fp = fopen("time.txt", "w");
time_now = time(NULL);
tm_now = localtime(&time_now);
strftime(str_now, sizeof(str_now), "%Y-%m-%d %H:%M:%S\n", tm_now);
fprintf(fp, "%s", str_now);
fclose(fp);
sleep(1); // 等待1秒
}

在以上代码中，我们使用time()函数获取当前系统时间，并使用localtime()函数将时间转换为struct tm结构体类型。然后，使用strftime()函数将struct tm结构体类型的时间格式化为字符串类型，并将字符串类型时间写入文件中。主进程每隔1秒循环执行以上代码并写入文件。

3）在子进程中实现读取文件的操作

我们可以在子进程中使用fopen()函数打开文件并使用fgets()函数读取文件内容并显示在屏幕上。代码如下：

FILE *fp;
char line[256];

while (1) {
fp = fopen("time.txt", "r");
if (fp == NULL) {
printf("Open file failed.\n");
exit(1);
}
while (fgets(line, 256, fp)) {
printf("%s", line);
}
fclose(fp);
}

在以上代码中，我们首先使用fopen()函数打开文件，并使用fgets()函数读取文件内容并显示在屏幕上。由于主进程每隔1秒会覆盖原有文件内容，因此在读取文件内容时需要进行循环读取。在以上代码中，我们使用while循环读取文件内容，并使用printf()函数将内容输出到屏幕上。

4）终止主进程和子进程

我们可以在应用程序结束时使用exit()函数终止进程。在主进程和子进程中均需调用exit()函数以避免进程资源的泄露。代码如下：

// 主进程
while (1) {
fp = fopen("time.txt", "w");
// 写入文件
fclose(fp);
sleep(1);
}

exit(0);

// 子进程
while (1) {
fp = fopen("time.txt", "r");
// 读取并显示文件内容
fclose(fp);
}

exit(0);

综上，我们可以将以上代码封装为一个函数，如下所示：

void multiProcess() {
int pid = fork();
if (pid == 0) {
// 子进程
FILE *fp;
char line[256];

while (1) {
fp = fopen("time.txt", "r");
if (fp == NULL) {
printf("Open file failed.\n");
exit(1);
}
while (fgets(line, 256, fp)) {
printf("%s", line);
}
fclose(fp);
}

exit(0);
} else if (pid > 0) {
// 主进程
FILE *fp;
time_t time_now;
struct tm *tm_now;
char str_now[32];

while (1) {
fp = fopen("time.txt", "w");
time_now = time(NULL);
tm_now = localtime(&time_now);
strftime(str_now, sizeof(str_now), "%Y-%m-%d %H:%M:%S\n", tm_now);
fprintf(fp, "%s", str_now);
fclose(fp);
sleep(1);
}

exit(0);
} else {
// 创建子进程失败
printf("Create process failed.\n");
}
}

### 回答3：
1. 用c语言编程，打开/etc/passwd文件，找出已经注册的普通用户账号

在Linux系统中，/etc/passwd文件中记录了所有已注册账户的用户信息，包括用户名、用户ID、组ID、用户家目录、默认shell等等。要通过C语言编程来读取这个文件并找出已注册的普通账户，可以按照以下步骤操作：

1）使用fopen函数打开/etc/passwd文件，打开方式为只读。

2）使用fgets函数逐行读取文件内容，每次读取一行记录做处理。

3）使用strtok函数将每一行记录按照":"作为分隔符分割成各个字段，然后读取第3个字段（用户ID）的值来判断是否为普通用户。判断的条件为用户ID大于等于1000，则认为是普通用户。

4）将符合条件的用户记录输出到控制台或写入某个文件中。

代码如下：

#include <stdio.h>
#include <string.h>

int main()
{
    FILE *pFile;
    char buffer[256];

    // 打开文件
    pFile = fopen("/etc/passwd", "r");
    if (pFile == NULL)
    {
        printf("无法打开文件 /etc/passwd！\n");
        return -1;
    }

    // 逐行读取文件内容
    while (fgets(buffer, sizeof(buffer), pFile) != NULL)
    {
        // 分离每一个字段
        char *pToken = strtok(buffer, ":");
        int count = 0, userId = 0;
        while (pToken != NULL)
        {
            count++;
            if (count == 3) // 读取用户ID值
            {
                userId = atoi(pToken);
                break;
            }
            pToken = strtok(NULL, ":");
        }

        // 判断是否为普通用户
        if (userId >= 1000)
        {
            char *pUserName = strtok(buffer, ":");
            printf("普通用户账号：%s\n", pUserName);
        }
    }

    // 关闭文件
    fclose(pFile);

    return 0;
}

2. 用c语言实现多进程编程，主进程每隔1秒获取当前系统时间写入某文件，子进程打开该文件，读取文件的内容并显示在屏幕上

C语言中的多进程编程可以使用fork函数来实现。fork函数会创建一个新的进程，其中包含原进程的完整副本，包括程序代码、内存空间、数据等等。在新进程开始执行之前，该函数会将父进程的上下文复制到子进程中。也就是说，子进程拥有与父进程相同的文件描述符、当前目录、根目录和文件权限等等。

下面是实现每隔1秒获取当前系统时间并写入文件的主进程代码：

#include <stdio.h>
#include <time.h>
#include <unistd.h> // sleep函数

int main()
{
    FILE *pFile;
    time_t rawtime;
    struct tm *timeinfo;

    // 打开文件
    pFile = fopen("time.txt", "w");
    if (pFile == NULL)
    {
        printf("无法打开文件 time.txt！\n");
        return -1;
    }

    // 每隔1秒写入当前系统时间
    while (1)
    {
        time(&rawtime);
        timeinfo = localtime(&rawtime);
        fprintf(pFile, "当前时间：%s", asctime(timeinfo));
        sleep(1);
    }

    // 关闭文件
    fclose(pFile);

    return 0;
}

下面是子进程读取文件内容并显示在屏幕上的代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    FILE *pFile;
    char buffer[256];

    // 打开文件
    pFile = fopen("time.txt", "r");
    if (pFile == NULL)
    {
        printf("无法打开文件 time.txt！\n");
        return -1;
    }

    // 读取文件内容并显示
    while (fgets(buffer, sizeof(buffer), pFile) != NULL)
    {
        printf("%s", buffer);
    }

    // 关闭文件
    fclose(pFile);

    return 0;
}

将以上两个程序结合起来，就可以实现多进程编程。具体步骤如下：

1）首先在主函数中调用fork函数，创建一个子进程。

2）在父进程中每隔1秒钟获取当前系统时间并将其写入文件中。

3）在子进程中打开该文件，读取文件内容并在屏幕上显示。

4）最后要记得关闭文件并结束进程。

代码如下：

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

int main()
{
    pid_t pid; // 进程ID
    int status;

    pid = fork(); // 创建子进程

    if (pid < 0)
    {
        printf("创建子进程失败！\n");
        return -1;
    }
    else if (pid == 0) // 子进程
    {
        execl("./readtime", NULL); // 执行子进程函数
    }
    else // 父进程
    {
        FILE *pFile;
        time_t rawtime;
        struct tm *timeinfo;

        // 打开文件
        pFile = fopen("time.txt", "w");
        if (pFile == NULL)
        {
            printf("无法打开文件 time.txt！\n");
            return -1;
        }

        // 每隔1秒写入当前系统时间
        while (1)
        {
            time(&rawtime);
            timeinfo = localtime(&rawtime);
            fprintf(pFile, "当前时间：%s", asctime(timeinfo));
            sleep(1);
        }

        // 关闭文件
        fclose(pFile);

        // 等待子进程结束
        wait(&status);
    }

    return 0;
}

上面的代码中使用了wait函数来等待子进程结束，以避免进程间的竞争条件。在子进程中，调用execl函数来执行子进程函数代码readtime，其中readtime函数的代码如下：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    FILE *pFile;
    char buffer[256];

    // 打开文件
    pFile = fopen("time.txt", "r");
    if (pFile == NULL)
    {
        printf("无法打开文件 time.txt！\n");
        return -1;
    }

    // 读取文件内容并显示
    while (fgets(buffer, sizeof(buffer), pFile) != NULL)
    {
        printf("%s", buffer);
    }

    // 关闭文件
    fclose(pFile);

    return 0;
}

运行以上代码，就可以实现每隔1秒钟获取当前系统时间并显示在屏幕上。