Alphin Thomas's questions

Tenho o seguinte código C que grava em um arquivo tanto do processo pai quanto do filho após um fork(). No entanto, a saída em testfile.txtàs vezes é corrompida ou está em uma ordem inesperada.

Estou anexando o código:

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

int main() {
    int fd = open("testfile.txt", O_WRONLY | O_CREAT, 0644);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    if (fork() == 0) { 
        // Child process
        write(fd, "Child\n", 6);
        close(fd);
    } else {
        // Parent process
        write(fd, "Parent\n", 7);
        close(fd);
    }

    return 0;
}

Emitir :

• O arquivo às vezes contém "Child\nParent\n"e outras vezes"Parent\nChild\n"
• Em alguns casos, a saída é corrompida ou misturada
• Eu esperava que cada processo fosse escrito separadamente, mas eles parecem interferir um no outro

Pergunta:

1. Por que isso está acontecendo?
2. Como posso garantir gravações corretas e separadas de cada processo?

Em muitos casos, compilamos um programa C e executamos o binário sem nos preocuparmos com mudanças no arquivo fonte original. No entanto, estou curioso:

É possível que um programa C em execução detecte se seu próprio .carquivo de origem foi modificado após a compilação?

Algumas restrições a considerar:

• O programa deve verificar se há modificações em seu próprio arquivo de origem, não apenas no binário ( a.out)
• Não deve depender de ferramentas externas como md5sumou statpor meio system()de chamadas.
• A solução deve funcionar em sistemas operacionais comuns (Linux/Windows)
• Isso deve ser feito puramente em C, usando bibliotecas de sistema padrão ou amplamente disponíveis.

Isso exigiria a leitura do arquivo de origem em tempo de execução e a comparação de registros de data e hora ou hashes, ou existe uma maneira mais elegante de fazer isso?

Sabemos que esse main()é o ponto de entrada de um programa em C. Mas o que acontece se definirmos maincomo uma macro, assim?

#define main something_else

• O programa será compilado e executado corretamente?
• Como diferentes compiladores lidam com essa situação?
• Há casos em que redefinir maincomo uma macro pode ser útil ou problemático?

Li que C não exige um tamanho mínimo de pilha, deixando-o definido pela implementação. Mas um compilador C em conformidade poderia se recusar a compilar um programa se ele detectar — digamos, por meio de análise estática — que a profundidade da pilha de chamadas (por exemplo, de uma chamada de função aninhada) excede um limite fixo que ele suporta? Ou isso é sempre um problema de tempo de execução? Estou curioso para saber se o padrão C (como C11 ou C23) permite rejeitar sintaxe válida em tempo de compilação com base apenas na profundidade da pilha, assumindo que não há recursão ou comportamento indefinido