extern trefwoord in C is van toepassing op C-variabelen (data-objecten) en C-functies. Kortom, het externe trefwoord breidt de zichtbaarheid van de C-variabelen en C-functies uit. Dat is waarschijnlijk de reden waarom het extern werd genoemd.
Hoewel de meeste mensen waarschijnlijk het verschil begrijpen tussen de declaratie en de definitie van een variabele of functie, laten we het voor de volledigheid even verduidelijken
- Bij het declareren van een variabele of functie wordt eenvoudigweg aangegeven dat de variabele of functie ergens in het programma bestaat, maar dat er geen geheugen voor is toegewezen. De declaratie van een variabele of functie speelt een belangrijke rol: het vertelt het programma wat het type ervan zal zijn. In het geval van functie declaraties, vertelt het het programma ook de argumenten, hun gegevenstypen, de volgorde van die argumenten en het retourtype van de functie. Het gaat dus allemaal om de aangifte.
- Komt naar de definitie , wanneer we definiëren een variabele of functie, naast alles wat een declaratie doet, wijst het ook geheugen toe voor die variabele of functie. Daarom kunnen we de definitie beschouwen als een superset van de declaratie (of declaratie als een subset van de definitie).
- Extern is een korte naam voor extern.
- De externe variabele wordt gebruikt wanneer een bepaald bestand toegang nodig heeft tot een variabele uit een ander bestand.
Syntaxis van extern in C
De syntaxis voor het definiëren van een externe variabele in C is het gebruik van het externe sleutelwoord vóór de variabeledeclaratie.
extern data_type variable_name;>
Voorbeeld van externe variabele in C
C
hoeveel weken in een maand
#include> > extern> int> a;>// int var; ->declaratie en definitie> >// extern int var; ->aangifte> > int> main()> {> >printf>(>'%d'>, a);> > >return> 0;> }> |
>
>
Eigenschappen van externe variabele in C
- Wanneer we extern some_data_type some_variable_name schrijven; er is geen geheugen toegewezen. Alleen de eigenschap van de variabele wordt aangekondigd.
- Binnen het bestand zijn meerdere declaraties van externe variabelen toegestaan. Bij automatische variabelen is dit niet het geval.
- De externe variabele zegt tegen de compiler: Ga buiten mijn bereik en je zult de definitie vinden van de variabele die ik heb gedeclareerd.
- De compiler gelooft dat wat die externe variabele ook zegt waar is en geen fout oplevert. Linker genereert een fout wanneer wordt vastgesteld dat een dergelijke variabele niet bestaat.
- Wanneer een externe variabele wordt geïnitialiseerd, wordt hiervoor geheugen toegewezen en wordt deze als gedefinieerd beschouwd.
Een variabele of functie kan zijn verklaard een aantal keren, maar het kan wel bepaald slechts één keer. (Denk aan het basisprincipe dat er geen twee locaties van dezelfde variabele of functie kunnen zijn).
Nu terug naar het externe trefwoord. Laten we eerst eens kijken naar het gebruik van extern in-functies. Het blijkt dat wanneer een functie wordt gedeclareerd of gedefinieerd, het externe sleutelwoord impliciet wordt aangenomen. Als we schrijven.
int foo(int arg1, char arg2);>
De compiler behandelt het als:
extern int foo(int arg1, char arg2);>
Omdat het trefwoord extern de zichtbaarheid van de functie uitbreidt naar het hele programma, kan de functie overal in elk bestand van het hele programma worden gebruikt (aangeroepen), op voorwaarde dat die bestanden een declaratie van de functie bevatten. (Nu de declaratie van de functie aanwezig is, weet de compiler dat de definitie van de functie ergens anders bestaat en gaat hij verder en compileert het bestand). Dus dat gaat allemaal over extern en functies.
Laten we nu eens kijken naar het gebruik van extern met variabelen. Om te beginnen: hoe zou jij dat doen? verklaren een variabele zonder definiëren Het? Je zou zoiets als dit doen:
extern int var;>
Hier is een variabele van het integer-type genaamd var gedeclareerd (deze is nog niet gedefinieerd, dus tot nu toe is er geen geheugentoewijzing voor var). En we kunnen deze verklaring zo vaak doen als we willen.
Hoe zou je het nu doen? definiëren var? Je zou dit doen:
int var = 10;>
In deze regel is zowel een variabele van het type geheel getal met de naam var gedeclareerd En gedefinieerd (onthoud dat definitie is de superset van verklaring ). Aangezien dit een definitie , wordt ook het geheugen voor var toegewezen. Nu komt hier de verrassing. Toen we een functie declareerden/definieerden, zagen we dat het externe trefwoord impliciet aanwezig was. Maar bij variabelen is dit niet het geval. Als dat zo was, zou er nooit geheugen voor worden toegewezen. Daarom moeten we het externe trefwoord expliciet opnemen als we variabelen willen declareren zonder ze te definiëren. Omdat het trefwoord extern de zichtbaarheid uitbreidt naar het hele programma, kunnen we, door het trefwoord extern te gebruiken met een variabele, de variabele overal in het programma gebruiken, op voorwaarde dat we de verklaring opnemen dat de variabele ergens is gedefinieerd.
Laten we nu proberen extern te begrijpen met voorbeelden.
Voorbeeld 1:
C
int> var;> int> main(>void>)> {> >var = 10;> >return> 0;> }> |
>
>
Dit programma is succesvol gecompileerd. var wordt globaal gedefinieerd (en impliciet gedeclareerd).
Voorbeeld 2:
C
extern> int> var;> int> main(>void>)> {> >return> 0;> }> |
>
>
Dit programma is succesvol gecompileerd. Hier wordt alleen var gedeclareerd. Merk op dat var nooit wordt gebruikt, dus er ontstaan geen problemen.
Voorbeeld 3:
C
extern> int> var;> int> main(>void>)> {> >var = 10;> >return> 0;> }> |
>
>
Dit programma genereert een fout in de compilatie (tijdens de koppelingsfase, meer info hier) omdat var wel wordt gedeclareerd maar nergens gedefinieerd. In wezen krijgt de var geen geheugen toegewezen. En het programma probeert de waarde te veranderen in 10 van een variabele die helemaal niet bestaat.
Voorbeeld 4:
C
// As we are importing the file and henceforth the> // defination> #include 'somefile.h'> > // Declaring the same variable> extern> int> var;> >// int var;> >// It will throw compiler error as compiler will get> >// confused where the variable is defined> > int> main(>void>)> {> >var = 10;> >return> 0;> }> > // Now it will compile and run successfully> |
>
>
Uitgang:
10>
Opmerking: Hier ontstaat een ander scenario, wat als we niet declareren met extern in het bovenstaande codefragment?
Als we ervan uitgaan dat somefile.h de definitie van var bevat, zal dit programma met succes worden gecompileerd. Het trefwoord ‘extern’ wordt gebruikt voor een variabele wanneer we de variabele in het ene bestand declareren en deze in een ander bestand definiëren. Maar als we hier hetzelfde bestand importeren in het bestand waarin het is gedeclareerd, wordt hier een compilerfout gegenereerd.
Het is omdat we nog steeds het externe trefwoord moeten gebruiken in het bestand waarin we die variabele hebben gedeclareerd om onze compiler te vertellen dat deze variabele ergens anders is gedefinieerd dan dat er alleen geen nieuwe geheugenruimte wordt toegewezen, anders wordt er een nieuw geheugenblok gemaakt welk gebruik van het trefwoord 'extern' nutteloos is.
website zoals coomeet
Voorbeeld 5:
C
extern> int> var = 0;> int> main(>void>)> {> >var = 10;> >return> 0;> }> |
>
>
Denk jij dat dit programma gaat werken? Welnu, hier komt nog een verrassing van C-standaarden. Ze zeggen dat... als een variabele alleen wordt gedeclareerd en er ook een initializer bij die declaratie wordt geleverd, het geheugen voor die variabele zal worden toegewezen - met andere woorden, die variabele zal als gedefinieerd worden beschouwd. Daarom zal dit programma, volgens de C-standaard, succesvol compileren en werken.
Dus dat was een eerste blik op het externe trefwoord in C.
Kort gezegd kunnen we zeggen:
- Een aangifte kan een onbeperkt aantal keren worden gedaan, maar slechts één keer worden gedefinieerd.
- het externe sleutelwoord wordt gebruikt om de zichtbaarheid van variabelen/functies uit te breiden.
- Omdat functies standaard in het hele programma zichtbaar zijn, is het gebruik van extern niet nodig in functiedeclaraties of definities. Het gebruik ervan is impliciet.
- Wanneer extern wordt gebruikt met een variabele, wordt deze alleen gedeclareerd en niet gedefinieerd.
- Wanneer een externe variabele bij initialisatie wordt gedeclareerd, wordt deze bij wijze van uitzondering ook als de definitie van de variabele genomen.