Inkludera direktiv

Många programmeringsspråk och andra datorfiler har ett direktiv , ofta kallat include (ibland kopiera eller importera ), som gör att innehållet i den angivna filen infogas i originalfilen. Dessa inkluderade filer kallas copybooks eller header- filer . De används ofta för att definiera den fysiska layouten av programdata, bitar av procedurkod och/eller vidarebefordran av deklarationer samtidigt som de främjar inkapsling och återanvändning av kod eller data.

Header-filer

Inom datorprogrammering är en rubrikfil en fil som låter programmerare separera vissa delar av ett programs källkod till återanvändbara filer. Rubrikfiler innehåller vanligtvis vidaredeklarationer av klasser , subrutiner , variabler och andra identifierare . Programmerare som vill deklarera standardiserade identifierare i mer än en källfil kan placera sådana identifierare i en enda rubrikfil, som annan kod sedan kan inkludera närhelst huvudinnehållet krävs. Detta för att hålla gränssnittet i headern åtskilt från implementeringen .

C -standardbiblioteket och C++-standardbiblioteket deklarerar traditionellt sina standardfunktioner i rubrikfiler.

Vissa nyligen skapade kompilerade språk (som Java , C# ) använder inte framåtriktade deklarationer; identifierare känns igen automatiskt från källfiler och läses direkt från dynamiska bibliotekssymboler . Det betyder att huvudfiler inte behövs.

Syfte

Inkluderingsdirektivet tillåter att kodbibliotek utvecklas som hjälper till att :

  • se till att alla använder samma version av en datalayoutdefinition eller procedurkod genom hela programmet,
  • enkelt korsreferens där komponenter används i ett system,
  • enkelt ändra program när det behövs (endast en fil måste redigeras), och
  • spara tid genom att återanvända datalayouter.

Exempel

Ett exempel på situation som drar nytta av användningen av ett include-direktiv är när man hänvisar till funktioner i en annan fil. Anta att det finns någon C- källfil som innehåller en funktion add , som refereras till i en andra fil genom att först deklarera dess externa existens och typ (med en funktionsprototyp ) enligt följande: 

  

  

       
 int  add  (  int  ,  int  );  int  triple  (  int  x  )  {  return  add  (  x  ,  add  (  x  ,  x  ));  }

En nackdel med detta tillvägagångssätt är att funktionsprototypen måste finnas i alla filer som använder funktionen. En annan nackdel är att om returtypen eller argumenten för funktionen ändras, skulle alla dessa prototyper behöva uppdateras. Genom att lägga prototypen i en enda separat fil undviker du dessa problem. Förutsatt att prototypen flyttas till filen add.h , kan den andra källfilen bli: 

 

  

      
 #include  "add.h"  int  triple  (  int  x  )  {  return  add  (  x  ,  add  (  x  ,  x  ));  }

Nu, varje gång koden kompileras, kommer de senaste funktionsprototyperna i add.h att inkluderas i filerna som använder dem, vilket undviker potentiella fel.

Språkstöd

C/C++

I programmeringsspråken C och C++ får #include preprocessor-direktivet att kompilatorn ersätter den raden med hela texten i innehållet i den namngivna källfilen (om den ingår inom citattecken: "") eller namngiven rubrik (om den ingår i vinkelparenteser) : <>); Observera att en rubrik inte behöver vara en källfil. Inkluderingen fortsätter rekursivt på detta inkluderade innehåll, upp till en implementeringsdefinierad kapslingsgräns. Rubriker behöver inte ha namn som motsvarar filer: i C++ identifieras standardhuvuden vanligtvis med ord, som "vektor", därav #inkludera <vector> , medan standardhuvuden i C har identifierare i form av filnamn med tillägget ".h" , som i #include <stdio.h> . En "källfil" kan vara vilken fil som helst, med ett namn av vilken form som helst, men kallas oftast med filtillägget ".h" och kallas för en "huvudfil" (ibland ".hpp" eller ".hh" för att särskilja C++ headers), även om filer med tilläggen .c, .cc och .cpp också kan inkluderas (särskilt i tekniken med en enda kompileringsenhet) , och ibland används andra tillägg.

Dessa två former av #include- direktiv kan bestämma vilken rubrik eller källfil som ska inkluderas på ett implementeringsdefinierat sätt. I praktiken är det som vanligtvis görs att vinkelparenteserna söker efter källfiler i en standardsystemkatalog (eller uppsättning kataloger) och sedan söker efter källfiler i lokala eller projektspecifika sökvägar (anges på kommandoraden, i en miljövariabel, eller i en Makefile eller annan byggfil), medan formuläret med citattecken inte söker i en standardsystemkatalog, utan endast i lokala eller projektspecifika sökvägar. Om det inte finns någon kollision kan formuläret med vinkelparenteser också användas för att specificera projektspecifika inslag, men detta anses vara dåligt format. Det faktum att rubriker inte behöver motsvara filer är i första hand en implementeringsteknik, och används för att utelämna tillägget .h i att inkludera C++ standardhuvuden; i vanligt bruk betyder "header" "huvudfil".

Till exempel:

 
 
  #include  <stdio.h>  // Inkludera innehållet i standardhuvudet 'stdio.h' (förmodligen en fil 'stdio.h').  #include  <vector>  // Inkludera innehållet i standardhuvudet 'vector' (troligen en fil 'vector.h').  #inkludera  "user_defined.h"  // Inkludera innehållet i filen 'user_defined.h'.

I C och C++ kan problem uppstå om två (eller flera) inkluderar filer innehåller samma tredje fil. En lösning är att undvika att inkludera filer från att inkludera andra filer, vilket möjligen kräver att programmeraren manuellt lägger till extra inkluderingsdirektiv till originalfilen. En annan lösning är att använda inkluderande skydd .

COBOL

COBOL (och även RPG IV ) tillåter programmerare att kopiera copybooks till programmets källa på ett liknande sätt som header-filer, men det tillåter också att viss text i dem ersätts med annan text. COBOL-nyckelordet för inkludering är COPY , och ersättningen görs med hjälp av REPLACING ... BY ...- satsen. Ett inkluderingsdirektiv har funnits i COBOL sedan COBOL 60, men ändrades från originalet INCLUDE till COPY 1968.

Fortran

Fortran kräver inte header-filer i sig . Fortran 90 och senare har dock två relaterade funktioner: inkluderar uttalanden och moduler. Den förra kan användas för att dela en gemensam fil som innehåller procedurgränssnitt, ungefär som en C-header, även om specifikationen av ett gränssnitt inte krävs för alla varianter av Fortran-procedurer. Detta tillvägagångssätt är inte vanligt förekommande; istället är procedurer i allmänhet grupperade i moduler som sedan kan refereras med en användningssats inom andra kodområden. För moduler genereras gränssnittsinformation av header-typ automatiskt av kompilatorn och placeras vanligtvis i separata modulfiler, även om vissa kompilatorer har placerat denna information direkt i objektfiler. Språkspecifikationen i sig kräver inte att några extra filer skapas, även om modulprocedurgränssnitt nästan sprids överallt på detta sätt.

Pascal

De flesta Pascal- kompilatorer stöder kompilatordirektivet $i eller $include , där direktivet $i eller $include omedelbart följer början av ett kommentarblock i form av

  • {$i filnamn.pas }
  • (*$I filnamn.inc *)
  • {$inkludera filnamn.inc }
  • (*INKLUDERA filnamn.pas *)

Där $i- eller $include -direktivet inte är skiftlägeskänsligt och filnamn.pas eller filnamn.inc är namnet på filen som ska inkluderas. (Det har varit vanligt att namnge Pascals include-filer med filtillägget .inc , men detta krävs inte.) Vissa kompilatorer, för att förhindra crock-rekursion , begränsar anropandet av en include-fil till ett visst antal, förbjuder att anropa sig själv eller någon fil som för närvarande är öppen , eller är begränsade till högst en include-fil åt gången, t.ex. en include-fil kan inte inkludera sig själv eller en annan fil. Men programmet som innehåller andra filer kan innehålla flera, bara en åt gången.

PHP

I PHP gör include - direktivet att ytterligare en PHP-fil inkluderas och utvärderas. Liknande kommandon är require , som vid misslyckande med att inkludera kommer att producera ett ödesdigert undantag och stoppa skriptet, och include_once och require_once , som förhindrar att en fil inkluderas eller krävs igen om den redan har inkluderats eller krävs, vilket undviker C:s problem med dubbla inkludering .

Andra språk

Det finns många former av inkluderingsdirektivet, till exempel:

Moderna språk (t.ex. Haskell och Java ) tenderar att undvika copybooks eller inkluderar, och föredrar moduler och import/exportsystem för namnutrymmeskontroll . Vissa av dessa språk (som Java och C# ) använder inte framåtriktade deklarationer och istället identifieras identifierare automatiskt från källfiler och läses direkt från dynamiska bibliotekssymboler (vanligtvis refererade till med import eller användning av direktiv), vilket innebär att rubrikfiler inte behövs .

Se även

externa länkar

Hämtad från " https://en.wikipedia.org/w/index.php?title=Include_directive&oldid=1140375718 "