getpid系统调用及示例

#include <sys/types.h> // 通常需要
#include <unistd.h>    // 必需

pid_t getpid(void);

#include <sys/types.h> // pid_t
#include <unistd.h>    // getpid
#include <stdio.h>     // printf

int main() {
    pid_t my_pid;

    // 调用 getpid 获取当前进程的 PID
    my_pid = getpid();

    // 打印 PID
    printf("Hello from process with PID: %d\n", (int)my_pid);
    // 注意：虽然 my_pid 是 pid_t 类型，但 printf 通常用 %d 打印，
    // 或者可以强制类型转换为 (long) 并用 %ld，以保证可移植性
    // printf("Hello from process with PID: %ld\n", (long)my_pid);

    // PID 在进程生命周期内不变
    pid_t my_pid_again = getpid();
    if (my_pid == my_pid_again) {
        printf("Confirmed: PID is consistent (%d).\n", (int)my_pid);
    } else {
        printf("Error: PID changed? (%d -> %d)\n", (int)my_pid, (int)my_pid_again);
    }

    return 0;
}

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

int main() {
    pid_t pid;
    pid_t my_pid;

    // 获取父进程的 PID
    my_pid = getpid();
    printf("Parent process PID: %d\n", (int)my_pid);

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

    if (pid == -1) {
        // fork 失败
        perror("fork failed");
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // --- 子进程 ---
        // 子进程获取自己的 PID
        pid_t child_pid = getpid();
        // fork 在子进程中返回 0
        printf("Child process created. Child's PID: %d, fork() returned: %d\n", (int)child_pid, (int)pid);

        // 子进程可以获取父进程的 PID
        pid_t parent_pid = getppid();
        printf("Child's parent PID: %d\n", (int)parent_pid);

        // 子进程执行一些任务
        for (int i = 0; i < 5; ++i) {
            printf("Child working... (Step %d)\n", i + 1);
            sleep(1); // 模拟工作
        }
        printf("Child process (PID %d) finished.\n", (int)child_pid);
        _exit(EXIT_SUCCESS); // 子进程使用 _exit 退出

    } else {
        // --- 父进程 ---
        // fork 在父进程中返回子进程的 PID
        printf("Parent process (PID %d) created child with PID: %d\n", (int)my_pid, (int)pid);

        // 父进程可以再次获取自己的 PID (应该与之前相同)
        pid_t parent_pid_again = getpid();
        if (parent_pid_again == my_pid) {
            printf("Parent PID confirmed: %d\n", (int)parent_pid_again);
        }

        // 父进程等待子进程结束
        int status;
        pid_t waited_pid = wait(&status);
        if (waited_pid == -1) {
            perror("wait failed");
            exit(EXIT_FAILURE);
        }

        printf("Parent process (PID %d) reaped child PID %d.\n", (int)my_pid, (int)waited_pid);
        if (WIFEXITED(status)) {
            printf("Child exited with status %d.\n", WEXITSTATUS(status));
        }

        printf("Parent process (PID %d) finished.\n", (int)my_pid);
    }

    return 0;
}

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

#define TEMP_FILE_TEMPLATE "/tmp/my_temp_file_XXXXXX"

int main() {
    pid_t my_pid;
    char temp_filename[256];
    FILE *temp_file;
    const char *data_to_write = "This is some data written by the process.\n";

    // 1. 获取进程 PID
    my_pid = getpid();

    // 2. 构造临时文件名 (方法一：直接使用 PID)
    snprintf(temp_filename, sizeof(temp_filename), "/tmp/my_app_%d.tmp", (int)my_pid);
    printf("Generated temporary filename (using PID): %s\n", temp_filename);

    // 3. 创建并写入临时文件
    temp_file = fopen(temp_filename, "w");
    if (temp_file == NULL) {
        perror("fopen temporary file");
        exit(EXIT_FAILURE);
    }

    if (fputs(data_to_write, temp_file) == EOF) {
        perror("fputs to temporary file");
        fclose(temp_file);
        // 尝试删除可能已创建的文件
        unlink(temp_filename);
        exit(EXIT_FAILURE);
    }

    if (fclose(temp_file) != 0) {
        perror("fclose temporary file");
        // 文件内容可能未完全写入磁盘
        unlink(temp_filename); // 仍然尝试清理
        exit(EXIT_FAILURE);
    }

    printf("Successfully wrote to temporary file: %s\n", temp_filename);

    // 4. (可选) 程序结束时清理临时文件
    // 在实际应用中，可能需要在信号处理函数或 atexit 中注册清理函数
    // 这里简单地在 main 结束前 unlink
    if (unlink(temp_filename) == 0) {
        printf("Temporary file '%s' deleted successfully.\n", temp_filename);
    } else {
        perror("unlink temporary file");
        // 不是致命错误，程序可以继续
    }

    // --- 方法二：使用 mkstemp (更安全和标准) ---
    printf("\n--- Using mkstemp for safer temporary file ---\n");
    char temp_filename_mkstemp[] = "/tmp/my_app_mkstemp_XXXXXX";
    int temp_fd = mkstemp(temp_filename_mkstemp); // 注意：参数不是 const
    if (temp_fd == -1) {
        perror("mkstemp");
        exit(EXIT_FAILURE);
    }
    printf("Created secure temporary file: %s\n", temp_filename_mkstemp);

    // 使用文件描述符写入
    if (write(temp_fd, data_to_write, strlen(data_to_write)) == -1) {
        perror("write to mkstemp file");
        close(temp_fd);
        unlink(temp_filename_mkstemp);
        exit(EXIT_FAILURE);
    }

    // 关闭文件描述符
    if (close(temp_fd) == -1) {
        perror("close mkstemp file");
        unlink(temp_filename_mkstemp);
        exit(EXIT_FAILURE);
    }

    // 清理 mkstemp 创建的文件
    if (unlink(temp_filename_mkstemp) == 0) {
        printf("Secure temporary file '%s' deleted successfully.\n", temp_filename_mkstemp);
    } else {
        perror("unlink secure temporary file");
    }

    printf("Both temporary file methods demonstrated.\n");
    return 0;
}