Creare il tuo file di intestazione in C


Risposte:


300

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;
}

Per compilare utilizzando GCC

gcc -o my_app main.c foo.c

2
@Anu: non riesco a leggerlo in questo formato. È possibile modificare la domanda originale per includere questo codice.
Oliver Charlesworth,

3
Vale la pena notare che questo codice non funziona se si tenta di crearlo semplicemente tramite il pulsante (ad esempio "build and run" in Code :: Blocks). Potrebbe sembrare ovvio per te, ma per me è la prima volta che succede e mi ci è voluto un po 'di tempo per capire dov'è il problema.
Jeyekomon,

5
@Jeyekomon: Beh, dove è il problema?
Oliver Charlesworth,

2
Nessuno mi ha detto che il pulsante "costruisci ed esegui" non è sufficiente per tutto. :-) È stata una vera sorpresa per me (sono un novizio). Ora credo di dover imparare a usare prima la riga di comando o i makefile.
Jeyekomon,

1
Mi chiedevo se potessi approfondire come compilare con tutti i file richiesti e non dover includere foo.c nell'argomento del programma gcc. Come si chiama questa tecnica o quale programma può realizzare questo al di fuori di IDE - Make mi viene in mente
nf071590

26
#ifndef MY_HEADER_H
# define MY_HEADER_H

//put your function headers here

#endif

MY_HEADER_H funge da guardia a doppia inclusione.

Per la dichiarazione di funzione, è sufficiente definire la firma, ovvero senza i nomi dei parametri, in questo modo:

int foo(char*);

Se vuoi davvero, puoi anche includere l'identificatore del parametro, ma non è necessario perché l'identificatore verrebbe usato solo nel corpo di una funzione (implementazione), che nel caso di un'intestazione (firma del parametro), manca.

Questo dichiara la funzione fooche accetta a char*e restituisce un int.

Nel tuo file sorgente, avresti:

#include "my_header.h"

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

Sono conosciuti come dichiarazioni di funzione o prototipi di funzione , non "intestazioni di funzione". Le intestazioni sono i file che includi, non le dichiarazioni al loro interno.
Jonathan Wakely,

@JonathanWakely Questi sono i file di intestazione. Il nome dice tutto: i file header contengono header. Ma grazie per il feedback, mi ha fatto riflettere per un secondo.
Flavio

No, le intestazioni sono i file stessi, non le dichiarazioni che contengono. Riesci a trovare un unico riferimento affidabile per eseguire il backup dell'utilizzo di "header"? È contraddetto da K&R, lo standard C, L'ambiente di programmazione UNIX e Wikipedia , per esempio.
Jonathan Wakely

@JonathanWakely hai davvero letto K&R? Il sommario ha una sezione "4.5 File di intestazione" e "file di intestazione" è scritto in corsivo, indicando la terminologia. Nel resto del libro gli autori a volte scrivono solo "header" per brevità, ma attraverso la formattazione e il sommario è chiaro quale sia la giusta terminologia. Quindi, per favore, essere un professionista e riconoscere quando ti sbagli.
Flavio

Sì, e "header" si riferisce ai file , non alle dichiarazioni in essi contenute. Nella seconda edizione, vedere pagina 241 per la discussione delle intestazioni standard e pagina 33 che parla di definizioni e dichiarazioni (che erroneamente chiamate "intestazioni di funzione") e definisce chiaramente un'intestazione : "La pratica normale è quella di raccogliere externdichiarazioni di variabili e funzioni in un file separato, storicamente chiamato header , che è incluso #includenella parte anteriore di ogni file sorgente. Le funzioni della libreria standard, ad esempio, sono dichiarate come header <stdio.h>. "
Jonathan Wakely,

8

MYFILE.H

#ifndef _myfile_h
#define _myfile_h

void function();

#endif

miofile.c

#include "myfile.h"

void function() {

}

void function();come una dichiarazione non impedisce chiamate simili function(42);. Utilizzare voidnella dichiarazione comevoid function(void);
chux - Ripristinare Monica

5

i file di intestazione contengono prototipi per le funzioni definite in un file .c o .cpp / .cxx (a seconda se si utilizza c o c ++). Si desidera posizionare # ifndef / # definisce attorno al proprio codice .h in modo che se si include lo stesso .h due volte in parti diverse dei programmi, i prototipi vengono inclusi solo una volta.

client.h

#ifndef CLIENT_H
#define CLIENT_H

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


#endif /** CLIENT_H */

Quindi implementeresti il ​​file .h in un file .c in questo modo:

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;
}

"in modo che se includi lo stesso .h due volte in parti diverse dei tuoi programmi, i prototipi saranno inclusi solo una volta." Questo è fuorviante. Proteggono dall'includere due volte lo stesso file di intestazione dallo stesso file di origine (compresa un'intestazione due volte in due diversi file di origine è ok e generalmente richiesto!) E la dichiarazione di nuovo dei prototipi di funzioni non è un problema, ridefinendo tipi e variabili globali è ciò che deve essere protetto.
Jonathan Wakely
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.