Nesta aula vamos aprender como criar arquivos de cabeçalho .h com a linguagem de programação C. Este é um recurso muito útil para uma melhor organização do código especialmente em grandes projetos.

O primeiro arquivo que vamos criar é nosso arquivo de cabeçalho .h. Este arquivo contém apenas a definição das estruturas que precisaremos e a assinatura das funções e procedimentos que iremos criar.

Para criar um arquivo de cabeçalho no Code Blocks clique no menu File-new-file e na janela que aparecer escolha a opção header (cabeçalho).

Como um arquivo de cabeçalho pode ser incluído em diversos arquivos diferentes, precisamos ter o cuidado de não carregá-lo mais de uma vez, isso irá duplicar nossas estruturas, funções e procedimentos podendo ocasionar em erros durante a execução do programa. Para evitar isso, podemos verificar se o arquivo já foi carregado por meio de uma estrutura if.

O ifndef significa if not defined, ou seja, se não existir uma definição chamada PILHA_H_INCLUDED, então essa definição será criada (na linha seguinte), assim como as estruturas serão criadas e as assinaturas das nossas funções e procedimentos.

Caso a definição PILHA_H_INCLUDED já exista, o fluxo de execução irá para endif e nada será feito.

O nome PILHA_H_INCLUDED não precisa ser exatamente assim. Eu escolhi este nome, você pode definir um nome diferente. O importante é que seja exatamente o mesmo nome na primeira e segunda linhas.

// arquivo pilha.h

#ifndef PILHA_H_INCLUDED
#define PILHA_H_INCLUDED

typedef struct no{
    int valor;
    struct no *proximo;
}No;

No* empilhar(No *pilha, int num);

No* desempilhar(No **pilha);

void imprimir(No *pilha);

#endif // PILHA_H_INCLUDED

Agora que já temos nosso arquivo de cabeçalhos, perceba que ele possui apenas as estruturas que iremos utilizar e as assinaturas das funções e procedimentos, das operações da nossa TAD. Precisamos criar propriamente estas funções e procedimentos. Para isso vamos criar um novo arquivo chamado pilha.c.

É dentro deste arquivo pilha.c que teremos nossas funções e procedimentos para operar sobre nosso conjunto de dados, a pilha. Este arquivo precisa de dois includes, o arquivo de cabeçalho stdio.h, onde está definido a constante NULL e o arquivo de cabeçalho pilha.h que acabamos de criar.

Observe que a inclusão do nosso arquivo fica entre um par de aspas duplas. Isso diz para o computador procurar este arquivo dentro do diretório do nosso projeto. Ao utilizar os sinais de maior e menor o compilador irá procurar este arquivo diretamente na pasta padrão do compilador, como stdio.h. Como o arquivo pilha.h está na pasta do projeto e não na pasta padrão do compilador, teremos um erro se tentarmos usar os sinais de maior menor no lugar das aspas duplas.

// arquivo pilha.c

#include <stdio.h>
#include "pilha.h"

No* empilhar(No *pilha, int num){
    No *novo = malloc(sizeof(No));

    if(novo){
        novo->valor = num;
        novo->proximo = pilha;
        return novo;
    }
    else
        printf("Erro ao alocar memoria!\n");
    return NULL;
}

No* desempilhar(No **pilha){
    No *remover = NULL;

    if(*pilha){
        remover = *pilha;
        *pilha = remover->proximo;
    }
    else
        printf("Pilha vazia!\n");
    return remover;
}

void imprimir(No *pilha){
    printf("\n\tPILHA\n");
    while(pilha){
        printf("\t%d\n", pilha->valor);
        pilha = pilha->proximo;
    }
    printf("\n");
}

Agora vamos criar nosso arquivo main.c. Neste arquivo, além dos includes que já estamos acostumados, também precisamos incluir nosso arquivo de cabeçalho pilha.h.

Perceba que a função fatorial não está definida no arquivo pilha.h nem no arquivo pilha.c, isso porque esta função não é uma operação que age sobre nosso conjunto de dados, como empilhar, desempilhar ou imprimir. Isso faz parte da organização do código. Imagine que além da estrutura pilha, também tivéssemos uma fila e uma lista encadeada (estruturas que veremos aqui no curso), poderíamos ter mais quatro arquivos:
– fila.h
– fila.c
– lista.h
– lista.c

Assim, cada arquivo contém o código de um TAD, deixando o código mais organizado e tornando a manutenção mais rápida e precisa.

/*
                 arquivo main.c

                 Código escrito por Wagner Gaspar
                 Julho de 2021
*/

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

int fatorial(int num){
    No *remover, *pilha = NULL;

    while(num > 1){
        pilha = empilhar(pilha, num);
        num--;
    }

    imprimir(pilha); // 2 3

    while(pilha){
        remover = desempilhar(&pilha);
        num = num * remover->valor;
        free(remover);
    }
    return num;
}

int main(){
    int valor;

    printf("Digite um valor maior que zero para o fatorial: ");
    scanf("%d", &valor);
    printf("\tFatorial de %d: %d\n", valor, fatorial(valor));

}