C++
Kompilering och byggnad

Introduktion

Anmärkningar

Kompilering med GCC

Antagande av en enda källfil med namnet main.cpp , är kommandot för att kompilera och länka en icke-optimerad körbar som följer (Kompilering utan optimering är användbart för initial utveckling och felsökning, även om -Og officiellt rekommenderas för nyare GCC-versioner).

g++ -o app -Wall main.cpp -O0

För att producera en optimerad körbar för användning i produktion använder du ett av -O alternativen (se: -O1 , -O2 , -O3 , -Os , -Ofast ):

g++ -o app -Wall -O2 main.cpp

Om alternativet -O utelämnas används -O0, vilket betyder inga optimeringar, som standard (specificera -O utan ett nummer löses till -O1).

Alternativt kan du använda optimeringsflaggor från O grupperna (eller fler experimentella optimeringar) direkt. Följande exempel bygger med -O2 optimering, plus en flagga från -O3 optimeringsnivån:

g++ -o app -Wall -O2 -ftree-partial-pre main.cpp

För att producera en plattformsspecifik optimerad körbar (för användning i produktion på maskinen med samma arkitektur), använd:

g++ -o app -Wall -O2 -march=native main.cpp

Endera av ovanstående kommer att producera en binär fil som kan köras med .\app.exe på Windows och ./app på Linux, Mac OS, etc.

Flaggan -o kan också hoppas över. I detta fall skapar GCC standardutförbar exekverbar a.exe Windows och a.out på Unix-liknande system. För att kompilera en fil utan att länka den använder du alternativet -c :

g++ -o file.o -Wall -c file.cpp

Detta producerar en objektfil med namnet file.o som senare kan kopplas till andra filer för att producera en binär:

g++ -o app file.o otherfile.o

Mer om optimeringsalternativ finns på gcc.gnu.org . Särskilt anmärkningsvärt är -Og (optimering med betoning på felsökningsupplevelse - rekommenderas för standard redigering-kompilera-felsökningscykel) och -Ofast (alla optimeringar, inklusive sådana som inte respekterar strikta standarders efterlevnad).

Flaggan -Wall möjliggör varningar för många vanliga fel och bör alltid användas. För att förbättra -Wextra uppmuntras det ofta också att använda -Wextra och andra varningsflaggor som inte automatiskt aktiveras av -Wall och -Wextra .

Om koden förväntar sig en specifik C ++ -standard, ange vilken standard som ska användas genom att inkludera -std= . Värden som stöds motsvarar året för färdigställande för varje version av ISO C ++ -standarden. Från GCC 6.1.0 är giltiga värden för std= flaggan c++98 / c++03 , c++11 , c++14 och c++17 / c++1z . Värden som är separerade med ett snedstreck är likvärdiga.

g++ -std=c++11 <file>

GCC innehåller vissa kompilator-specifika tillägg som är inaktiverade när de strider mot en standard som anges av -std= flaggan. För att kompilera med alla tillägg aktiverade kan värdet gnu++XX användas, där XX är något av de år som används av c++ -värdena listade ovan.

Standardstandarden används om ingen anges. För versioner av GCC före 6.1.0 är standard -std=gnu++03 ; i GCC 6.1.0 och högre är standarden -std=gnu++14 .

Observera att på grund av buggar i GCC måste -pthread flaggan vara närvarande vid sammanställning och länkning för GCC för att stödja C ++ standardgängfunktioner som introducerats med C ++ 11, såsom std::thread och std::wait_for . Om du utelämnar det när du använder trådfunktioner kan det inte leda till några varningar men ogiltiga resultat på vissa plattformar.

Länk till bibliotek:

Använd alternativet -l att skicka bibliotekets namn:

g++ main.cpp -lpcre2-8
#pcre2-8 is the PCRE2 library for 8bit code units (UTF-8)

Om biblioteket inte finns i standardbibliotekets sökväg lägger du till sökvägen med -L :

g++ main.cpp -L/my/custom/path/ -lmylib

Flera bibliotek kan kopplas samman:

g++ main.cpp -lmylib1 -lmylib2 -lmylib3

Om ett bibliotek är beroende av ett annat, lägg det beroende biblioteket inför det oberoende biblioteket:

g++ main.cpp -lchild-lib -lbase-lib

Eller låt länken bestämma själva beställningen via --start-group och - --end-group (Obs: detta har betydande prestanda kostnad):

g++ main.cpp -Wl,--start-group -lbase-lib -lchild-lib -Wl,--end-group

Kompilering med Visual C ++ (kommandorad)

För programmerare som kommer från GCC eller Clang till Visual Studio, eller programmerare som är mer bekväm med kommandoraden i allmänhet, kan du använda Visual C ++ -kompileraren från kommandoraden och IDE.

Om du vill kompilera din kod från kommandoraden i Visual Studio måste du först ställa in kommandoradsmiljön. Detta kan göras antingen genom att öppna Visual Studio Command Prompt / Developer Command Prompt / x86 Native Tools Command Prompt / x64 Native Tools Command Prompt eller liknande (som tillhandahålls av din version av Visual Studio), eller vid kommandotolken, genom att navigera till underkatalogen VC för kompilatorns installationskatalog (vanligtvis \Program Files (x86)\Microsoft Visual Studio x\VC , där x är versionsnumret (som 10.0 för 2010 eller 14.0 för 2015) och kör VCVARSALL batchfilen med en kommandoradsparameter som anges här .

Observera att till skillnad från GCC tillhandahåller Visual Studio inte en front-end för länken ( link.exe ) via kompilatorn ( cl.exe ), utan istället tillhandahåller länken som ett separat program, som kompilatorn kallar när den kommer ut. cl.exe och link.exe kan användas separat med olika filer och alternativ, eller cl kan sägas att skicka filer och alternativ för att link om båda uppgifterna utförs tillsammans. Alla länkalternativ som anges för cl kommer att översättas till alternativ för link , och alla filer som inte behandlas av cl kommer att skickas direkt till link . Eftersom detta huvudsakligen är en enkel guide för att sammanställa med Visual Studio-kommandoraden kommer argument för link inte att beskrivas just nu; om du behöver en lista, se här .

Observera att argument för cl är skiftlägeskänsliga, medan argument att link inte är.

[Observera att några av följande exempel använder variabeln "aktuell katalog" i Windows-skalet, %cd% , när du anger absoluta sökvägsnamn. För alla som inte är bekanta med denna variabel expanderar den till den aktuella arbetskatalogen. Från kommandoraden kommer det att vara katalogen du befann dig i när du körde cl och anges som standard i kommandoprompten (om din kommandotolk är C:\src> , till exempel, är %cd% C:\src\ ).]

Förutsatt att en enda källfil med namnet main.cpp i den aktuella mappen är kommandot för att sammanställa och länka en ooptimerad körbar (användbar för initial utveckling och felsökning) är (använd något av följande):

cl main.cpp
// Generates object file "main.obj".
// Performs linking with "main.obj".
// Generates executable "main.exe".

cl /Od main.cpp
// Same as above.
// "/Od" is the "Optimisation: disabled" option, and is the default when no /O is specified.

Om du antar en ytterligare källfil "niam.cpp" i samma katalog, använd följande:

cl main.cpp niam.cpp
// Generates object files "main.obj" and "niam.obj".
// Performs linking with "main.obj" and "niam.obj".
// Generates executable "main.exe".

Du kan också använda jokertecken, som man kan förvänta sig:

cl main.cpp src\*.cpp
// Generates object file "main.obj", plus one object file for each ".cpp" file in folder
//  "%cd%\src".
// Performs linking with "main.obj", and every additional object file generated.
// All object files will be in the current folder.
// Generates executable "main.exe".

Om du vill byta namn på eller flytta den körbara kör du en av följande:

cl /o name main.cpp
// Generates executable named "name.exe".

cl /o folder\ main.cpp
// Generates executable named "main.exe", in folder "%cd%\folder".

cl /o folder\name main.cpp
// Generates executable named "name.exe", in folder "%cd%\folder".

cl /Fename main.cpp
// Same as "/o name".

cl /Fefolder\ main.cpp
// Same as "/o folder\".

cl /Fefolder\name main.cpp
// Same as "/o folder\name".

Både /o och /Fe passerar sin parameter (låt oss kalla det o-param ) för att link som /OUT:o-param , lägg till lämplig tillägg (i allmänhet .exe eller .dll ) för att "namnge" o-param vid behov. Medan både /o och /Fe är enligt mina kunskaper identiska i funktionalitet, föredras det senare för Visual Studio. /o är markerad som föråldrad och verkar främst tillhandahållas för programmerare som är mer bekanta med GCC eller Clang.

Observera att medan utrymmet mellan /o och den angivna mappen och / eller namnet är valfritt, kan det inte finnas ett avstånd mellan /Fe och den angivna mappen och / eller namnet.

På samma sätt, för att producera en optimerad körbar (för användning i produktion), använd:

cl /O1 main.cpp
// Optimise for executable size.  Produces small programs, at the possible expense of slower
//  execution.

cl /O2 main.cpp
// Optimise for execution speed.  Produces fast programs, at the possible expense of larger
//  file size.

cl /GL main.cpp other.cpp
// Generates special object files used for whole-program optimisation, which allows CL to
//  take every module (translation unit) into consideration during optimisation.
// Passes the option "/LTCG" (Link-Time Code Generation) to LINK, telling it to call CL during
//  the linking phase to perform additional optimisations.  If linking is not performed at this
//  time, the generated object files should be linked with "/LTCG".
// Can be used with other CL optimisation options.

Slutligen, för att producera en plattformspecifik optimerad körbar (för användning i produktion på maskinen med den angivna arkitekturen), välj lämplig kommandotolk eller VCVARSALL parameter för målplattformen. link ska detektera den önskade plattformen från objektfilerna; om inte, använd alternativet /MACHINE att specifikt ange målplattformen.

// If compiling for x64, and LINK doesn't automatically detect target platform:
cl main.cpp /link /machine:X64

Någon av ovanstående kommer att producera en körbar med namnet specificerat av /o eller /Fe , eller om inget av detta finns, med ett namn som är identiskt med den första källan eller objektfilen som anges för kompilatorn.

cl a.cpp b.cpp c.cpp
// Generates "a.exe".

cl d.obj a.cpp q.cpp
// Generates "d.exe".

cl y.lib n.cpp o.obj
// Generates "n.exe".

cl /o yo zp.obj pz.cpp
// Generates "yo.exe".

För att sammanställa en fil utan att länka, använd:

cl /c main.cpp
// Generates object file "main.obj".

Detta säger cl att avsluta utan att ringa link och producerar en objektfil som senare kan kopplas till andra filer för att producera en binär.

cl main.obj niam.cpp
// Generates object file "niam.obj".
// Performs linking with "main.obj" and "niam.obj".
// Generates executable "main.exe".

link main.obj niam.obj
// Performs linking with "main.obj" and "niam.obj".
// Generates executable "main.exe".

Det finns andra värdefulla kommandoradsparametrar också, vilket det skulle vara mycket användbart för användare att veta:

cl /EHsc main.cpp
// "/EHsc" specifies that only standard C++ ("synchronous") exceptions will be caught,
//  and `extern "C"` functions will not throw exceptions.
// This is recommended when writing portable, platform-independent code.

cl /clr main.cpp
// "/clr" specifies that the code should be compiled to use the common language runtime,
//  the .NET Framework's virtual machine.
// Enables the use of Microsoft's C++/CLI language in addition to standard ("native") C++,
//  and creates an executable that requires .NET to run.

cl /Za main.cpp
// "/Za" specifies that Microsoft extensions should be disabled, and code should be
//  compiled strictly according to ISO C++ specifications.
// This is recommended for guaranteeing portability.

cl /Zi main.cpp
// "/Zi" generates a program database (PDB) file for use when debugging a program, without
//  affecting optimisation specifications, and passes the option "/DEBUG" to LINK.

cl /LD dll.cpp
// "/LD" tells CL to configure LINK to generate a DLL instead of an executable.
// LINK will output a DLL, in addition to an LIB and EXP file for use when linking.
// To use the DLL in other programs, pass its associated LIB to CL or LINK when compiling those
//  programs.

cl main.cpp /link /LINKER_OPTION
// "/link" passes everything following it directly to LINK, without parsing it in any way.
// Replace "/LINKER_OPTION" with any desired LINK option(s).

För alla som är mer bekanta med * nix-system och / eller GCC / Clang, kan cl , link och andra Visual Studio-kommandoradsverktyg acceptera parametrar som anges med en bindestreck (till exempel -c ) istället för en snedstreck (t.ex. /c ). Dessutom känner Windows igen antingen en snedstreck eller en backslash som en giltig sökvägsavskiljare, så * nix-stilvägar kan också användas. Detta gör det enkelt att konvertera enkla kompilerkommandorader från g++ eller clang++ till cl , eller vice versa, med minimala ändringar.

g++ -o app src/main.cpp
cl  -o app src/main.cpp

Naturligtvis när du portar kommandorader som använder mer komplexa g++ eller clang++ -alternativ, måste du naturligtvis slå upp motsvarande kommandon i tillämpliga kompilatordokumentationer och / eller på resurswebbplatser, men det gör det lättare att komma igång med minimal tid att lära sig om nya kompilatorer.

Om du behöver specifika språkfunktioner för din kod krävdes en specifik utgåva av MSVC. Från Visual C ++ 2015 Update 3 på är det möjligt att välja version av standarden att kompilera med via /std flaggan. Möjliga värden är /std:c++14 och /std:c++latest ( /std:c++17 kommer att följa snart).

Obs: I äldre versioner av denna kompilator var specifika funktionsflaggor tillgängliga, men det användes mest för förhandsgranskningar av nya funktioner.

Kompilering med Visual Studio (grafiskt gränssnitt) - Hello World

1. Ladda ner och installera Visual Studio Community 2015
2. Öppna Visual Studio Community
3. Klicka på Arkiv -> Nytt -> Projekt
4. Klicka på Mallar -> Visual C ++ -> Win32 Console Application och namnge sedan projektet MyFirstProgram .
5. Klicka på Ok
6. Klicka på Nästa i följande fönster.
7. Empty project rutan Empty project och klicka sedan på Slutför:
8. Högerklicka på mappens källfil: - Lägg till -> Ny artikel:
9. Välj C ++ -fil och namnge filen main.cpp och klicka sedan på Lägg till: 10: Kopiera och klistra in följande kod i den nya filen main.cpp:

#include <iostream>

int main()
{
    std::cout << "Hello World!\n";
    return 0;
}

Din miljö ska se ut:

11. Klicka på Debug -> Start Without Debugging (eller tryck på ctrl + F5):

12. Gjort. Du bör få följande konsolutgång:

Kompilering med Clang

Eftersom Clang front-end är utformat för att vara kompatibelt med GCC kommer de flesta program som kan kompileras via GCC att kompileras när du byter g++ med clang++ i build-skript. Om ingen -std=version ges, kommer gnu11 att användas.

Windows-användare som är vana vid MSVC kan byta cl.exe med clang-cl.exe . Som standard försöker clang vara kompatibel med den högsta versionen av MSVC som har installerats.

Vid sammanställning med visuell studio kan clang-cl användas genom att ändra Platform toolset i projektegenskaperna.

I båda fallen är clang endast kompatibel via dess front-end, även om den också försöker generera binära kompatibla objektfiler. Användare av clang-cl bör notera att kompatibiliteten med MSVC ännu inte är fullständig .

För att använda clang eller clang-cl kan man använda standardinstallationen på vissa Linux-distributioner eller de som ingår i IDE: er (som XCode på Mac). För andra versioner av denna kompilator eller på plattformar som inte har detta installerat kan det laddas ner från den officiella nedladdningssidan .

Om du använder CMake för att bygga din kod kan du vanligtvis byta kompilator genom att ställa in CC och CXX miljövariablerna så här:

mkdir build
cd build
CC=clang CXX=clang++ cmake ..
cmake --build .

Se även introduktion till Cmake .

Online-kompilatorer

Olika webbplatser ger online-åtkomst till C ++ -kompilatorer. Onlinekompilatorens funktionsuppsättning varierar avsevärt från plats till plats, men vanligtvis tillåter de att göra följande:

• Klistra in din kod i ett webbformulär i webbläsaren.
• Välj några kompilatoralternativ och kompilera koden.
• Samla ut kompilatorn och / eller programutgången.

Beteende på webbsajtens kompilator är vanligtvis ganska begränsande eftersom de tillåter alla att köra kompilatorer och köra godtycklig kod på sin serversida, medan vanligtvis exekvering av godtycklig kodkod betraktas som sårbarhet.

Online-kompilatorer kan vara användbara för följande ändamål:

• Kör ett litet kodavsnitt från en maskin som saknar C ++ -kompilerare (smartphones, surfplattor, etc.).
• Se till att koden sammanställs framgångsrikt med olika kompilatorer och körs på samma sätt oavsett kompilatorn den kompilerades med.
• Lär dig eller lära grunderna i C ++.
• Lär dig moderna C ++ -funktioner (C ++ 14 och C ++ 17 inom en snar framtid) när aktuell C ++ -kompilator inte är tillgänglig på lokal maskin.
• Upptäck ett fel i din kompilator jämfört med en stor uppsättning andra kompilatorer. Kontrollera om ett kompilatorfel har rättats i framtida versioner, som inte är tillgängliga på din maskin.
• Lös problem med domare online.

Vad online-kompilatorer inte ska användas till:

• Utveckla fullfunktionella (även små) applikationer med C ++. Vanligtvis tillåter onlinekompilatorer inte att länka till tredjepartsbibliotek eller ladda ner build-artefakter.
• Utför intensiva beräkningar. Beräkningsresurser på allvarliga sidor är begränsade, så alla program som tillhandahålls av användaren kommer att dödas efter några sekunders körning. Den tillåtna exekveringstiden räcker vanligtvis för testning och inlärning.
• Attackera själva kompilatorservern eller andra värdparter på nätet.

Exempel:

Ansvarsfriskrivning: författare / dokumentation är inte anslutna till några resurser som anges nedan. Webbplatser listas alfabetiskt.

• http://codepad.org/ Online-kompilator med koddelning. Att redigera kod efter sammanställning med källkodvarning eller fel fungerar inte så bra.
• http://coliru.stacked-crooked.com/ Online-kompilator för vilken du anger kommandoraden. Tillhandahåller både GCC- och Clang-kompilatorer för användning.
• http://cpp.sh/ - Online-kompilator med C ++ 14-stöd. Tillåter dig inte att redigera kompileringskommandon, men vissa alternativ är tillgängliga via GUI-kontroller.
• https://gcc.godbolt.org/ - Ger en bred lista med kompilatorversioner, arkitekturer och demontering. Mycket användbart när du behöver inspektera vad din kod sammanställer av olika kompilatorer. GCC, Clang, MSVC ( CL ), Intel-kompilator ( icc ), ELLCC och Zapcc finns med en eller flera av dessa kompilatorer tillgängliga för ARM, ARMv8 (som ARM64), Atmel AVR, MIPS, MIPS64, MSP430, PowerPC , x86 och x64 arkitekttjänster. Argument för kommandoradskomponenter kan redigeras.
• https://ideone.com/ - Mycket använt på nätet för att illustrera kodavsnittens beteende. Tillhandahåller både GCC och Clang för användning, men tillåter dig inte att redigera kompileringens kommandorad.
• http://melpon.org/wandbox - Stöder många Clang- och GNU / GCC-kompilatorversioner.
• http://onlinegdb.com/ - En extremt minimalistisk IDE som innehåller en redigerare, en kompilator (gcc) och en felsökare (gdb).
• http://rextester.com/ - Tillhandahåller Clang-, GCC- och Visual Studio-kompilatorer för både C och C ++ (tillsammans med kompilatorer för andra språk), med Boost-biblioteket tillgängligt för användning.
• http://tutorialspoint.com/compile_cpp11_online.php - Fullständigt UNIX-skal med GCC, och en användarvänlig projektutforskare.
• http://webcompiler.cloudapp.net/ - Online Visual Studio 2015-kompilator, tillhandahålls av Microsoft som en del av RiSE4fun.

C ++ -sammanställningsprocessen

När du utvecklar ett C ++ -program är nästa steg att sammanställa programmet innan du kör det. Sammanställningen är den process som konverterar programmet skrivet på mänskligt läsbart språk som C, C ++ etc till en maskinkod, direkt förstått av Central Processing Unit. Om du till exempel har en C ++ källkodfil som heter prog.cpp och du kör kompileringskommandot,

   g++ -Wall -ansi -o prog prog.cpp

Det finns fyra huvudsteg involverade i att skapa en körbar fil från källfilen.

1. C ++ förprocessorn tar en C ++ källkodfil och hanterar rubrikerna (#include), makron (#define) och andra preprocessor-direktiv.

2. Den utvidgade C ++ källkodefilen som produceras av C ++ förbehandlaren sammanställs till monteringsspråket för plattformen.

3. Monteringskoden som genereras av kompilatorn samlas i objektkoden för plattformen.

4. Objektkodfilen som produceras av monteraren är länkad ihop
   med objektkodfilerna för alla biblioteksfunktioner som används för att producera antingen ett bibliotek eller en körbar fil.

förbehandling

Förbehandlaren hanterar förbehandlingsdirektiven, som #include och #define. Det är agnostiskt för syntaxen för C ++, varför det måste användas med försiktighet.

Det fungerar på en C ++ källfil i taget genom att ersätta #include-direktiv med innehållet i respektive filer (vilket vanligtvis bara är deklarationer), gör ersättning av makron (#definiera) och välja olika delar av text beroende på #if, #ifdef och #ifndef-direktiv.

Förbehandlaren fungerar på en ström av förbehandlingsmärken. Makrosubstitution definieras som att ersätta tokens med andra tokens (operatören ## gör det möjligt att slå samman två tokens när det är vettigt).

Efter allt detta producerar förprocessorn en enda utgång som är en ström av symboler som härrör från de ovan beskrivna transformationerna. Den lägger också till några speciella markörer som berättar kompilatorn var varje rad kommer från så att den kan använda dem för att producera förnuftiga felmeddelanden.

Vissa fel kan produceras i detta skede med smart användning av #if- och #rorror-direktivet.

Genom att använda kompilatorfilen nedan kan vi stoppa processen i förbehandlingsstadiet.

g++ -E prog.cpp

Kompilering

Kompilationssteget utförs på varje utgång från förprocessorn. Kompilatorn analyserar den rena C ++ källkoden (nu utan några förbehandlingsdirektiv) och omvandlar den till monteringskod. Åkallar sedan underliggande back-end (assembler in toolchain) som monterar den koden till maskinkod som producerar faktisk binär fil i något format (ELF, COFF, a.out, ...). Denna objektfil innehåller den sammanställda koden (i binär form) för symbolerna definierade i ingången. Symboler i objektfiler hänvisas till med namn.

Objektfiler kan hänvisa till symboler som inte är definierade. Detta är fallet när du använder en deklaration och inte anger någon definition för det. Kompilatorn har inget emot detta och kommer med glädje att producera objektfilen så länge källkoden är välformad.

Kompilatorer låter dig vanligtvis stoppa sammanställningen vid denna tidpunkt. Detta är mycket användbart eftersom du kan sammanställa varje källkodfil separat. Fördelen med detta är att du inte behöver kompilera allt om du bara ändrar en enda fil.

De producerade objektfilerna kan läggas i specialarkiv som kallas statiska bibliotek för att lättare kunna använda dem senare.

Det är i detta skede som "vanliga" kompilatorfel, som syntaxfel eller misslyckade överbelastningsupplösningsfel, rapporteras.

För att stoppa processen efter kompileringssteget kan vi använda alternativet -S:

g++ -Wall -ansi -S prog.cpp

montering

Monteraren skapar objektkod. På ett UNIX-system kan du se filer med .o-suffix (.OBJ på MSDOS) för att indikera objektkodfiler. I denna fas konverterar monteraren dessa objektfiler från monteringskod till maskinnivåinstruktioner och den skapade filen är en flyttbar objektkod. Följaktligen genererar kompilationsfasen det flyttbara objektprogrammet och detta program kan användas på olika platser utan att behöva kompilera igen.

För att stoppa processen efter monteringssteget kan du använda alternativet -c:

g++ -Wall -ansi -c prog.cpp

länka

Länken är vad som producerar den slutliga sammanställningsutgången från objektfilerna som samlaren producerade. Denna utgång kan vara antingen ett delat (eller dynamiskt) bibliotek (och medan namnet liknar har de inte mycket gemensamt med statiska bibliotek som nämnts tidigare) eller ett körbart.

Den länkar alla objektfiler genom att ersätta referenser till odefinierade symboler med rätt adresser. Var och en av dessa symboler kan definieras i andra objektfiler eller i bibliotek. Om de definieras i andra bibliotek än standardbiblioteket, måste du berätta länken om dem.

I detta skede saknas de vanligaste felen definitioner eller duplikatdefinitioner. Den förstnämnda innebär att antingen definitionerna inte finns (dvs. att de inte är skrivna), eller att objektfilerna eller biblioteken där de finns inte gavs till länken. Det senare är uppenbart: samma symbol definierades i två olika objektfiler eller bibliotek.

Kompilering med kod :: block (grafiskt gränssnitt)

1. Ladda ner och installera kod :: block här . Om du är på Windows, var noga med att välja en fil som namnet innehåller mingw , de andra filerna installerar inte någon kompilator.

2. Öppna kod :: Blockerar och klicka på "Skapa ett nytt projekt":

   

3. Välj "Konsolapplikation" och klicka på "Gå":

   

4. Klicka på "Nästa", välj "C ++", klicka på "Nästa", välj ett namn för ditt projekt och välj en mapp att spara den i, klicka på "Nästa" och klicka sedan på "Slutför".

5. Nu kan du redigera och sammanställa din kod. En standardkod som skriver ut "Hej värld!" i konsolen är redan där. För att kompilera och / eller köra programmet trycker du på en av de tre knapparna för kompilering / körning i verktygsfältet:

   

   Tryck på för att kompilera utan att springa , för att köra utan att sammanställa igen, tryck på och för att kompilera och sedan köra, tryck .

   Kompilera och köra standard "Hej värld!" kod ger följande resultat: