`#include` în C++

Operatori alternativi și preprocesor C++98

Directivă a preprocesorului care copiază conținutul unui fișier antet în locul ei, ca să poți folosi funcțiile și clasele declarate acolo.

Sintaxă

#include <antet_standard>
#include "fisierul_meu.h"

Ce face `#include`

Înainte de compilare, preprocesorul înlocuiește fiecare linie #include cu întregul conținut al fișierului indicat. Așa ajung în programul tău declarațiile lui std::vector, std::string sau ale propriilor funcții scrise în alt fișier.

Cu paranteze unghiulare (<vector>) fișierul este căutat în directoarele bibliotecilor standard și ale sistemului. Cu ghilimele ("calcul.h") este căutat întâi lângă fișierul curent, apoi în aceleași locuri. Anteturile standard C++ nu au extensie (<iostream>); cele moștenite din C au prefixul c (<cmath>, <cstring>).

Include tot ce folosești, chiar dacă merge și fără: un antet poate include întâmplător altul pe un compilator, dar nu pe altul. Fișierele antet proprii trebuie protejate împotriva includerii repetate cu #pragma once sau gărzi #ifndef. Din C++20 există și alternativa modulelor.

Exemple

Exemplul 1: Anteturi standard

Fiecare antet aduce altceva: <vector> containerul, <algorithm> sortarea, <cmath> radicalul, <print> afișarea.

#include <algorithm>
#include <cmath>
#include <print>
#include <vector>

int main() {
    std::vector<int> v = {25, 9, 16};
    std::sort(v.begin(), v.end());
    for (int x : v) {
        std::println("√{} = {}", x, std::sqrt(x));
    }
}

Rezultat

√9 = 3
√16 = 4
√25 = 5

Exemplul 2: Antet propriu (doi pași)

Fișierul calcul.h conține doar declarații și este inclus cu ghilimele. Definițiile stau într-un calcul.cpp separat, iar la compilare se dau ambele fișiere: c++ -std=c++23 main.cpp calcul.cpp -o program. Exemplul are mai multe fișiere, deci a fost compilat și rulat separat.

// ---- calcul.h ----
#pragma once
double cu_tva(double pret);

// ---- calcul.cpp ----
#include "calcul.h"
double cu_tva(double pret) { return pret * 1.21; }

// ---- main.cpp ----
#include <print>
#include "calcul.h"

int main() {
    std::println("{:.2f} lei", cu_tva(250));
}

Rezultat (cele trei fișiere compilate împreună)

302.50 lei

Greșeli frecvente

Folosești anteturi vechi: #include <iostream.h> sau <math.h> în loc de <cmath>. <iostream.h> nu mai există de peste 20 de ani.
Incluzi fișiere .cpp (#include "calcul.cpp"). Dacă fișierul este compilat și separat, funcțiile apar de două ori și primești „duplicate symbol” la legare. Include doar anteturi.
Folosești #include <bits/stdc++.h> (frecvent în concursuri). Este un antet intern GCC, nu există pe clang/MSVC și încetinește mult compilarea.

Comenzi înrudite

#pragma once: Pusă la începutul unui fișier antet, face ca fișierul să fie inclus o singură dată, chiar dacă apare în mai multe #include-uri.
#define: Definește un macro: preprocesorul înlocuiește textual numele cu valoarea lui, peste tot în cod, înainte de compilare.
#ifdef, #ifndef, #if, #endif: Compilare condiționată: păstrează sau elimină bucăți de cod înainte de compilare, după ce macro-uri sunt definite.
module, import, export: Modulele (C++20) înlocuiesc fișierele antet: un modul exportă ce vrea să fie vizibil, iar alt fișier îl folosește cu import.
main: Funcția cu care începe orice program C++: sistemul o apelează la pornire, iar valoarea returnată spune dacă programul a reușit.

Ce face #include