extern nyckelord i C gäller C-variabler (dataobjekt) och C-funktioner. I grund och botten utökar nyckelordet extern synligheten för C-variablerna och C-funktionerna. Det är förmodligen anledningen till att den fick namnet extern.
Även om de flesta förmodligen förstår skillnaden mellan deklarationen och definitionen av en variabel eller funktion, låt oss för fullständighetens skull klargöra det
- Deklaration av en variabel eller funktion deklarerar helt enkelt att variabeln eller funktionen finns någonstans i programmet, men minnet är inte allokerat för dem. Deklarationen av en variabel eller funktion fyller en viktig roll - den talar om för programmet vad dess typ kommer att vara. I fallet med fungera deklarationer, talar den också om för programmet argumenten, deras datatyper, ordningen på dessa argument och returtypen för funktionen. Så det handlar om deklarationen.
- Kommer till definition , när vi definiera en variabel eller funktion, förutom allt som en deklaration gör, allokerar den också minne för den variabeln eller funktionen. Därför kan vi tänka på definitionen som en supermängd av deklarationen (eller deklarationen som en delmängd av definitionen).
- Extern är ett kort namn på extern.
- Den externa variabeln används när en viss fil behöver komma åt en variabel från en annan fil.
Syntax för extern i C
Syntaxen för att definiera en extern variabel i C är bara att använda nyckelordet extern före variabeldeklarationen.
extern data_type variable_name;>
Exempel på extern variabel i C
C
#include> > extern> int> a;>// int var; ->deklaration och definition> >// extern int var; ->deklaration> > int> main()> {> >printf>(>'%d'>, a);> > >return> 0;> }> |
>
>
Egenskaper för extern variabel i C
- När vi skriver extern some_data_type some_variable_name; inget minne är tilldelat. Endast egenskapen hos variabeln meddelas.
- Flera deklarationer av extern variabel är tillåtna i filen. Så är inte fallet med automatiska variabler.
- Den externa variabeln säger till kompilatorn Gå utanför mitt räckvidd så hittar du definitionen av variabeln som jag deklarerade.
- Kompilatorn tror att allt som den externa variabeln säger är sant och ger inget fel. Linker kastar ett fel när det inte finns någon sådan variabel.
- När en extern variabel initieras, tilldelas minne för denna och den kommer att anses definierad.
En variabel eller funktion kan vara deklarerade hur många gånger som helst, men det kan vara det definierad bara en gång. (Kom ihåg den grundläggande principen att du inte kan ha två platser med samma variabel eller funktion).
Nu tillbaka till det externa nyckelordet. Låt oss först överväga användningen av extern i funktioner. Det visar sig att när en funktion deklareras eller definieras, antas det externa nyckelordet implicit. När vi skriver.
int foo(int arg1, char arg2);>
Kompilatorn behandlar det som:
extern int foo(int arg1, char arg2);>
Eftersom det externa nyckelordet utökar funktionens synlighet till hela programmet, kan funktionen användas (anropas) var som helst i vilken som helst av filerna i hela programmet, förutsatt att dessa filer innehåller en deklaration av funktionen. (Med deklarationen av funktionen på plats vet kompilatorn att definitionen av funktionen finns någon annanstans och den går vidare och kompilerar filen). Så det handlar om extern och funktioner.
Låt oss nu överväga användningen av extern med variabler. Till att börja med, hur skulle du deklarera en variabel utan definierande Det? Du skulle göra något så här:
extern int var;>
Här har en heltalsvariabel kallad var deklarerats (den har inte definierats än, så ingen minnesallokering för var än så länge). Och vi kan göra denna förklaring så många gånger vi vill.
Hur skulle du nu definiera var? Du skulle göra så här:
int var = 10;>
På den här raden har båda en heltalsvariabel som heter var deklarerats och definierad (kom ihåg att definition är superuppsättningen av deklaration ). Eftersom detta är en definition , minnet för var tilldelas också. Nu kommer överraskningen. När vi deklarerade/definierade en funktion såg vi att det externa nyckelordet var närvarande implicit. Men detta är inte fallet med variabler. Om det var det, skulle minnet aldrig tilldelas dem. Därför måste vi inkludera det externa nyckelordet explicit när vi vill deklarera variabler utan att definiera dem. Dessutom, eftersom det externa nyckelordet utökar synligheten till hela programmet, genom att använda det externa nyckelordet med en variabel, kan vi använda variabeln var som helst i programmet förutsatt att vi inkluderar dess deklaration att variabeln är definierad någonstans.
Låt oss nu försöka förstå extern med exempel.
Exempel 1:
c
int> var;> int> main(>void>)> {> >var = 10;> >return> 0;> }> |
>
>
java tostring
Det här programmet kompileras framgångsrikt. var definieras (och deklareras implicit) globalt.
Exempel 2:
c
extern> int> var;> int> main(>void>)> {> >return> 0;> }> |
>
>
Det här programmet kompileras framgångsrikt. Här deklareras endast var. Observera att var aldrig används så inga problem uppstår.
Exempel 3:
c
extern> int> var;> int> main(>void>)> {> >var = 10;> >return> 0;> }> |
>
>
Detta program ger ett fel i kompileringen (under länkningsfasen, mer info här) eftersom var deklareras men inte definieras någonstans. I huvudsak tilldelas var inte något minne. Och programmet försöker ändra värdet till 10 för en variabel som inte existerar alls.
Exempel 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> |
>
>
Produktion:
10>
Notera: Här uppstår ett annat scenario vad händer om vi inte deklarerar med extern i ovanstående kodavsnitt,?
Med tanke på ett antagande att somefile.h innehåller definitionen av var, kommer detta program att kompilera framgångsrikt. 'extern' nyckelord används för en variabel när vi deklarerar variabeln i en fil och definierar den i en annan fil. Men här när vi importerar samma fil i filen där den deklareras, kommer här ett kompilatorfel att genereras.
Det beror på att vi fortfarande måste använda nyckelordet extern i filen där vi har deklarerat den variabeln för att tala om för vår kompilator att denna variabel har definierats någon annanstans än att bara nytt minnesutrymme inte kommer att tilldelas, annars kommer det att skapa ett annat minnesblock vilken användning av 'extern' nyckelord är värdelös.
aryan khan
Exempel 5:
c
extern> int> var = 0;> int> main(>void>)> {> >var = 10;> >return> 0;> }> |
>
>
Tror du att det här programmet kommer att fungera? Nåväl, här kommer en annan överraskning från C standards. De säger att...om en variabel bara deklareras och en initialiserare också tillhandahålls med den deklarationen, så kommer minnet för den variabeln att allokeras – med andra ord, den variabeln kommer att betraktas som definierad. Därför, enligt C-standarden, kommer detta program att kompilera framgångsrikt och fungera.
Så det var en preliminär titt på det externa nyckelordet i C.
Kortfattat kan vi säga:
- En deklaration kan göras hur många gånger som helst men bara definieras en gång.
- nyckelordet extern används för att utöka synligheten för variabler/funktioner.
- Eftersom funktioner är synliga i hela programmet som standard, behövs inte användningen av den externa i funktionsdeklarationer eller definitioner. Dess användning är implicit.
- När extern används med en variabel deklareras den bara, inte definierad.
- Som ett undantag, när en extern variabel deklareras med initialisering, tas den också som definition av variabeln.