windows 编写一段程序，使用系统调用 fork0来创建两个子进程，并由父进程重复显示字符串“parent:”和自己的标识数，子进程则重复显示字符串“child:”和自己的标识数

以下是Windows平台下使用系统调用fork0创建两个子进程的程序：

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

int main() {
    int i;
    for (i = 0; i < 2; i++) {
        if (fork0() == 0) {
            printf("child:%d\n", GetCurrentProcessId());
            exit(0);
        } else {
            printf("parent:%d\n", GetCurrentProcessId());
        }
    }
    return 0;
}

其中，fork0函数模拟了Unix平台下的fork函数，用于创建子进程。在父进程中，fork0函数返回子进程的进程ID；在子进程中，fork0函数返回0。

在上述程序中，父进程使用for循环创建两个子进程，重复输出字符串“parent:”和自己的进程ID；子进程则输出字符串“child:”和自己的进程ID。使用GetCurrentProcessId函数获取当前进程的进程ID。最后，主函数返回0表示程序正常结束。

相关问题

windows编写一段程序，使用系统调用 fork0来创建两个子进程，并由父进程重复显示字符串“parent:”和自己的标识数，子进程则重复显示字符串“child:”和自己的标识数

以下是一个使用系统调用 fork() 来创建两个子进程，并由父进程重复显示字符串“parent:”和自己的标识数，子进程则重复显示字符串“child:”和自己的标识数的示例程序：

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

int main() {
    pid_t child1, child2;
    int status;

    // 创建第一个子进程
    child1 = fork();
    if (child1 == -1) {
        printf("Failed to create child1.\n");
        return 1;
    } else if (child1 == 0) {
        // 子进程1
        printf("child1: %d\n", getpid());
        return 0;
    }

    // 创建第二个子进程
    child2 = fork();
    if (child2 == -1) {
        printf("Failed to create child2.\n");
        return 1;
    } else if (child2 == 0) {
        // 子进程2
        printf("child2: %d\n", getpid());
        return 0;
    }

    // 父进程
    printf("parent: %d\n", getpid());

    // 等待子进程结束
    waitpid(child1, &status, 0);
    waitpid(child2, &status, 0);

    return 0;
}

在上面的程序中，我们先创建了第一个子进程 child1，然后再创建第二个子进程 child2。在每个子进程中，我们简单地输出了进程的 PID。在父进程中，我们输出了父进程的 PID。最后，我们使用 waitpid() 函数来等待两个子进程的结束。

注意，fork() 函数会返回两次，一次在父进程中，一次在子进程中。因此，我们需要在程序中使用条件语句来判断当前进程是父进程还是子进程。

编写一段程序，使用系统调用fork()来创建两个子进程，并由父进程重复显示字符串“parent:”和自己的标识数，而子进程则重复显示字符串“child:”和自己的标识数。

### 回答1：
下面是使用系统调用fork()来创建两个子进程，并由父进程重复显示字符串“parent:”和自己的标识数，而子进程则重复显示字符串“child:”和自己的标识数的程序：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>

int main()
{
    pid_t pid1, pid2;

    pid1 = fork();
    if (pid1 == ) {
        // 子进程1
        while (1) {
            printf("child1: %d\n", getpid());
            sleep(1);
        }
    } else {
        pid2 = fork();
        if (pid2 == ) {
            // 子进程2
            while (1) {
                printf("child2: %d\n", getpid());
                sleep(1);
            }
        } else {
            // 父进程
            while (1) {
                printf("parent: %d\n", getpid());
                sleep(1);
            }
        }
    }

    return ;
}

### 回答2：
本题需要使用C语言编写一段程序，通过系统调用fork()函数来创建两个子进程，并通过父进程和子进程的不同标识数分别重复显示不同的字符串。

首先，我们需要包含头文件<sys/types.h>和<unistd.h>，因为这两个头文件包含了各种系统调用所需的函数和类型定义。

接着，我们可以使用fork()函数来创建两个子进程。fork()函数会返回一个整型，其中在父进程中返回子进程的进程ID，而在子进程中返回0。

在父进程中，我们可以通过调用getpid()函数来获得当前进程的标识数，并使用printf()函数来输出“parent:”和该标识数。为了让父进程不停地显示该字符串，我们可以使用一个while循环。

在子进程中，我们可以同样调用getpid()函数和printf()函数，输出“child:”和进程标识数，并同样通过while循环来保证重复显示该字符串。

最后，我们需要注意在程序结束前要调用exit()函数来退出进程，否则子进程会继续运行下去。

下面是完整的程序代码：

#include<sys/types.h>
#include<unistd.h>
#include<stdio.h>

int main()
{
pid_t pid1, pid2; // 定义两个子进程的进程ID
int count = 0; // 父进程计数器

pid1 = fork(); // 创建第一个子进程
if(pid1 < 0)
{
printf("Error fork\n");
return 1;
}
else if(pid1 == 0) // 子进程1
{
while(1)
{
printf("child 1: %d\n", getpid());
sleep(2);
}
}
else // 父进程
{
pid2 = fork(); // 创建第二个子进程
if(pid2 < 0)
{
printf("Error fork\n");
return 1;
}
else if(pid2 == 0) // 子进程2
{
while(1)
{
printf("child 2: %d\n", getpid());
sleep(2);
}
}
else // 父进程
{
while(count < 5)
{
printf("parent: %d\n", getpid());
count++;
sleep(1);
}
exit(0);
}
}

return 0;
}

### 回答3：
编写这样一个程序需要使用C语言，并调用系统调用fork()来创建两个子进程。在程序中，父进程需要重复显示字符串“parent: ”和自己的标识数，而子进程则需要重复显示字符串“child: ”和自己的标识数。

首先，需要使用头文件#include <stdio.h>和#include <unistd.h>，这个后者包含了实现fork()函数所需要的一些系统调用。接下来，需要编写main()函数，该函数应该返回一个整数类型的值。

在main()函数中，需要使用fork()系统调用来创建两个子进程。当调用fork()时，该函数会返回一个整数值，如果该值为0，则表明当前线程是子进程；如果该值大于0，则表明当前线程是父进程；如果该值小于0，则表明fork()调用失败。

当程序进入父进程中时，需要使用一段while循环来重复显示字符串“parent: ”和当前父进程的标识数。为了获取当前程序的进程标识数，可以使用getpid()函数。该函数会返回一个整数类型的值，代表当前程序的进程标识数。

当程序进入子进程中时，需要使用一段while循环来重复显示字符串“child: ”和当前子进程的标识数。方法与父进程类似，调用getpid()函数即可。

最后，在程序的结尾处要加上一条return语句，返回整数值0，表示程序顺利结束。

整个程序的代码如下：

#include <stdio.h>
#include <unistd.h>

int main() {
  pid_t pid1, pid2;

  pid1 = fork();
  pid2 = fork();

  if (pid1 < 0 || pid2 < 0) {
    printf("fork() failed\n");
    return -1;
  } else if (pid1 == 0) {
    while (1) {
      printf("child: %d\n", getpid());
      sleep(1);
    }
  } else if (pid2 == 0) {
    while (1) {
      printf("child: %d\n", getpid());
      sleep(1);
    }
  } else {
    while (1) {
      printf("parent: %d\n", getpid());
      sleep(1);
    }
  }

  return 0;
}

该程序使用了fork()系统调用来创建两个子进程。当调用fork()时，该函数会分别返回两个值，分别代表两个子进程的进程标识符。在程序中，pid1代表第一个子进程的进程标识符，pid2代表第二个子进程的进程标识符。如果pid1或pid2的值小于0，则表明fork()调用失败；如果pid1或pid2的值等于0，则表明当前程序在执行子进程中；如果pid1和pid2都大于0，则表明当前程序在执行父进程中。

在父进程中，使用while循环来重复显示字符串“parent: ”和当前父进程的进程标识符，即getpid()的返回值。

在子进程中，同样使用while循环来重复显示字符串“child: ”和当前子进程的进程标识符。同样是用getpid()函数来获取当前子进程的进程标识符。

最后，需要加上一条return语句，返回值为0，表示程序执行成功结束。