Para minha classe de programação 102, somos solicitados a fornecer código C que compila e executa no Linux. Não tenho espaço livre suficiente no disco rígido para instalar o Linux no Windows e, portanto, uso o cygwin para compilar meus programas.

O programa mais recente que tive que apresentar compila e roda bem no cygwin. Compila bem no Linux, mas no meio da execução produz uma falha de segmentação. Expliquei isso ao aluno de pós-graduação que nos dá aula e ele disse que a versão do cygwin do GCC permite que o código mais superficial seja compilado e executad

As poucas referências que encontrei via google não foram conclusivas. Um tópico que encontrei disse que a causa da falha seg no Linux é um vazamento de memória. Por que isso não afetaria a versão do cygwin?

Eu usaria os computadores da Universidade, mas não posso usar o Subversion neles, o que prejudicaria significativamente meus esforços. (Sou iniciante em codificação e geralmente preciso poder reverter para as revisões X atrás).

A versão do cygwin do GCC é realmente mais "relaxada" com o código que compila? Em caso afirmativo, existem problemas óbvios a serem observados ao codificar? Existem alternativas para escrever código que será executado no Linux?

Edita

Obrigado pelas respostas. Eu não fui explícito o suficiente no meu post original: o fato de haver um bug no meu código era praticamente um dado para mim (eu sou bastante novo em programação e realmente verde quando se trata de C, afinal). O GCC do meu cygwin, implicado por TA, é um compilador menos confiável - permitindo a execução de códigos muito mais desleixados - do que o encontrado no GNU / Linux. Achei isso estranho e fiz uma pesquisa na internet, mas não consegui encontrar nenhuma referência a esse fat

Mais do que culpar o compilador x meu código, fiquei pensando qual seria o motivo para o programa ser executado no Windows e travar no Linux. As respostas re: diferentes gerenciadores de memória e layout de pilha / pilha no Windows / Linux estavam ilustrando a esse respeit

A conclusão de que o GCC da cygwin é tão 'boa' quanto o GNU / Linux 'e é a sorte dos sistemas operacionais subjacentes / pura sorte que o meu programa de buggy é executado sob um e não o outro está praticamente correto?

Quanto à publicação do código-fonte, é uma tarefa de casa, então eu preferiria encontrar o problema, se possível:)

Edit 2

Aceitei a resposta do jalf, que fala sobre o que faz o programa rodar no Windows e não no Linux, que era o que eu realmente queria saber. Obrigado a todos que contribuíram, todas foram respostas muito interessantes e informativas.

Quando eu encontrar o problema e o corrigir, vou fazer upload de um arquivo zip com todo o código fonte desta versão não funcional, caso alguém esteja curioso para ver o que diabos eu fiz:)

Edit 3

Para aqueles interessados em ver o código, encontrei o problema, e isso ocorreu devido a indicadores. Eu estava tentando retornar um ponteiro de uma função. O ponteiro que eu estava tentando retornar estava sendo declarado dentro da função e, portanto, estava sendo destruído quando a função foi executada. O código problemático é comentado nas linhas 22 a 2

Sinta-se livre para ridicularizar meu códig

/**
*  Returns array of valid searches based on current coordinate
*/
void determine_searches(int row, int col, int last_row, int last_col, int *active_search){
    // define coordinate categories and related valid search directions
    int Library0[] = {2, 3, 4, -1};
    int Library1[] = {4, 5, 6, -1};
    int Library2[] = {2, 3, 4, 5, 6, -1};
    int Library3[] = {0, 1, 2, 3, 4, 5, 6, 7, -1};
    int Library4[] = {0, 1, 2, -1};
    int Library5[] = {0, 6, 7, -1};
    int Library6[] = {0, 1, 2, 6, 7, -1};
    int Library7[] = {0, 1, 2, 3, 4, -1};
    int Library8[] = {0, 4, 5, 6, 7, -1};

    int * Library[] = { 
        Library0, Library1, Library2,
        Library3, Library4, Library5,
        Library6, Library7, Library8,
    };

    // declare (and assign memory to) the array of valid search directions that will be returned
    //int *active_search;
    //active_search = (int *) malloc(SEARCH_DIRECTIONS * sizeof(int));


    // determine which is the correct array of search directions based on the current coordinate
    // top left corner
        int i = 0;
    if(row == 0 && col == 0){
        while(Library[0][i] != -1){
            active_search[i] = Library[0][i];
            i++;
        }
    }
    // top right corner
    else if(row == 0 && col == last_col){
        while(Library[1][i] != -1){
            active_search[i] = Library[1][i];
            i++;
        }
    }
    // non-edge columns of first row
    else if(row == 0 && (col != 0 || col != last_col)){
        while(Library[2][i] != -1){
            active_search[i] = Library[2][i];
            i++;
        }
    }
    // non-edge coordinates (no edge columns nor rows)
    else if(row != 0 && row != last_row && col != 0 && col != last_col){
        while(Library[3][i] != -1){
            active_search[i] = Library[3][i];
            i++;
        }
    }
    // bottom left corner
    else if(row == last_row && col == 0){
        while(Library[4][i] != -1){
            active_search[i] = Library[4][i];
            i++;
        }
    }
    // bottom right corner
    else if(row == last_row && col == last_col){
        while(Library[5][i] != -1){
            active_search[i] = Library[5][i];
            i++;
        }
    }
    // non-edge columns of last row
    else if(row == last_row && (col != 0 || col != last_col)){
        while(Library[6][i] != -1){
            active_search[i] = Library[6][i];
            i++;
        }
    }
    // non-edge rows of first column
    else if((row != 0 || row != last_row) && col == 0){
        while(Library[7][i] != -1){
            active_search[i] = Library[7][i];
            i++;
        }
    }
    // non-edge rows of last column
    else if((row != 0 || row != last_row) && col == last_col){
        while(Library[8][i] != -1){
            active_search[i] = Library[8][i];
            i++;
        }
    }
    active_search[i] = -1;
}