Quasi tutti i programmi C++ utilizzano comandi speciali specifici del compilatore chiamati direttive. In generale, una direttiva è un'istruzione al compilatore C++ per eseguire un'azione al momento della compilazione del programma. Esiste un insieme ben definito di possibili direttive, che include le seguenti definizioni:
#define, #elif, #else, #endif, #if, #ifdef, #ifndef, #include, #undef.
La direttiva #define viene utilizzata per impostare costanti, parole chiave, operatori ed espressioni utilizzate nel programma. La sintassi generale di questa direttiva è la seguente:
Va notato che il simbolo ';' non è posto dopo le direttive. Di seguito sono riportati esempi dei casi d'uso per la direttiva #define.
Listato 1.2. Esempi di utilizzo della direttiva #define.
#includere
#definisci DUE 2
#define QUATTRO DUE * DUE
#define PX printf ("X è% d. \ n", x)
#define FMT "X è% d. \ n"
#define QUADRATO (X) X * X
intero principale ()
{
int x = DUE;
PX;
x = QUATTRO;
printf (FMT, x);
x = QUADRATO (3);
PX;
Ritorna 0;
}
Dopo aver eseguito questo programma, sullo schermo del monitor appariranno tre righe:
X è 2.
X è 4.
X è 9.
La direttiva #undef sovrascrive la definizione introdotta in precedenza dalla direttiva #define. Supponiamo che in qualche parte del programma sia necessario annullare la definizione della costante QUATTRO. Ciò si ottiene con il seguente comando:
Una caratteristica interessante di questa direttiva è la capacità di sovrascrivere il valore di una costante introdotta in precedenza. Infatti, riutilizzare la direttiva #define per la costante QUATTRO precedentemente introdotta è impossibile, poiché questo risulterà in un messaggio di errore al momento della compilazione del programma. Ma se si annulla la definizione della costante QUATTRO utilizzando la direttiva #undef, allora diventa possibile riutilizzare la direttiva #define per la costante QUATTRO.
Per poter eseguire la compilazione condizionale, viene utilizzato un gruppo di direttive #if, #ifdef, #ifndef, #elif, #else e #endif. Il programma seguente collegherà le librerie in base alle costanti impostate.
#se definito (GRAFICO)
#elif definito (TESTO)
#altro
#finisci se
Questo programma funziona come segue. Se una costante denominata GRAPH è stata precedentemente impostata tramite la direttiva #define, la libreria grafica verrà inclusa utilizzando la direttiva #include. Se GRAPH non è definito, ma TEXT è definito, verrà utilizzata la libreria di I/O di testo. Diversamente, in assenza di definizioni, è inclusa la libreria I/O. Invece della frase #if definita, vengono spesso utilizzate le abbreviazioni #ifdef e #ifndef e il programma sopra può essere riscritto come:
#ifdef GRAFICO
#include // include libreria grafica
#ifdef TESTO
#include // include la libreria di testo
#altro
#include // include la libreria I/O
#finisci se
La differenza tra la direttiva #if e le direttive #ifdef e #ifndef risiede nella capacità di controllare condizioni più diverse, e non solo se esistono o meno delle costanti. Ad esempio, utilizzando la direttiva #if puoi controllare:
#se DIMENSIONE == 1
#include // include la libreria matematica
#elif TAGLIA> 1
#include // connette la libreria di elaborazione degli array
#finisci se
Nell'esempio fornito, è collegata una libreria matematica o una libreria di elaborazione di array, a seconda del valore della costante SIZE.
Queste direttive vengono talvolta utilizzate per evidenziare i blocchi di programma necessari che devono essere utilizzati in una particolare implementazione del software. L'esempio seguente mostra come funziona questo codice.
Listato 1.3. Un esempio di compilazione di singoli blocchi di un programma.
#includere
#define SQUARE
intero principale ()
{
int s = 0;
int lunghezza = 10;
int larghezza = 5;
#ifdef PIAZZA
s = lunghezza * larghezza;
#altro
s = 2 * (lunghezza + larghezza);
#finisci se
Ritorna 0;
}
Questo esempio calcola l'area del rettangolo o il suo perimetro, a seconda che il valore SQUARE sia definito o meno. Per impostazione predefinita, il programma calcola l'area di un rettangolo, ma se si rimuove la linea #define SQUARE, il programma ne calcolerà il perimetro.
La direttiva #include utilizzata negli esempi precedenti consente di aggiungere programmi scritti in precedenza e salvati come file al programma. Ad esempio, la linea
#include & lt stdio.h>
dice al preprocessore di aggiungere il contenuto del file stdio.h invece della riga data. Questo dà grande flessibilità, facilità di programmazione e chiarezza del testo generato del programma. Esistono due versioni della direttiva #include:
#include & lt stdio.h> - nome file tra parentesi angolari
#include "mylib.h" - nome file tra virgolette
Le parentesi angolari dicono al preprocessore di cercare un file (in questo caso stdio.h) in una o più directory di sistema standard. Le virgolette indicano che il preprocessore deve prima cercare un file nella directory corrente, ad es. in cui si trova il file del programma creato e solo allora - cerca nelle directory standard.
In questo articolo continueremo a comprendere l'arte della programmazione in linguaggio C++. A questo punto del tutorial, è il momento di familiarizzare con cose come le direttive del preprocessore. Guardando avanti, dirò che nelle lezioni precedenti abbiamo già usato la direttiva #includere, che serve per includere i file di intestazione.
Innanzitutto, definiamo cos'è un preprocessore. La compilazione di qualsiasi programma avviene in più fasi e una delle prime è la preelaborazione. In parole povere, un preprocessore è un programma che legge il codice sorgente del programma e lo modifica in base alle direttive. L'intero processo di costruzione di un programma può essere rappresentato schematicamente come segue.
Come puoi vedere, appena prima della compilazione, il codice sorgente del programma viene elaborato dal preprocessore, diamo un'occhiata più da vicino alle sue istruzioni.
Iniziamo con la direttiva #include, che viene sostituita dal preprocessore con il contenuto del file che lo segue. Esempio usando #include:
#includere
#include "header2.h"
Se il nome del file è racchiuso tra parentesi angolari, il preprocessore cerca il file in una posizione predefinita. L'uso delle doppie parentesi presuppone che un file sia connesso dalla stessa directory in cui si trova il codice sorgente del programma compilato. Vale anche la pena notare che i file include possono anche contenere direttive per il preprocessore, in particolare la direttiva #include, quindi potrebbero esserci problemi con più connessioni dello stesso file. Per evitare questo tipo di confusione sono state introdotte delle direttive condizionali, vediamo un esempio del loro utilizzo:
#ifndef CUCUMBLER_H
#define CUCUMBLER_H
/ * contenuto del file cucumbler.h * /
La direttiva #ifndef verifica se la costante CUCUMBLER_H è stata definita in precedenza e se la risposta è negativa, viene eseguita la definizione di questa costante e altro codice che segue prima della direttiva #endif. Come puoi immaginare, la direttiva #define definisce la costante CUCUMBLER_H. In questo caso, tale pezzo di codice aiuta ad evitare l'inclusione multipla dello stesso codice, poiché dopo la prima inclusione, la costante CUCUMBLER_H verrà inizializzata e i successivi controlli #ifndef CUCUMBLER_H restituiranno FALSE.
La direttiva #define è anche ampiamente utilizzata durante il debug di un programma.
#includere
#includere
#includere
usando lo spazio dei nomi std;
cout<< "Начало функции main()\n";
vettore
array_testo; mentre (cin >> testo)
cout<< "Прочитан текст: " << text << "\n";
text_array.push_back (testo);
Se la costante IN_DEBUG non è specificata, il preprocessore genererà la seguente sorgente:
#includere
#includere
#includere
usando lo spazio dei nomi std;
vettore
array_testo; mentre (cin >> testo)
text_array.push_back (testo);
Ma se definisci IN_DEBUG, il testo del programma cambierà drasticamente
#includere
#includere
#includere
usando lo spazio dei nomi std;
cout<< "Начало функции main()\n";
vettore
array_testo; mentre (cin >> testo)
cout<< "Прочитан текст: " << text << "\n";
text_array.push_back (testo);
Puoi impostare una costante del preprocessore direttamente dalla console. Ad esempio, per il compilatore g++, viene utilizzato il seguente formato
#includereLa direttiva #include inserisce il codice dal file specificato nel file corrente, cioè semplicemente collegando un altro file, possiamo usare le sue funzioni, classi, variabili. I file di intestazione si trovano solitamente nella directory corrente o nella directory di sistema standard.
I file di intestazione vengono inclusi in fase di compilazione o come file che fa parte del progetto. Questa funzione dipende dall'implementazione specifica del tuo compilatore, quindi scava nelle impostazioni del tuo compilatore per maggiori dettagli.
Se il file di inclusione non viene trovato, il processo di compilazione avrà esito negativo.
#Definisci direttiva
La direttiva #define assume due forme:
- definizione di costanti;
- definizione di macro.
Definizione di costanti
#define nomeValore tokenQuando si utilizza il nome della costante - nameToken, verrà sostituito dal valore value, ovvero, in parole povere, questa è la stessa variabile, il cui valore non può essere modificato. Vediamo un esempio di utilizzo di una costante:
#includere
Come puoi vedere, per accedere al valore di una costante, usiamo semplicemente il suo nome.
Definizione di macro parametrizzate
#define nameEspressione Macro (arg1, arg2, ...)Ad esempio, definiamo una macro che restituirà il massimo di due valori.
#define MAX (num1, num2) ((num1)> (num2)? (num1): (num2))
Attenzione, per definire una macro multiriga, in ogni riga, alla fine, deve essere posizionato un simbolo, che informi il preprocessore che la macro non è stata ancora completata.
#Direttiva Undef
La direttiva #undef sovrascrive una costante o una macro del preprocessore precedentemente definita utilizzando la direttiva #define.
#nome undef Token
Vediamo un esempio di utilizzo della direttiva #undef:
#define E 2.71828 // macro definita in precedenza int sumE = E + E; // chiama la macro #undef E // ora E non è una macro
In genere, la direttiva #undef viene utilizzata per annullare l'impostazione di una costante o macro definita in precedenza in una piccola area del programma. Questo viene fatto in modo che per l'intero programma rimanga una macro o una costante e per una certa area si possa ridefinire la stessa macro o una costante. Non sarebbe sicuro ignorare una costante in tutto il programma, ma in un breve ambito è relativamente sicuro. La direttiva #undef è l'unico modo per creare questo ambito, poiché l'ambito di macro o costanti varia da #define a #undef.
#If direttiva
#if valore // codice che verrà eseguito se valore è vero #elsif valore1 // questo codice verrà eseguito se valore1 è vero #else // codice che verrà eseguito altrimenti #endifLa direttiva #if controlla se value è vero e, in tal caso, viene eseguito il codice prima della direttiva di chiusura #endif. In caso contrario, il codice all'interno di #if non verrà compilato, verrà rimosso dal compilatore, ma ciò non influisce sul codice sorgente nel sorgente.
Nota che #if può contenere direttive #elsif e #else annidate. Di seguito è riportato un codice di esempio per commentare blocchi di codice utilizzando il seguente costrutto:
#if 0 // codice per commentare #endif
Se hai blocchi di codice nel tuo programma che contengono commenti su più righe e devi racchiudere l'intero blocco di codice in un commento, non funzionerà se usi / * commento su più righe * /. Altra cosa è la costruzione delle direttive #if #endif.
#Direttiva Ifdef
#ifdef nameToken // codice che verrà eseguito se nameToken è definito #else // codice che verrà eseguito se nameToken non è definito #endifLa direttiva #ifdef controlla se una macro o una costante simbolica è stata precedentemente definita come #define. Se - si, il compilatore include nel programma il codice che sta tra le direttive #ifdef e #else, se nameToken non era stato precedentemente definito, allora viene eseguito il codice tra #else e #endif, oppure, se non c'è #else direttiva, il compilatore va immediatamente a # endif. Ad esempio, la macro __cpp è definita in C++, ma non in C. Puoi usare questo fatto per mescolare il codice C e C ++ usando la direttiva #ifdef:
#ifdef __cpp // Codice C ++ #else // Codice C #endif
#Direttiva Ifndef
#ifndef nameToken // codice che verrà eseguito se nameToken non è definito #else // codice che verrà eseguito se nameToken è definito #endifLa direttiva #ifndef controlla se una macro o una costante simbolica è stata precedentemente definita come #define. Se sì, il compilatore include nel programma il codice che sta tra le direttive #else e #endif, se nameToken non era stato precedentemente definito, allora viene eseguito il codice tra #ifndef e #else, oppure, se non c'è la direttiva #else , il compilatore passa immediatamente a # endif. La direttiva #ifndef può essere utilizzata per includere file di intestazione. se non sono collegati, per questo utilizzare una costante simbolica come indicatore della funzionalità connessa al progetto.
Ad esempio, il file di intestazione contiene un'interfaccia di classe che deve essere connessa al progetto se questa classe non era stata precedentemente connessa.
#ifndef PRODUCT_H #define PRODUCT_H class Prodotto (// codice classe ...); #endif PRODUCT_H
In questo caso viene utilizzata la costante simbolica vuota PRODUCT_H, che può essere definita solo nel programma insieme alla classe Product. Pertanto, se troviamo che la costante PRODUCT_H è già definita, anche la classe lo è e quindi escluderemo la ridefinizione della classe, che può portare a un errore di override.
#Errore direttiva
#error "Questo codice non deve essere compilato"La direttiva #error consente di visualizzare un messaggio nell'elenco degli errori di compilazione se si verifica un errore corrispondente. Questa direttiva è molto utile in combinazione con le direttive #if, #elsif, #else per controllare la compilazione se alcune condizioni non sono vere. Ad esempio:
#ifndef __unix__ // __unix__ è solitamente supportato su sistemi Unix #error "Supportato solo su Unix" #endif
__FILE__ macro del preprocessore
La macro del preprocessore __FILE__ si espande nel percorso completo del file corrente (sorgente). __FILE__ è utile per creare un file di registro, generare messaggi di errore destinati ai programmatori, durante il debug del codice.
Errore int (const char * adrFile, const std :: string & erMessage) (cerr<< "[" << adrFile << "]" << arMessage << endl; } #define LOG(erMessage) error(__FILE__, arMessage) // макрос LOG может быть использован для получения сообщений об ошибках, которые выводятся на стандартный поток ошибок
La macro __FILE__ viene spesso utilizzata insieme alla macro __LINE__, che fornisce il numero di riga corrente.
__LINE__ macro del preprocessore
La macro __LINE__ si espande al numero di riga corrente nel file di origine come valore intero. __LINE__ è utile per generare un file di registro o per generare messaggi di errore del numero di riga per i programmatori durante il debug del codice.
Errore int (int nLine, const std :: string & erMessage) (cerr<< "[" << nLine << "]" << erMessage << endl; } #define LOG(erMessage) error(__LINE__, erMessage) // макрос LOG может быть использован для получения сообщений об ошибках, с указанием номеров строк, которые выводятся на стандартный поток ошибок
La macro __LINE__ viene spesso utilizzata insieme alla macro __FILE__, che mostra l'indirizzo del file di origine corrente.
__DATE__ macro del preprocessore
La macro __DATE__ si espande alla data corrente (ora di compilazione) come [mmm gg aaaa] (ad esempio, "7 dicembre 2012"), come stringa. __DATE__ può essere utilizzato per fornire informazioni in fase di compilazione.
cout<< __DATE__ << endl;
Puoi anche usare la macro __TIME__ per ottenere il tempo di compilazione corrente.
__TIME__ macro del preprocessore
La macro __TIME__ si espande all'ora corrente (ora di compilazione) nel formato hh: mm: cc nel formato 24 ore (ad esempio, "22:29:12"). La macro __TIME__ può essere utilizzata per fornire informazioni sull'ora in un punto particolare della compilazione.
cout<< __TIME__ << endl;
__TIMESTAMP__ macro del preprocessore
La macro __TIMESTAMP__ si espande all'ora corrente (ora di compilazione) nel formato Ddd Mmm Date hh :: mm :: ss yyyy, l'ora in formato 24 ore:
- Ddd è il giorno della settimana abbreviato,
- mmm questo è abbreviato come un mese,
- Data - il giorno corrente del mese (1-31),
- aaaa sono le quattro cifre dell'anno.
Ad esempio, "ven 7 dic 00:42:53 2012". La macro __TIMESTAMP__ può essere utilizzata per ottenere informazioni su data e ora di compilazione.
cout<< __TIMESTAMP__ << endl;
È inoltre possibile utilizzare la macro __TIME__ per ottenere l'ora di compilazione corrente e la macro __DATE__ per ottenere la data.
#Direttiva Pragma
Estensione specifica del compilatore #pragmaLa direttiva #pragma viene utilizzata per accedere a specifiche estensioni del compilatore. L'utilizzo della direttiva #pragma con il token once richiede al compilatore di includere il file di intestazione solo una volta, indipendentemente da quante volte viene importato:
#pragma once // file di intestazione
In questo esempio, la direttiva #pragma once non consente di includere il file nel progetto più volte, ovvero impedisce l'override.
La direttiva #pragma può essere utilizzata anche per altri scopi, ad esempio #pragma viene solitamente utilizzata per disabilitare gli avvisi. Ad esempio, in MVS:
#pragma avviso (disabilita: 4018)
La direttiva #pragma in questo esempio viene utilizzata per disabilitare gli avvisi 4018. Per un maggiore utilizzo della direttiva #pragma, fare riferimento alla documentazione del compilatore.
Operatore macro #
#Operatore # un token di testo in una stringa tra virgolette. Vediamo un esempio:
#includere
Concatena le stringhe ed espandi la macro del messaggio in cout<< "Сообщение: GunGamen"; . Обратите внимание на то, что операция # должна использоваться совместно с аргументами, так как # ссылается на аргумент.
Operatore macro ##
L'operatore ## prende due token separati e li incolla insieme per formare una macro. Il risultato può essere un nome di variabile, nome di classe o qualsiasi altro identificatore. Ad esempio:
#define tipo ch ## ar tipo a; // la variabile a è il tipo di dati char, poiché ch e ar sono incollati a char
Consideriamo un altro esempio di utilizzo dell'operatore ##, in cui combiniamo due token:
#define TOKENCONCAT (x, y) x ## y
Quando un programma chiama questa macro, i due token vengono uniti in uno. L'operazione ## deve avere due operandi.
PS .: Qualsiasi programma serio deve avere un proprio database, di solito vengono utilizzati i seguenti DBMS per gestire il database: MySQL, MsSQL, PostgreeSQL, Oracle, ecc. Quando si installa sql server, il forum su cyberforum.ru sarà un assistente insostituibile per voi. Poni le tue domande su questo forum, sarai sicuramente aiutato a risolvere il tuo problema.
preprocessore. Lo scopo del preprocessore è elaborare il codice sorgente del programma prima che venga compilato. La preelaborazione include diverse fasi che vengono eseguite in sequenza. Un'implementazione concreta può combinare più fasi, ma il risultato dovrebbe essere come se fossero eseguite nel seguente ordine:- Tutte le designazioni dipendenti dal sistema vengono convertite in codici standard.
- Ogni coppia di caratteri "\" e "fine riga" insieme agli spazi tra di loro vengono rimossi e quindi la riga successiva del testo di origine viene aggiunta alla riga in cui si trovava questa coppia di caratteri.
- Le direttive e i token del preprocessore vengono riconosciuti nel testo e ogni commento viene sostituito da uno spazio vuoto.
- Le direttive del preprocessore vengono eseguite e vengono eseguite le sostituzioni di macro.
- Sequenze di fuga in caratteri costanti e stringhe di caratteri vengono sostituiti con i loro equivalenti.
- Le stringhe di caratteri adiacenti vengono concatenate, ovvero concatenate in un'unica stringa.
- Ogni token del preprocessore viene convertito in testo C.
Spieghiamo cosa si intende per token del preprocessore o token del preprocessore. Questi includono costanti di caratteri, includono nomi di file, identificatori, segni di operazione, numeri di preprocessore, segni di punteggiatura, costanti di stringa e qualsiasi carattere diverso dagli spazi.
La fase di elaborazione delle direttive del preprocessore. Durante l'esecuzione, sono possibili le seguenti azioni:
- sostituzione degli identificatori con sequenze di caratteri pre-preparate;
- inclusione di testi dai file specificati nel programma;
- esclusione dal programma di alcune parti del suo testo, compilazione condizionale;
- sostituzione di macro, ovvero sostituire la designazione con un testo parametrizzato generato dal preprocessore tenendo conto di argomenti specifici.
Costanti simboliche: #define
Se il simbolo # viene utilizzato come primo carattere in una riga di programma, questa riga è riga di comando preprocessore (macroprocessore). Riga di comando Il preprocessore termina con un carattere di nuova riga. Se metti il carattere barra rovesciata "\" immediatamente prima della fine della riga, allora riga di comando continuerà alla riga successiva del programma.
La direttiva #define, come tutte le direttive del preprocessore, inizia con un # nella posizione più a sinistra. Può apparire ovunque nel file di origine e la definizione è valida da dove appare fino alla fine del file. Stiamo attivamente utilizzando questa direttiva per definire costanti simboliche nei nostri programmi di esempio, tuttavia, ha un'applicazione più ampia, che mostreremo in seguito.
Sostituzione degli identificatori
#define id string
Sostituisce ogni occorrenza dell'identificatore ABC nel testo del programma con 100:
#identificatore undef
Inverte la definizione precedente per l'identificatore ABC.
/ * Semplici esempi di direttiva per il preprocessore * / #define TWO 2 / * possono essere utilizzati commenti * / #define MSG "Text 1. \ Continued text 1" / * backslash continua la definizione alla riga successiva * / #define FOUR TWO * TWO # define PX printf ("X è% d. \ n", x) #define FMT "X è% d. \ n" int main() (int x = DUE; PX; x = QUATTRO; printf (FMT, x) ; printf ("% s \ n", MSG); printf ("DUE: MSG \ n"); return DUE;)
Come risultato dell'esecuzione del nostro esempio, avremo.
Ultimo aggiornamento: 22.05.2017
Il preprocessore è un componente obbligatorio del compilatore C. Il preprocessore elabora il codice sorgente del programma prima di compilarlo direttamente. Il risultato del lavoro del preprocessore è il testo completo del programma, che viene inviato per la compilazione in un file eseguibile.
Per controllare il preprocessore, vengono utilizzate le direttive, ognuna delle quali inizia con un carattere hash # e si trova su una riga separata. Il preprocessore scansiona il testo del programma, trova queste direttive e le elabora in modo appropriato.
Possiamo utilizzare le seguenti direttive:
#define: definisce una macro o un identificatore del preprocessore
#undef: annulla la definizione di una macro o di un identificatore
#ifdef: controlla se è definito un id
#ifndef: verifica l'ambiguità dell'identificatore
#include: include il testo dal file
#if: verifica un'espressione condizionale (come un'istruzione if condizionale)
#else: imposta una condizione alternativa per #if
#endif: fine della direttiva #if condizionale
#elif: imposta una condizione alternativa per #if
#line: cambia il numero della riga successiva sotto
#error: genera il testo di un messaggio di errore broadcast
#pragma: definisce le azioni che dipendono dall'implementazione specifica del compilatore
#: direttiva vuota, essenzialmente non fa nulla
Consideriamo la principale di queste direttive.
#Include direttiva. Compresi i file
La direttiva #include è già stata utilizzata. Questa direttiva include i file nel testo di origine. Ha le seguenti forme di applicazione:
#includere<имя_файла>// nome file tra parentesi angolari #include "nome_file" // nome file tra virgolette
Ad esempio, se dobbiamo utilizzare l'I/O della console in un'applicazione utilizzando le funzioni printf() o scanf(), dobbiamo includere il file "stdio.h", che contiene la definizione di queste funzioni:
#includere
Quando questa direttiva viene eseguita, il preprocessore inserisce il testo del file stdio.h. Questo file è anche chiamato intestazione. I file di intestazione contengono prototipi di funzioni, definizioni e descrizioni di tipi e costanti e hanno l'estensione .h.
Il file viene cercato nelle directory di sistema standard. In generale, esiste un set standard di file di intestazione incorporati che sono definiti dallo standard del linguaggio e che possiamo usare:
assert.h: responsabile della diagnostica del programma
complex.h: per lavorare con numeri complessi
ctype.h: responsabile della conversione e del controllo dei caratteri
errno.h: responsabile del controllo degli errori
fenv.h: per accedere all'ambiente che controlla le operazioni in virgola mobile
float.h: è responsabile dell'utilizzo dei numeri in virgola mobile
inttypes.h: per lavorare con interi grandi
iso646.h: contiene una serie di definizioni che estendono un numero di operazioni booleane
limits.h: contiene i limiti per i tipi interi
locale.h: responsabile del lavoro con la cultura locale
math.h: per lavorare con espressioni matematiche
setjmp.h: determina le capacità dei salti non locali
signal.h: per la gestione delle eccezioni
stdalign.h: per l'allineamento del tipo
stdarg.h: fornisce supporto per un numero variabile di parametri
stdatomic.h: per eseguire operazioni atomiche su dati condivisi tra thread
stdbool.h: per lavorare con il _tipo Bool
stddef.h: contiene una serie di definizioni ausiliarie
stdint.h: per lavorare con numeri interi
stdio.h: per lavorare con le strutture di I/O
stdlib.h: contiene definizioni e prototipi di funzioni comuni
stdnoreturn.h: contiene la macro noreturn
string.h: per lavorare con le stringhe
tgmath.h: collega math.h e complex.h e aggiunge funzionalità aggiuntive per lavorare con calcoli matematici
threads.h: per lavorare con i thread
time.h: per lavorare con date e orari
uchar.h: per lavorare con i caratteri Unicode
wchar.h: per lavorare con i simboli
wctype.h: contiene opzioni aggiuntive per lavorare con i simboli
Tuttavia, va notato che in vari ambienti è possibile aggiungere ulteriori file di intestazione incorporati a questo set per vari scopi, ad esempio per lavorare con la grafica.
Oltre ai file di intestazione standard, possiamo includere i nostri file. Ad esempio, nella stessa cartella in cui si trova il file del programma principale, definiremo un altro file, che chiameremo main.c. Definiamo il seguente codice in esso:
Int numero = 5;
Definisce solo una variabile. Ora includiamo questo file nel programma:
#includere
Quando si collegano i loro file, il loro nome è indicato tra virgolette. E nonostante il fatto che la variabile numero non sia definita nel programma, sarà presa dal file main.c. Ma ancora una volta, noto che è importante che in questo caso il file main.c si trovi nella stessa cartella con i file del programma principale.
Allo stesso tempo, questo metodo funziona alla grande in GCC. Ma per diversi ambienti di programmazione, il modo di connettere i file potrebbe essere diverso. Ad esempio, in Visual Studio otterremo un errore. E un approccio più corretto sarebbe definire la dichiarazione di un oggetto (variabile / costante) o funzione in un file di intestazione aggiuntivo e inserire la definizione dell'oggetto o della funzione in un file standard con estensione .c.
Ad esempio, nel nostro file main.c c'è già una definizione per il numero variabile. Ora aggiungi un nuovo file main.h alla stessa cartella, un file con lo stesso nome, ma con un'estensione diversa. E definire il seguente codice in main.h:
Numero interno esterno;
La parola chiave extern indica che questo oggetto è esterno. E in questo caso, potremmo includerlo nel file del codice sorgente:
#includere
Questo esempio funzionerà anche in GCC, tuttavia, come discusso sopra, incluso il file main.h per GCC è facoltativo.
Se lo sviluppo viene eseguito in Visual Studio, non è necessario che la definizione dell'oggetto includa il file di origine:
#includere
Nonostante il fatto che il file main.c non sia incluso esplicitamente qui, ma durante la traduzione di Visual Studio tramite il file di intestazione main.h sarà possibile connettere il file main.c che si trova nella stessa cartella.
