Criando seu próprio arquivo de cabeçalho em C


Respostas:


299

foo.h

#ifndef FOO_H_   /* Include guard */
#define FOO_H_

int foo(int x);  /* An example function declaration */

#endif // FOO_H_

foo.c

#include "foo.h"  /* Include the header (not strictly necessary here) */

int foo(int x)    /* Function definition */
{
    return x + 5;
}

main.c

#include <stdio.h>
#include "foo.h"  /* Include the header here, to obtain the function declaration */

int main(void)
{
    int y = foo(3);  /* Use the function here */
    printf("%d\n", y);
    return 0;
}

Para compilar usando o GCC

gcc -o my_app main.c foo.c

2
@ Anu: Eu não consigo ler isso neste formato. Você pode editar sua pergunta original para incluir esse código.
— Oliver Charlesworth

3
Vale a pena notar que esse código não funciona se você tentar compilá-lo por botão ("compilar e executar" no Code :: Blocks, por exemplo). Pode parecer óbvio para você, mas para mim é a primeira vez que isso acontece e levei algum tempo para descobrir onde está o problema.
— Jeyekomon

5
@Jeyekomon: Bem, onde está o problema?
— Oliver Charlesworth

2
Ninguém me disse que o botão "construir e executar" não é suficiente para tudo. :-) Foi uma surpresa para mim (eu sou um novato). Agora acho que tenho que aprender a usar a linha de comando ou os makefiles primeiro.
— Jeyekomon

1
Eu queria saber se você poderia elaborar como compilar com todos os arquivos necessários e não precisar incluir foo.c no argumento do programa gcc. O que é esta técnica chamada ou o programa pode fazer isso fora do IDE - Marca vem à minha mente
— nf071590

26
#ifndef MY_HEADER_H
# define MY_HEADER_H

//put your function headers here

#endif

MY_HEADER_H serve como um guarda de dupla inclusão.

Para a declaração da função, você só precisa definir a assinatura, ou seja, sem nomes de parâmetros, como este:

int foo(char*);

Se você realmente quiser, também pode incluir o identificador do parâmetro, mas não é necessário porque o identificador seria usado apenas no corpo de uma função (implementação), que, no caso de um cabeçalho (assinatura do parâmetro), está ausente.

Isso declara a função fooque aceita ae char*retorna uma int.

No seu arquivo de origem, você teria:

#include "my_header.h"

int foo(char* name) {
   //do stuff
   return 0;
}

Eles são conhecidos como declarações ou protótipos de função , não "cabeçalhos de função". Cabeçalhos são os arquivos que você inclui, não as declarações dentro deles.
— Jonathan Wakely

@ JonathanWakely Esses são os arquivos de cabeçalho. O nome diz tudo: os arquivos de cabeçalho contêm cabeçalhos. Mas obrigado pelo feedback, isso me fez pensar por um segundo.
— Flavius

Não, os cabeçalhos são os próprios arquivos, não as declarações que eles contêm. Você consegue encontrar uma única referência respeitável para fazer backup do uso do "cabeçalho"? É contradito por K&R, o padrão C, o ambiente de programação UNIX e a Wikipedia , por exemplo.
— Jonathan Wakely

@JonathanWakely você realmente leu K&R? O sumário contém uma seção "4.5 Arquivos de cabeçalho" e "Arquivos de cabeçalho" escritos em itálico, indicando terminologia. No restante do livro, os autores escrevem algumas vezes apenas "cabeçalho" por questões de concisão, mas, por meio da formatação e do sumário, fica claro qual é a terminologia correta. Então, por favor, seja um profissional e reconheça quando estiver errado.
— Flavius

Sim, e "cabeçalho" refere-se aos arquivos , não às declarações neles. Na 2ª edição, consulte a página 241 para discussão dos cabeçalhos padrão e a página 33, que fala sobre definições e declarações (que você chama erroneamente de "cabeçalhos de função") e define claramente um cabeçalho : "A prática usual é coletar externdeclarações de variáveis ​​e funções em um arquivo separado, historicamente chamado de cabeçalho , incluído #includena frente de cada arquivo de origem. As funções da biblioteca padrão, por exemplo, são declaradas em cabeçalhos como <stdio.h>".
— 111319 Jonathan Wakely

8

myfile.h

#ifndef _myfile_h
#define _myfile_h

void function();

#endif

myfile.c

#include "myfile.h"

void function() {

}

void function();como uma declaração não impede chamadas como function(42);. Use voidna declaração comovoid function(void);
— chux - Reinstate Monica

5

os arquivos de cabeçalho contêm protótipos para funções definidas em um arquivo .c ou .cpp / .cxx (dependendo se você estiver usando c ou c ++). Você deseja colocar # ifndef / # define em torno do seu código .h para que, se você incluir o mesmo .h duas vezes em diferentes partes dos seus programas, os protótipos sejam incluídos apenas uma vez.

client.h

#ifndef CLIENT_H
#define CLIENT_H

short socketConnect(char *host,unsigned short port,char *sendbuf,char *recievebuf, long rbufsize);


#endif /** CLIENT_H */

Em seguida, você implementaria o .h em um arquivo .c da seguinte forma:

client.c

#include "client.h"

short socketConnect(char *host,unsigned short port,char *sendbuf,char *recievebuf, long rbufsize) {
 short ret = -1;
 //some implementation here
 return ret;
}

"para que, se você incluir o mesmo .h duas vezes em diferentes partes dos seus programas, os protótipos sejam incluídos apenas uma vez." Isso é enganador. Eles se protegem contra a inclusão do mesmo arquivo de cabeçalho duas vezes do mesmo arquivo de origem (incluir um cabeçalho duas vezes em dois arquivos de origem diferentes é ok e geralmente é necessário!) E declarar novamente os protótipos de função não é um problema, redefinir tipos e variáveis ​​globais é o que deve ser protegido.
— Jonathan Wakely
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.