Declaraties en definities (C++)

Een C++-programma bestaat uit verschillende entiteiten, zoals variabelen, functies, typen en naamruimten. Elk van deze entiteiten moet worden gedeclareerd voordat ze kunnen worden gebruikt. Een declaratie geeft een unieke naam op voor de entiteit, samen met informatie over het type en andere kenmerken. In C++ is het punt waarop een naam wordt gedeclareerd het punt waarop deze zichtbaar wordt voor de compiler. U kunt niet verwijzen naar een functie of klasse die op een later moment in de compilatie-eenheid wordt gedeclareerd. Variabelen moeten zo dicht mogelijk worden gedeclareerd voordat ze worden gebruikt.

In het volgende voorbeeld ziet u enkele declaraties:

#include <string>

int f(int i); // forward declaration

int main()
{
    const double pi = 3.14; //OK
    int i = f(2); //OK. f is forward-declared
    C obj; // error! C not yet declared.
    std::string str; // OK std::string is declared in <string> header
    j = 0; // error! No type specified.
    auto k = 0; // OK. type inferred as int by compiler.
}

int f(int i)
{
    return i + 42;
}

namespace N {
   class C{/*...*/};
}

Op regel 5 wordt de main functie gedeclareerd. Op regel 7 wordt een const variabele met de naam pi gedeclareerd en geïnitialiseerd. Op regel 8 wordt een geheel getal i gedeclareerd en geïnitialiseerd met de waarde die door de functie fwordt geproduceerd. De naam f is zichtbaar voor de compiler vanwege de doorstuurdeclaratie op regel 3.

In regel 9 wordt een variabele met de naam obj van het type C gedeclareerd. Deze declaratie genereert echter een fout omdat C deze pas later in het programma wordt gedeclareerd en niet doorsturend is gedeclareerd. Als u de fout wilt oplossen, kunt u de hele definitie van C voordat main verplaatsen of een doorstuurdeclaratie ervoor toevoegen. Dit gedrag verschilt van andere talen, zoals C#. In deze talen kunnen functies en klassen worden gebruikt voordat hun declaratiepunt in een bronbestand wordt gebruikt.

In regel 10 wordt een variabele met de naam str van het type std::string gedeclareerd. De naam std::string is zichtbaar omdat deze wordt geïntroduceerd in het stringheaderbestand, dat wordt samengevoegd in het bronbestand in regel 1. std is de naamruimte waarin de string klasse wordt gedeclareerd.

In regel 11 wordt een fout gegenereerd omdat de naam j niet is gedeclareerd. Een declaratie moet een type opgeven, in tegenstelling tot andere talen, zoals JavaScript. In regel 12 wordt het auto trefwoord gebruikt, waarmee de compiler het type moet afleiden op basis van k de waarde waarmee het is geïnitialiseerd. De compiler in dit geval kiest int voor het type.

Bereik van declaratie

De naam die door een declaratie wordt ingevoerd, is geldig binnen het bereik waar de declaratie plaatsvindt. In het vorige voorbeeld zijn de variabelen die in de main functie zijn gedeclareerd lokale variabelen. U kunt een andere variabele declareren die i buiten het hoofdbereik valt, en het zou een afzonderlijke entiteit zijn. Dergelijke duplicatie van namen kan echter leiden tot verwarring en fouten van programmeurs en moet worden vermeden. In regel 21 wordt de klasse C gedeclareerd in het bereik van de naamruimte N. Het gebruik van naamruimten helpt bij het voorkomen van naamconflicten. De meeste C++-standaardbibliotheeknamen worden gedeclareerd binnen de std naamruimte. Zie Bereik voor meer informatie over de interactie tussen bereikregels en declaraties.

Definities

Sommige entiteiten, waaronder functies, klassen, enums en constante variabelen, moeten worden gedefinieerd en gedeclareerd. Een definitie biedt de compiler alle informatie die nodig is om machinecode te genereren wanneer de entiteit later in het programma wordt gebruikt. In het vorige voorbeeld bevat regel 3 een declaratie voor de functie f , maar de definitie voor de functie wordt opgegeven in regels 15 tot en met 18. Op regel 21 wordt de klasse C zowel gedeclareerd als gedefinieerd (hoewel zoals gedefinieerd de klasse niets doet). Er moet een constante variabele worden gedefinieerd, met andere woorden een waarde toegewezen, in dezelfde instructie waarin deze wordt gedeclareerd. Een declaratie van een ingebouwd type, zoals int automatisch een definitie, omdat de compiler weet hoeveel ruimte er moet worden toegewezen.

In het volgende voorbeeld ziet u declaraties die ook definities zijn:

// Declare and define int variables i and j.
int i;
int j = 10;

// Declare enumeration suits.
enum suits { Spades = 1, Clubs, Hearts, Diamonds };

// Declare class CheckBox.
class CheckBox : public Control
{
public:
    Boolean IsChecked();
    virtual int     ChangeState() = 0;
};

Hier volgen enkele declaraties die geen definities zijn:

extern int i;
char *strchr( const char *Str, const char Target );

Typedefs en instructies gebruiken

In oudere versies van C++wordt het typedef trefwoord gebruikt om een nieuwe naam te declareren die een alias is voor een andere naam. Het type std::string is bijvoorbeeld een andere naam voor std::basic_string<char>. Het moet duidelijk zijn waarom programmeurs de typedef-naam en niet de werkelijke naam gebruiken. In moderne C++heeft het trefwoord de using voorkeur, typedefmaar het idee is hetzelfde: een nieuwe naam wordt gedeclareerd voor een entiteit, die al is gedeclareerd en gedefinieerd.

Leden van statische klasse

Statische klassegegevensleden zijn discrete variabelen die worden gedeeld door alle objecten van de klasse. Omdat ze worden gedeeld, moeten ze worden gedefinieerd en geïnitialiseerd buiten de klassedefinitie. Zie Klassen voor meer informatie.

externe declaraties

Een C++-programma kan meer dan één compilatie-eenheid bevatten. Als u een entiteit wilt declareren die is gedefinieerd in een afzonderlijke compilatie-eenheid, gebruikt u het extern trefwoord. De informatie in de declaratie is voldoende voor de compiler. Als de definitie van de entiteit echter niet in de koppelingsstap kan worden gevonden, treedt er een fout op met de linker.

In deze sectie

Opslagklassen
const
constexpr
extern
Initializers
Aliassen en typedefs
using verklaring
volatile
decltype
Kenmerken in C++

Zie ook

Basisconcepten