makepp_tutorial_compilation - Online in de cloud

PROGRAMMA:

NAAM

makepp_tutorial_compilation -- Unix-compilatieopdrachten

PRODUCTBESCHRIJVING

Sla deze handleidingpagina over als u goed begrijpt wat de compilatiecommando's doen.

Ik vind dat schrijnend weinig mensen tijdens hun programmeerlessen geleerd hebben hoe
om programma's te gaan compileren nadat ze deze hebben geschreven. Beginners vertrouwen op één
opgeslagen commando, of anders volgens de ingebouwde regels in make. Ik ben er door verrast
extreem computervaardige mensen die leerden compileren zonder optimalisatie omdat
er is hen eenvoudigweg nooit verteld hoe belangrijk het is. Rudimentaire kennis van hoe compilatie
Als commando's werken, kunnen uw programma's twee keer zo snel of sneller worden uitgevoerd, dus het is op zijn minst de moeite waard
vijf minuten. Op deze pagina wordt zo ongeveer alles beschreven wat u moet weten om C te compileren
of C++-programma's op vrijwel elke variant van Unix.

De voorbeelden zullen voornamelijk voor C zijn, aangezien de C++-compilatie identiek is, behalve de naam
van de compiler is anders. Stel dat u de broncode compileert in een bestand met de naam
"xyz.c" en u wilt een programma bouwen met de naam "xyz". Wat moet er gebeuren?

U weet wellicht dat u uw programma in één stap kunt bouwen met behulp van een opdracht als deze:

cc -g xyz.c -o xyz

Dit zal werken, maar er gaat een proces in twee stappen schuil dat je moet begrijpen als dat zo is
makefiles schrijven. (Eigenlijk zijn er meer dan twee stappen, maar dat hoeft alleen maar
begrijp er twee.) Voor een programma van meer dan één module zijn dit meestal twee stappen
expliciet gescheiden.

Compilatie
De eerste stap is de vertaling van uw C- of C++-broncode naar een binair bestand genaamd
een objectbestand. Objectbestanden hebben meestal de extensie ".o". (Voor wat recentere
projecten, wordt ".lo" ook gebruikt voor een iets ander soort objectbestand.)

Het commando om een ​​objectbestand op Unix te maken ziet er ongeveer zo uit:

cc -g -c xyz.c -o xyz.o

"cc" is de C-compiler. Soms worden alternatieve C-compilers gebruikt; een veel voorkomende is
genaamd "gcc". Een gebruikelijke C++-compiler is de GNU-compiler, gewoonlijk "g++" genoemd. Vrijwel
alle C- en C++-compilers op Unix hebben dezelfde syntaxis voor de rest van de opdracht (tenminste
voor basisbewerkingen), dus het enige verschil zou het eerste woord zijn.

We zullen later uitleggen wat de optie "-g" doet.

De optie "-c" vertelt de C-compiler om een ​​".o"-bestand als uitvoer te produceren. (Als je dat niet doet
specificeer "-c", waarna de tweede compilatiestap automatisch wordt uitgevoerd.)

De optie "-o xyz.o" vertelt de compiler wat de naam van het objectbestand is. Jij kan
laat dit weg, zolang de naam van het objectbestand dezelfde is als de naam van de bron
bestand, behalve de extensie ".o".

Voor het grootste deel doet de volgorde van de opties en de bestandsnamen er niet toe. Een
Een belangrijke uitzondering is dat het uitvoerbestand onmiddellijk moet volgen op "-o".

Koppelen
De tweede stap van het bouwen van een programma heet Koppeling. Een objectbestand kan niet worden uitgevoerd
direct; het is een tussenvorm, dat moet het zijn gekoppeld naar andere componenten om dat te doen
een programma maken. Andere componenten kunnen zijn:

· Bibliotheken. A bibliotheek, grofweg gesproken, is een verzameling objectmodules die dat wel zijn
opgenomen indien nodig. Als uw programma bijvoorbeeld de functie "printf" aanroept, dan
de definitie van de functie "printf" moet worden opgenomen in de systeem C-bibliotheek.
Sommige bibliotheken worden automatisch aan uw programma gekoppeld (bijvoorbeeld degene die
"printf"), zodat u zich daar nooit zorgen over hoeft te maken.

· Objectbestanden afgeleid van andere bronbestanden in uw programma. Als u uw schrijft
programma zodat het feitelijk meerdere bronbestanden heeft; normaal gesproken zou u ze allemaal compileren
bronbestand naar een afzonderlijk objectbestand en koppel ze vervolgens allemaal aan elkaar.

De Links is het programma dat verantwoordelijk is voor het verzamelen van objectbestanden en
bibliotheken en koppelt ze aan elkaar om een ​​uitvoerbaar bestand te produceren. Het uitvoerbare bestand is
het programma dat u daadwerkelijk uitvoert.

Het commando om het programma te koppelen ziet er ongeveer zo uit:

cc -g xyz.o -o xyz

Het lijkt misschien vreemd, maar we gebruiken meestal hetzelfde programma ("cc") om de koppeling uit te voeren. Wat
wat er onder de oppervlakte gebeurt, is dat het "cc"-programma onmiddellijk de controle overdraagt ​​aan a
ander programma (de linker, ook wel de loader of "ld" genoemd) na het toevoegen van een nummer
van complexe stukjes informatie naar de opdrachtregel. "cc" vertelt bijvoorbeeld "ld" waar
de systeembibliotheek bevat de definitie van functies zoals "printf". Tot jij
Als u begint met het schrijven van gedeelde bibliotheken, hoeft u meestal niet rechtstreeks met "ld" om te gaan.

Als u "-o xyz" niet opgeeft, wordt het uitvoerbestand "a.out" genoemd, zo lijkt het
voor mij een volkomen nutteloze en verwarrende conventie. Specificeer dus altijd "-o" op het
stap koppelen.

Als uw programma meer dan één objectbestand heeft, moet u alle objectbestanden opgeven
het linkcommando.

Waarom u genoodzaakt bent naar apart de stappen
Waarom gebruikt u niet gewoon de eenvoudige opdracht in één stap, zoals deze:

cc -g xyz.c -o xyz

in plaats van de meer gecompliceerde compilatie in twee fasen

cc -g -c xyz.c -o xyz.o
cc -g xyz.o -o xyz

als intern de eerste wordt omgezet in de tweede? Het verschil is alleen belangrijk als
er zijn meer dan één module in uw programma. Stel dat we een extra module hebben,
"abc.c". Onze compilatie ziet er nu als volgt uit:

# Eéntrapsopdracht.
cc -g xyz.c abc.c -o xyz

or

# Tweetrapscommando.
cc -g -c xyz.c -o xyz.o
cc -g -c abc.c -o abc.o
cc -g xyz.o abc.o -o xyz

De eerste methode wordt uiteraard intern omgezet in de tweede methode. Dit betekent
dat zowel "xyz.c" als "abc.c" elke keer dat de opdracht wordt uitgevoerd opnieuw worden gecompileerd. Maar als jij
alleen "xyz.c" gewijzigd, het is niet nodig om "abc.c" opnieuw te compileren, dus de tweede regel van de twee-
podiumopdrachten hoeven niet te worden uitgevoerd. Dit kan een enorm verschil maken bij het compileren
tijd, vooral als je veel modules hebt. Om deze reden blijven vrijwel alle makefiles behouden
de twee compilatiestappen zijn gescheiden.

Dat is zo ongeveer de basis, maar er zijn nog een paar kleine details die je echt zou moeten doen
weten over.

Debugging vs optimalisatie
Normaal gesproken compileren programmeurs een programma voor debuggen of voor snelheid. Compilatie
voor snelheid wordt opgeroepen optimalisatie; compileren met optimalisatie kan ervoor zorgen dat uw code oploopt
5 keer sneller of meer, afhankelijk van uw code, uw processor en uw compiler.

Waarom zou u, als er zulke dramatische winsten mogelijk zijn, nooit willen optimaliseren? Het meest
Het belangrijkste antwoord is dat optimalisatie het gebruik van een debugger veel moeilijker maakt
(soms onmogelijk). (Als je niets weet over een debugger, is het tijd om het te leren.
Het halfuur of uur dat u besteedt aan het leren van de basisbeginselen, wordt vele malen terugbetaald
in de tijd die u later bespaart bij het debuggen. Ik raad aan om te beginnen met een GUI-debugger
zoals "kdbg", "ddd" of "gdb" uitgevoerd vanuit emacs (zie de infopagina's op gdb voor
instructies over hoe u dit kunt doen).) Optimalisatie herschikt en combineert instructies, verwijdert
onnodige tijdelijke variabelen, en herschikt uw code over het algemeen zodat deze zeer
moeilijk te volgen in een debugger. De gebruikelijke procedure is om uw code te schrijven en te compileren
zonder optimalisatie, debug het en schakel vervolgens de optimalisatie in.

Om de debugger te laten werken, moet de compiler niet alleen meewerken door niet
optimaliseren, maar ook door informatie over de namen van de symbolen in het object te plaatsen
bestand zodat de debugger weet hoe dingen worden genoemd. Dit is wat de "-g" -compilatie is
optie doet.

Als u klaar bent met debuggen en uw code wilt optimaliseren, vervangt u eenvoudigweg "-g" door
"-O". Voor veel compilers kunt u toenemende optimalisatieniveaus opgeven door toe te voegen
een getal na "-O". Mogelijk kunt u ook andere opties opgeven die de waarde verhogen
snelheid onder bepaalde omstandigheden (mogelijk in ruil voor een verhoogd geheugengebruik). Zien
de manpagina van uw compiler voor details. Hier is bijvoorbeeld een optimaliserende compileeropdracht
die ik vaak gebruik met de "gcc" -compiler:

gcc -O6 -kwaadaardig-dubbel -c xyz.c -o xyz.o

Mogelijk moet u experimenteren met verschillende optimalisatieopties voor het allerbeste
prestatie. Mogelijk hebt u verschillende opties nodig voor verschillende stukjes code. Over het algemeen
gesproken werkt een eenvoudige optimalisatievlag zoals "-O6" met veel compilers en meestal
levert behoorlijk goede resultaten op.

Waarschuwing: in zeldzame gevallen doet uw programma niet precies hetzelfde wanneer
het is samengesteld met optimalisatie. Dit kan te wijten zijn aan (1) een ongeldige veronderstelling die u heeft gemaakt
in uw code die zonder optimalisatie onschadelijk was, maar problemen veroorzaakt omdat de
compiler neemt de vrijheid om dingen te herschikken wanneer u optimaliseert; of (2) helaas,
compilers hebben ook bugs, inclusief bugs in hun optimizers. Voor een stabiele compiler zoals
"gcc" op een gemeenschappelijk platform zoals een Pentium, zijn optimalisatiebugs zelden een probleem (vanaf
het jaar 2000 - er waren een paar jaar geleden problemen).

Als u geen "-g" of "-O" opgeeft in uw compilatieopdracht, wordt het resulterende object
bestand is niet geschikt voor foutopsporing en ook niet voor snel gebruik. Om de een of andere reden is dit de
standaard. Geef dus altijd "-g" of "-O" op.

Op sommige systemen moet u "-g" opgeven bij zowel de compilatie- als de koppelingsstappen; op anderen
(bijv. Linux), hoeft dit alleen te worden opgegeven tijdens de compilatiestap. Op sommige systemen is "-O"
in de koppelfase doet het feitelijk iets anders, terwijl het bij anderen geen effect heeft.
In ieder geval is het altijd onschadelijk om voor beide commando's "-g" of "-O" op te geven.

waarschuwingen
De meeste compilers zijn in staat een aantal veelvoorkomende programmeerfouten op te vangen (bijv.
vergeten een waarde terug te geven van een functie die een waarde zou moeten retourneren). Gebruikelijk,
u wilt waarschuwingen inschakelen. Hoe je dit doet, hangt af van je compiler (zie man
page), maar met de "gcc"-compiler gebruik ik meestal zoiets als dit:

gcc -g -Wall -c xyz.c -o xyz.o

(Soms voeg ik ook "-Wno-uninitialized" toe na "-Wall" vanwege een waarschuwing
meestal verkeerd dat opduikt bij het optimaliseren.)

Deze waarschuwingen hebben mij vele uren aan foutopsporing bespaard.

Overige nuttig compilatie opties
Vaak worden noodzakelijke include-bestanden opgeslagen in een andere map dan de huidige
directory of het systeem bevat directory (/ Usr / include). Dit gebeurt vaak wanneer
u gebruikt een bibliotheek die wordt geleverd met include-bestanden om de functies of klassen te definiëren.

Stel dat u bijvoorbeeld een toepassing schrijft die gebruikmaakt van de Qt-bibliotheken. Jij hebt
installeerde een lokale kopie van de Qt-bibliotheek in /home/gebruikers/joe/qtDit betekent dat de
include-bestanden worden opgeslagen in de map /home/users/joe/qt/include. In jouw code, jij
wil dit soort dingen kunnen doen:

#erbij betrekken

in plaats van

#include "/home/users/joe/qt/include/qwidget.h"

U kunt de compiler vertellen om naar include-bestanden in een andere map te zoeken met behulp van de
"-I" compilatieoptie:

g++ -I/home/users/joe/qt/include -g -c mijnwidget.cpp -o mijnwidget.o

Er staat doorgaans geen spatie tussen de "-I" en de mapnaam.

Wanneer de C++-compiler naar het bestand zoekt qwidget.h, het zal naar binnen kijken
/home/users/joe/qt/include voordat u in de systeem include-directory kijkt. Jij kan
geef zoveel "-I"-opties op als u wilt.

gebruik bibliotheken
Vaak moet u de linker vertellen dat hij een koppeling moet maken met specifieke externe bibliotheken
roepen alle functies aan die geen deel uitmaken van de standaard C-bibliotheek. De "-l" (kleine letters
L) optie zegt om te linken met een specifieke bibliotheek:

cc -g xyz.o -o xyz -lm

"-lm" zegt dat het moet linken met de systeemwiskundebibliotheek, die je nodig hebt als je deze gebruikt
functies zoals "sqrt".

Pas op: als u meer dan één "-l"-optie opgeeft, kan de volgorde bij sommige een verschil maken
systemen. Als u ongedefinieerde variabelen krijgt terwijl u weet dat u de
bibliotheek die ze definieert, kunt u proberen die bibliotheek naar het einde van de opdracht te verplaatsen
regel, of voeg het zelfs een tweede keer toe aan het einde van de opdrachtregel.

Soms zijn de bibliotheken die u nodig heeft niet op de standaardplaats voor het systeem opgeslagen
bibliotheken. "-labc" zoekt naar een bestand met de naam libabc.a or libabc.zo or libabc.sa in de
systeembibliotheekmappen (/ Usr / lib en meestal ook op een paar andere plaatsen, afhankelijk van wat
soort Unix dat u gebruikt). De optie "-L" specificeert een extra map waarin moet worden gezocht
voor bibliotheken. Om het bovenstaande voorbeeld nogmaals te nemen, stel dat u de Qt-bibliotheken hebt geïnstalleerd
in /home/gebruikers/joe/qt, wat betekent dat de bibliotheekbestanden aanwezig zijn /home/users/joe/qt/lib.
Uw linkstap voor uw programma kan er ongeveer zo uitzien:

g++ -g test_mijnwidget.o mijnwidget.o -o test_mijnwidget -L/home/users/joe/qt/lib -lqt

(Op sommige systemen moet u, als u in Qt koppelt, ook andere bibliotheken toevoegen (bijv.
"-L/usr/X11R6/lib -lX11 -lXext"). Wat u moet doen, is afhankelijk van uw systeem.)

Houd er rekening mee dat er geen spatie staat tussen "-L" en de mapnaam. Meestal de optie "-L".
gaat vóór eventuele "-l"-opties die het zou moeten beïnvloeden.

Hoe weet je welke bibliotheken je nodig hebt? Over het algemeen is dit een moeilijke vraag, en deze varieert
afhankelijk van wat voor soort Unix je gebruikt. De documentatie voor de functies of
In de klassen die u gebruikt, moet worden vermeld met welke bibliotheken u moet linken. Als u gebruikt
functies of klassen uit een extern pakket, is er meestal een bibliotheek die u moet koppelen
met; de bibliotheek zal meestal een bestand zijn met de naam "libabc.a" of "libabc.so" of "libabc.sa"
als u een "-labc" -optie moet toevoegen.

sommige anders verwarrend spullen
Het is u misschien opgevallen dat het mogelijk is om opties op te geven die normaal gesproken van toepassing zijn
compilatie tijdens de koppelingsstap, en opties die normaal gesproken van toepassing zijn op het koppelen op de
compilatie stap. De volgende opdrachten zijn bijvoorbeeld geldig:

cc -g -L/usr/X11R6/lib -c xyz.c -o xyz.o
cc -g -I/ergens/include xyz.o -o xyz

De irrelevante opties worden genegeerd; de bovenstaande opdrachten zijn precies gelijk aan dit:

cc -g -c xyz.c -o xyz.o
cc -g xyz.o -o xyz

Gebruik makepp_tutorial_compilation online met behulp van onworks.net-services