Generatoren, compilers en IDE's - Platformonafhankelijke C SDK (2024)

Deze pagina is automatisch vertaald met behulp van de Google Translate API-services. Wij werken aanverbeterenteksten. Bedankt voor uw begrip en geduld.

Het is moeilijk om software te schrijven die correct en efficiënt werkt. Dus als een programma eenmaal in een bepaalde omgeving werkt, wil je niet veel moeite meer doen als je het naar een andere compiler, processor of besturingssysteem verplaatst.Idealiter zou er geen enkele verandering nodig zijn.Kernighan & Pike - De praktijk van programmeren.

1. Draagbaarheidsconcept

Wij begrijpen het doordraagbaarheid(Figuur 1) de mogelijkheid om onze programma's te compileren en te debuggen op andere platforms dan die waarop ze zijn geschreven, zonder ook maar één regel code aan te hoeven raken. Wij begrijpen het doorplatformde combinatie van een compiler en een CPU-architectuur. Bijvoorbeeld,v143_x64verwijst naar Visual Studio 2022 en Intel 64bits. Wij begrijpen het doorconfiguratiede set vlaggen en compileropties die zijn gebruikt om de binaire bestanden te genereren.

• Werkkopie:Op elke machine moet een kopie van de broncode van het project aanwezig zijn. Normaal gesproken gebeurt dit via een versiebeheersysteem (SVN, Git, enz.).
• CMaak:zal een buildproject maken of bijwerken vanuit de broncode met behulp van/src/CMakeLists.txten de scripts in de/prjmap. Dit zal volledig automatisch gebeuren.
• Compileren:Met behulp van Visual Studio, Xcode of GCC wordt de oplossing gecompileerd en worden de daarin opgenomen bibliotheken en uitvoerbare bestanden gegenereerd.
• Uitvoeren/foutopsporing:De binaire bestanden kunnen nu worden uitgevoerd en fouten worden opgespoord op het doelplatform.

2. CMake-generatoren

We herinneren ons dat een compiler op één bronbestand tegelijk werkt. Wanneer we een .c of .cpp compileren, wordt een objectbestand (.o, .obj) gegenereerd dat de binaire code van genoemde bron bevat. Maar elk project van een bepaalde omvang bevat honderden bestanden, georganiseerd in bibliotheken die moeten worden gekoppeld om de uiteindelijke uitvoerbare bestanden te maken. Wij weten alssysteem bouwende tool die de compilatie van alle projectbestanden orkestreert, om deze zo snel en efficiënt mogelijk te maken. We kunnen zeggen dat CMake een meta-build-systeem is dat build-projecten voor verschillende tools kan genereren (Figuur 2). Om dit te doen zullen we gebruik maken van de-Gkeuze.

cmake -G "Visual Studio 17 2022"cmake -G Ninjacmake -G Xcodecmake -G "Unix Makefiles"

Niet alle generatoren werken op alle platforms, en er is meestal geen strikte binding tussen generator en compiler. Bijvoorbeeld deNinjagenerator kan de onderstaande MSVC-, GCC- en Clang-compilers gebruiken. Het belangrijkste dat we moeten onthouden is dat CMake, via deCMakeLists.txtvan het project, verenigt het hele bouwproces en maakt het transparant voor de ontwikkelaar, ongeacht de generator, compiler en platform.

3. Compileer op Windows

Visual Studio is de ontwikkelomgeving bij uitstek voor Windows. In hetzelfde pakket integreert het het buildsysteem (msbuild), de compiler (MSVC) en de editor (IDE). We kunnen elke versie, vanaf 2005, gebruiken om NAppGUI op Windows te compileren (tafel 1). Zoals we al zagenSnelle starthet eerste dat we moeten doen is CMake starten op de broncode:

	Compiler	Platform	Minimale besturingssysteem
	Visuele Studio 2022	v143_x64 (x86)	Uitzicht
	Visuele Studio 2019	v142_x64 (x86)	Uitzicht
	Visuele Studio 2017	v141_x64 (x86)	Uitzicht
	Visuele Studio 2015	v140_x64 (x86)	Uitzicht
	Visuele Studio 2013	v120_x64 (x86)	Uitzicht
	Visuele Studio 2012	v110_x64 (x86)	Uitzicht
	Visuele Studio 2010	v100_x64 (x86)	XP
	Visuele Studio 2008	v90_x64 (x86)	XP
	Visuele Studio 2005	v80_x64 (x86)	XP

cmake -G "Visual Studio 16 2019" -A x64 -T v120 -S . -B-bouw

• -Gis de versie van Visual Studio (generator).

-G "Visual Studio 17 2022"-G "Visual Studio 16 2019"-G "Visual Studio 15 2017"-G "Visual Studio 14 2015"-G "Visual Studio 12 2013"-G "Visual Studio 11 2012"-G "Visual Studio 10 2010"-G "Visual Studio 9 2008"-G "Visual Studio 8 2005"

• -Ais Intel 32- of 64-bits architectuur:

-Een x64-A Win32

• -Tis dePlatformtoolset. Als u deze parameter weglaat, wordt de laatste parameter gebruikt die door de compiler wordt ondersteund.

-T v143-T v142-T v141-T v140-T v120-T v110// Voor XP-compatibiliteit-T v141_xp-T v140_xp-T v120_xp-T v110_xp-T v100-T v90-T v80

• -S: Pad waar deCMakeLists.txtbevindt zich.
• -B: Pad waar de bouwprojecten, binaire bestanden en tijdelijke bestanden worden gegenereerd.

Ondersteuning voor Visual Studio 8 2005 is verwijderd in CMake 3.12. U moet een oudere versie van CMake gebruiken als u nog steeds VS2005 gebruikt. NAppGUI werkt NIET met versies vóór VS2005.

NAppGUI biedt geen ondersteuning voor niet-x86-, x64-architecturen op Windows: ARM, Itanium, enz.

Na het uitvoeren van CMake verschijnt er een VisualStudio-oplossing in het/bouwenmap,NAppGUI.slnof welke naam dan ook is geconfigureerdproject(NAppGUI)van deCMakeLists.txt. Open die oplossing en vanuit Visual Studio,Bouw->Bouw oplossingcompilerenFoutopsporing -> Start foutopsporingdebuggen (figuur 3).

Om de versie van Visual Studio te wijzigen, selecteert u een andere builder in CMake-G "Visuele Studio 15 2017", sluit de oplossing en open deze opnieuw.

Om de voorbeeldapplicaties te bouwen, moet u de-DNAPPGUI_DEMO=NEEoptie in CMake.

Zoals we al zagenBouw NAppGUIAls u alleen de SDK wilt compileren, hoeft u de oplossing niet in de editor te openen. U kunt het rechtstreeks vanaf de opdrachtregel compileren.

cmake -G "Visuele Studio 17 2022" -S . -B build -DNAPPGUI_DEMO=NOcmake --build build --config Release -j 4

3.1. Platformtoolset

Vanaf Visual Studio 2010 is er een ontkoppeling tussen de editor en de compiler. De voorwaardePlatform-toolsetidentificeert de compiler zelf, die kan blijven worden gebruikt met modernere IDE's. Als we niets specificeren, zal CMake de standaard toolset gebruiken die in elke versie van VS is opgenomen, maar deze kan worden gewijzigd met behulp van de-Tparameter van CMake (tafel 2). We kunnen bijvoorbeeld combinerenVisuele Studio 15 2017met de VS2013-toolset voor Windows XPv120_xp:

cmake -G "Visual Studio 15 2017" -A Win32 -T v120_xp -S . -B-bouw

Elke versie van Visual Studio moet zijn geïnstalleerd om de bijbehorende toolset te kunnen gebruiken. Er zijn "light" versies die degereedschap bouwenzonder de ontwikkelomgeving.

3.2. Visuele C++ Herdistribueerbaar

Standaard koppelt Visual Studio dynamisch de functies van de C-standaardbibliotheek, wat betekent dat de.exewerkt mogelijk niet op machines die niet over deVC++ DLL's(Figuur 4). Dit dwingt toepassingen om een ​​kopie op te nemen vanMSVCRT.dll,VCRUNTIME.dll, ... of om de beroemde te installerenVisuele C++ Herdistribueerbaarpakketjes. om ervoor te zorgen dat de applicatie soepel kan werken.

NAppGUI gebruikt een beperkte set van de C-bibliotheek, omdat deze waar mogelijk rechtstreeks toegang heeft tot de Windows API. Om deze reden voeren alle applicaties die met NAppGUI zijn gemaakt een statische link uit (option/MT) van de noodzakelijke functies van de stdlib, waarbij afhankelijkheden worden vermeden ten koste van een iets grotere (enkele Kb) grootte van het uitvoerbare bestand. laatste. Dit zorgt ervoor dat applicaties soepel draaien op alle Windows-machines zonder dat er extra DLL's nodig zijn en zonder dat u deVC++ Herdistribueerbaar.

NAppGUI-applicaties vereisen geen Visual C++ Redistributable. Ook maken zij geen gebruik van de MFC “Microsoft Foundation Classes” of het .NET platform.

3.3. WindowsXP-ondersteuning

Vanaf VS2012 is dePlatformtoolsetgenereert uitvoerbare bestanden die niet compatibel zijn met WindowsXP. Als we willen dat onze applicaties op dit systeem draaien, moeten we de alternatieve toolset selecteren die eindigt op_xp:v141_xp,v140_xp,v120_xp,v110_xp. Ofv100,v90ofv80(VS2010, 2008, 2005), die XP rechtstreeks ondersteunen (Figuur 5).

Ondersteuning voor WindowsXP is definitief verwijderd in Visual Studio 2019.Er is geen Platform Toolset v142_xp.

Kan geen applicaties maken met NAppGUI die werken op Windows vóór XP.

3.4. SSE-ondersteuning

Met de Pentium III introduceerde Intel een extra instructieset voor drijvende-kommabewerkingen, genaamd SSEStreaming SIMD-extensies. Hierdoor kunt u wiskundige berekeningen optimaliseren, maar gaat de compatibiliteit verloren, aangezien toepassingen die SSE gebruiken niet werken op Pentium II of eerdere modellen. In NAppGUI wordt hetv80_x86Env90_x86toolsets zijn gereserveerd voor het bouwen van applicaties die compatibel zijn met oudere (tafel 3) verwerkers. Beginnend metv100_x86, SSE2 zal in alle toolsets worden gebruikt.

SSE-ondersteuning is alleen uitgeschakeld op 32-bits (x86) architecturen. Alle 64-bits (x64) CPU's bevatten SSE2.

3.5. Ninja op Windows

DeNinjagenerator maakt snellere compilaties mogelijk dan Visual Studio, in ruil voor het verlies van de *.sln-, *.vcxproj-projecten die erg handig zijn voor het debuggen vanuit de IDE. Het wordt meestal gebruikt in continue integratiesystemen waar snelheid prevaleert ten gunste van veelzijdigheid. Het eerste is downloadenNinja, kopiërenninja.exenaar elke systeemmap en maak deze toegankelijk via dePADvariabel.

ninja --versie 1.11.1

Op Windows gebruikt Ninja deMVSCcompiler eronder (net als Visual Studio), met dit verschil dat Ninja in principe niet weet waar zo'n compiler zich bevindt. Om het toegankelijk te maken, hebben we twee manieren:

• Gebruik deOpdrachtprompt voor ontwikkelaars 2022console (of welke versie u ook kiest). Deze terminal kent de locatie van de buildtools.
• Stel de omgevingsvariabelen in met behulp van devcvarsall.bat [Win32|x64]script. Een mogelijke locatie zal zijn"C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvarsall.bat" x64, maar dit zal veranderen afhankelijk van de versie die we gebruiken.

cmake -G Ninja -S . -B build -DNAPPGUI_DEMO=NO -DCMAKE_BUILD_TYPE=Releasecmake --build build

We kunnen ook de multi-configuratieversie van Ninja gebruiken:

cmake -G "Ninja Multi-Config" -S . -B build -DNAPPGUI_DEMO=NOcmake --build build --config Release

4. Compileer op macOS

Om te compileren voor Apple iMac, macBook en macMini hebben we CMake enXcodebeginnend met versie 3.2.6 (Tabel 4). Met NAppGUI kunt u applicaties bouwen die werken op MacOSX 10.6 Snow Leopard en hoger:

	Compiler	Minimale besturingssysteem	Platform
	Xcode 15.0.1	Sonoma	sdk14_0_x64 (arm)
	Xcode 14.3.1	Ventura	sdk13_6_x64 (arm)
	Xcode 13.4.1	Monterey	sdk12_3_x64 (slecht)
	Xcode 12.5.1	Grote Sur	sdk11_5_x64 (arm)
	Xcode 11.7	Catalina	sdk10_15_x64
	Xcode 10.3	Mojave	sdk10_14_x64
	Xcode 9.4.1	Hoge Sierra	sdk10_13_x64
	Xcode 8.3.3	Sierra	sdk10_12_x64
	Xcode 7.3.1	Gezagvoerder	sdk10_11_x64
	Xcode 6.4	Yosemite	sdk10_10_x64
	Xcode 6.2	Buitenbeentjes	sdk10_9_x64
	Xcode 5.1.1	Bergleeuw	sdk10_8_x64
	Xcode 4.6.3	Leeuw	sdk10_7_x64
	Xcode 3.2.6	Sneeuwluipaard	sdk10_6_x64 (x86)

cmake -G Xcode -DCMAKE_DEPLOYMENT_TARGET=11.0 -DCMAKE_ARCHITECTURE=arm64 -S . -B-bouw

• -GaltijdXcode. Gebruikxcode-selectom te schakelen als u meerdere versies hebt geïnstalleerd.
• -DCMAKE_DEPLOYMENT_TARGET. Minimale besturingssysteem dat wordt ondersteund. Als u dit weglaat, wordt deBasis-SDKopgenomen in de Xcode-versie.

-DCMAKE_DEPLOYMENT_TARGET=14.0 // Sonoma-DCMAKE_DEPLOYMENT_TARGET=13.6 // Ventura-DCMAKE_DEPLOYMENT_TARGET=13.5 // Ventura-DCMAKE_DEPLOYMENT_TARGET=13.4 // Ventura-DCMAKE_DEPLOYMENT_TARGET=13.3 // Ventura-DCMAKE_DEPLO YMENT_TARGET=13.2 // Ventura-DCMAKE_DEPLOYMENT_TARGET=13.1 // Ventura- DCMAKE_DEPLOYMENT_TARGET=13.0 // Ventura-DCMAKE_DEPLOYMENT_TARGET=12.4 // Monterey-DCMAKE_DEPLOYMENT_TARGET=12.3 // Monterey-DCMAKE_DEPLOYMENT_TARGET=12.2 // Monterey-DCMAKE_DEPLOYMENT_TARGET=12.0 // Monterey-DCMAKE_DEPLOY MENT_TARGET=11.5 // Grote Sur-DCMAKE_DEPLOYMENT_TARGET=11.4 // Grote Sur -DCMAKE_DEPLOYMENT_TARGET=11.3 // Big Sur-DCMAKE_DEPLOYMENT_TARGET=11.2 // Big Sur-DCMAKE_DEPLOYMENT_TARGET=11.1 // Big Sur-DCMAKE_DEPLOYMENT_TARGET=11.0 // Big Sur-DCMAKE_DEPLOYMENT_TARGET=10.15 // Catalina-DCMAKE_DE PLOYMENT_TARGET=10.14 // Mojave-DCMAKE_DEPLOYMENT_TARGET=10.13 // Hoge Sierra-DCMAKE_DEPLOYMENT_TARGET=10.12 // Sierra-DCMAKE_DEPLOYMENT_TARGET=10.11 // El Capitan-DCMAKE_DEPLOYMENT_TARGET=10.10 // Yosemite-DCMAKE_DEPLOYMENT_TARGET=10.9 // Mavericks-DCMAKE_DEPLOYMENT_TARGET=10.8 // Berg Lion-DCMAKE_DEPLOYMENT_TARGET=10.7 // Lion-DCMAKE_DEPLOYMENT_TARGET =10,6 // Sneeuwluipaard

• -DCMAKE_ARCHITECTURE.arm64,x64,ik386. Dearm64architectuur is inbegrepen vanaf SDK 11.0 Big Sur.ik386is verouderd in macOS 10.13 High Sierra.

-DCMAKE_ARCHITECTURE=arm64-DCMAKE_ARCHITECTURE=x64-DCMAKE_ARCHITECTURE=i386

NAppGUI ondersteunt het maken vanApple's Fat binaire bestanden. In dit veld moet u één enkele waarde opgeven.

• -S: Pad waar deCMakeLists.txtbevindt zich.
• -B: Pad waar de bouwprojecten, binaire bestanden en tijdelijke bestanden worden gegenereerd.

Na het uitvoeren van CMake verschijnt er een Xcode-oplossing in het/bouwenmap,NAppGUI.xcodeprojof welke naam dan ook is geconfigureerdproject(NAppGUI)van deCMakeLists.txt. Als we de Xcode-oplossing openen, zien we de verschillende projecten waaruit het bestaat, inclusiefDood gaanEnDobbelsteen. SelecteerDood gaanin de vervolgkeuzelijst linksboven en klik vervolgens opToneelstukofProduct->Uitvoeren(Figuur 6). Hierdoor wordt het programma gecompileerd en in de debug-modus gestart, waar we breekpunten kunnen instellen om de stapel en de waarden van de variabelen te inspecteren.

Om de voorbeeldapplicaties te bouwen, moet u de-DNAPPGUI_DEMO=NEEoptie in CMake.

4.1. Basis-SDK en implementatiedoel

Elk jaar brengt Apple een nieuwe versie van macOS uit, vergezeld van een nieuwe SDK en een update voor Xcode die de SDK bevat. Dit heet deBasis-SDK.

Basis-SDKis de versie die is opgenomen in elke nieuwe hoofdversie van Xcode en die overeenkomt met de nieuwste versie van het macOS-systeem die op de markt is uitgebracht.

Apple heeft een veel restrictiever beleid dan Microsoft wat betreft de compatibiliteit van applicaties met eerdere versies van het besturingssysteem. Standaard werkt een programma dat is gecompileerd met SDK 10.14 (macOS Mojave) niet op de onmiddellijk voorafgaande macOS High Sierra (Figuur 7).

Om dit probleem te voorkomen en ervoor te zorgen dat applicaties op oudere macOS werken, is er deImplementatiedoelparameter. Als u deze gebruikt, wordt een macro geactiveerd die de nieuwe functies van de Base SDK overschrijft. Hierdoor kan het programma op oudere versies worden uitgevoerd, maar dit kost uiteraard geen toegang tot de nieuwste iMac-functies. U kunt het implementatiedoel dat voor uw project vereist is, selecteren via de-DCMAKE_DEPLOYMENT_TARGETparameter, zoals we al in de vorige sectie hebben gezien.

Xcode 14 beëindigt implementatiedoelen onder 10.13 (Figuur 8). Gebruik Xcode 13 als u compatibiliteit met Mac OSX 10.12 Sierra en eerder wilt.

Xcode 8 beëindigt implementatiedoelen onder 10.9 (Figuur 9). Gebruik Xcode 7 als u compatibiliteit wilt met Mac OSX 10.8 Mountain Lion en eerder.

4.2. xcode-select

We hebben al gezien dat CMake slechts één generator voor Xcode aanbiedt (-G "Xcode"), hoewel het mogelijk is om meerdere versies op dezelfde machine te installeren, elk binnen zijn eigen versiebundel Xcode.app. Er zal altijd een standaard Xcode op het systeem aanwezig zijn (de meest recente), maar deze kan worden gewijzigd met behulp van dexcode-selectnutsvoorziening:

xcode-select -p/Applications/Xcode.app/Contents/Developer

sudo xcode-select -s /Applications/Xcode8.app/Contents/Developer

sudo xcode-select -r

Je zult moeten rennencmake -G "Xcode"...elke keer dat u het gebruikt opnieuwxcode-selectvoor uw project om de compilerwijziging bij te werken.

4.3. macOS-ARM

In november 2020 lanceert Apple zijn nieuwe lijn desktop- en laptopcomputers (iMac, macBook en macMini) gebaseerd op de Apple M1-processor met ARM (Figuur 10) architectuur. Hoewel ze in staat zijn programma's uit te voeren die zijn gecompileerd voor Intel x64 met behulp van de Rosetta 2 (Figuur 11) programma, zou het ideaal zijn om onze applicaties voor de nieuwe architectuur te compileren om de uitvoerbare bestanden zoveel mogelijk te optimaliseren.

NAppGUI ondersteunt bouwen voor de Apple ARM-architectuur. Je hoeft alleen maar de-DCMAKE_ARCHITECTURE=arm64optie in CMake, zoals we in de vorige sectie zagen.

U kunt de M1-architectuur compileren vanaf Intel x64-machines, maar u kunt de uitvoerbare bestanden niet debuggen.

M1-architectuur is alleen beschikbaar voor het Big Sur-systeem (macOS 11.0) en hoger.

4.4. macOS 32-bits

Sinds de release van macOS High Sierra heeft Apple dat gedaanverklaarde de 32-bits architectuur achterhaald, het uitgeven van kennisgevingen aan gebruikers in het geval van detectieik386(Figuur 12) uitvoerbare bestanden. Vanaf Xcode 10 (Figuur 13) kan niet op deze architectuur worden gecompileerd.

Ondersteuning voor 32bit-applicaties is voorgoed verdwenenmacOS Catalina, waarmee alleen 64bit-applicaties kunnen worden uitgevoerd.

Dit is logisch omdat alle op Intel gebaseerde iMac-modellen 64-bits processors hebben, met uitzondering van enkele modellen uit 2006 van wit polycarbonaat waarop de 32-bits Intel Core Duo was gemonteerd (Figuur 14). Deze iMacs ondersteunden maximaal Mac OSX 10.6 Snow Leopard, waarbij een 64-bit CPU een fundamentele vereiste was vanaf 10.7 Lion. Om zonder problemen in 32 bits te compileren, moet u maximaal Xcode 6 (Figuur 15).

4.5. Maken op macOS

DeUnix-merkhulpprogramma is opgenomen als onderdeel van de Xcode-buildtools. Daarom kunnen we het gebruiken als generator op macOS, als we het zonder de Xcode-projecten kunnen doen. Make is een monoconfiguratie, dus we moeten tijdens het genereren het configuratietype aangeven.

cmake -G "Unix Makefiles" -S . -B build -DNAPPGUI_DEMO=NO -DCMAKE_BUILD_TYPE=Releasecmake --build build

4.6. Ninja op macOS

Net als in Windows en Linux kunnen we in macOS de Ninja-generator gebruiken. De eerste stap is om het te installeren:

brew install ninjaninja --versie 1.11.1

Het gebruik ervan is identiek aan dat van andere platforms en u kunt de mono- of multi-configuratieversie gebruiken.

cmake -G Ninja -S . -B build -DNAPPGUI_DEMO=NO -DCMAKE_BUILD_TYPE=Releasecmake --build build

cmake -G "Ninja Multi-Config" -S . -B build -DNAPPGUI_DEMO=NOcmake --build build --config Release

AppelKlangis de "officiële" compiler voor macOS. De versie die is opgenomen in Xcode zal altijd worden gebruikt, ongeacht de generator.

5. Compileer op Linux

Voor Linux-versies gebruiken we degcc(Tabel 5) compiler en demakentool om de binaire bestanden te genereren, maar er is geen "officiële" ontwikkelomgeving zoals gebeurt in Windows en macOS. Om een ​​elementaire configuratie van onze apparatuur uit te voeren, typt u de volgende opdrachten in een terminal:

1 2 3 4 5 6 7 8 910111213141516171819

// Ontwikkelingstoolssudo apt-get install build-essentialsudo apt-get install gitsudo apt-get install cmake// Ontwikkelingsbibliothekensudo apt-get install libgtk-3-devsudo apt-get install libglu1-mesa-dev freeglut3-dev mesa-common- devsudo apt-get install libcurl4-openssl-dev// GTK Inspector (Ctrl+D tijdens het debuggen)gsettings set org.gtk.Settings.Debug enable-inspector-keybinding true// Controleer systeembibliotheken versiepkg-config --modversion gtk+-3.03 .24.20pkg-config --modversion libcurl7.68.0

	Minimale besturingssysteem	Compiler	Gereedschapskist	Platform
	Ubuntu 22.04 LTS	GCC 11.2.0	GTK 3.24.33	gcc11_gtk3_x64
	Ubuntu 20.04 LTS	GCC 9.3	GTK 3.24.20	gcc9_gtk3_x64
	Ubuntu 18.04 LTS	GCC 7.5	GTK 3.22.30	gcc7_gtk3_x64
	Ubuntu 16.04 LTS	GCC 5.4	GTK 3.18.9	gcc5_gtk3_x64 (x86)
	Ubuntu 14.04 LTS	GCC 4.8.4	GTK 3.10.8	gcc4_8_gtk3_x64 (x86)
	Ubuntu 12.04 LTS	GCC 4.6.3	GTK 3.4.2	gcc4_6_gtk3_x64 (x86)
	Raspbian 11 Bullseye	GCC 10.2.1	GTK 3.24.24	gcc10_gtk3_arm64
	Raspbian 10 Buster	GCC 8.3.0	GTK 3.24.5	gcc8_gtk3_arm
	Raspbian 9.1 Strech	GCC 6.3.0	GTK 3.22.11	gcc6_gtk3_arm
	Raspbian 8.0 Jessie	GCC 4.9.2	GTK 3.14.5	gcc4_9_gtk3_arm

Net zoals we deden op Windows en macOS, rennen wemaakom het bouwproject te genereren:

cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Debug -DCMAKE_ARCHITECTURE=x64 -DCMAKE_TOOLKIT=GTK3 -S . -B-bouw

• -Galtijd"Unix-makefiles". Bovendien kunt u projecten maken voor de belangrijkste IDE's die beschikbaar zijn in Linux:

-G "Unix Makefiles"-G "CodeBlocks - Unix Makefiles"-G "CodeLite - Unix Makefiles"-G "Sublieme tekst 2 - Unix Makefiles"-G "Kate - Unix Makefiles"-G "Eclipse CDT4 - Unix Makefiles"

• -DCMAKE_BUILD_TYPE. In tegenstelling tot Visual Studio en Xcode staat Make het maken van multi-configuratieprojecten niet toe. Het moet worden aangegeven op het moment van generatie:

-DCMAKE_BUILD_TYPE=Debug-DCMAKE_BUILD_TYPE=Release-DCMAKE_BUILD_TYPE=ReleaseWithAssert

• -DCMAKE_ARCHITECTURE.x64,ik386,arm,arm64. Cross-compiling is niet toegestaan ​​onder Linux. We moeten dezelfde architectuur selecteren als de hostmachine. Deze parameter kan worden weggelaten; deze wordt automatisch ingesteld.

-DCMAKE_ARCHITECTURE=x64 // Alleen in Linux Intel 64bits hosts-DCMAKE_ARCHITECTURE=i386 // Alleen in Linux Intel 32bits hosts-DCMAKE_ARCHITECTURE=arm // Alleen in Linux ARM 32bits hosts-DCMAKE_ARCHITECTURE=arm64 // Alleen in Linux ARM 64bits hosts

• -DCMAKE_TOOLKIT. Vanaf vandaag is de enige beschikbare optieGTK3, aangezien NAppGUI geen andere grafische toolkits ondersteunt. Deze parameter kan worden weggelaten; deze wordt automatisch ingesteld.

-DCMAKE_TOOLKIT=GTK3

• -S: Pad waar deCMakeLists.txtbevindt zich.
• -B: Pad waar de bouwprojecten, binaire bestanden en tijdelijke bestanden worden gegenereerd.

Na het uitvoerenmaakwe zullen hebben, in de/bouwenmap, een reeks vanMaakbestandenklaar om het project samen te stellen.

cmake --build build -j 4...[ 93%] Koppeling van het uitvoerbare CXX-bestand ../../Debug/bin/DrawBig[ 93%] Koppeling van het uitvoerbare CXX-bestand ../../Debug/bin/GuiHello[ 93% ] Gebouwd doel DrawBig[ 94%] C-object bouwen howto/drawhello/CMakeFiles/DrawHello.dir/resgen/res_drawhello.c.o[ 94%] Koppeling van uitvoerbaar CXX-bestand ../../Debug/bin/Col2dHello[ 98%] Gebouwd doel GuiHello[ 98%] C-object bouwen howto/drawimg/CMakeFiles/DrawImg.dir/resgen/res_drawimg.c.o[ 98%] CXX uitvoerbaar bestand koppelen ../../Debug/bin/UrlImg[ 98%] CXX uitvoerbaar bestand koppelen .. /../Debug/bin/DrawHello[ 98%] Gebouwd doel Col2dHello[ 98%] Koppeling van CXX uitvoerbaar bestand ../../Debug/bin/ColorView[ 98%] Gebouwd doel UrlImg[ 98%] Gebouwd doel DrawHello[ 99 %] Koppeling van uitvoerbaar CXX-bestand ../../Debug/bin/DrawImg[100%] Gebouwd doel ColorView[100%] Gebouwd doel DrawImg

Zodra de compilatie is voltooid, kunnen we de uitvoerbare bestanden rechtstreeks vanaf de terminal starten:

./build/demo/die/Debug/Die

Als je je er redelijk op je gemak bij voeltgdb, kunt u proberen de code rechtstreeks vanuit de (Figuur 16) eindstation. Later zullen we zien hoe we dit kunnen doen met Eclipse en Visual Studio Code.

gdb ./build/demo/die/Debug/Die(gdb) uitvoeren...

Om de voorbeeldapplicaties te bouwen, moet u de-DNAPPGUI_DEMO=NEEoptie in CMake.

5.1. GTK+3

In tegenstelling tot Windows en macOS ondersteunt Linux een groot aantal desktopomgevingen gebaseerd op verschillende bibliotheken (ofgereedschapskisten), GTK en Qt zijn de twee bekendste. NAppGUI gebruikt GTK+3 voor het grafische gedeelte, aangezien dit de basis is van Gnome, Xfce, Lxde, enz. (Tabel 6)-omgevingen die aanwezig zijn in veel van de meest wijdverspreide distributies. GTK+3 zal op natuurlijke wijze in alle versies aanwezig zijn, zonder dat er andere aanvullende afhankelijkheden nodig zijn. Om onder GTK+3 te kunnen compileren, moeten we natuurlijk de ontwikkelaarsversie installeren, zoals we aan het begin van deze sectie hebben gezien.

	Omgeving	Uitkeringen
	Kabouter	Ubuntu, Debian, Fedora, Red Hat, CentOS, Manjaro, Suse, Arch, ...
	Xfce	Xubuntu, Debian, Fedora, Manjaro, ...
	Lxde	Lubuntu, Raspbian, Debian, Fedora, Mandriva, ...
	Kaneel	Mint, Debian, Ubuntu, Fedora, OpenSuse, ...
	Maat	Ubuntu Mate, Mint, Debian, Fedora, OpenSuse, ...
	Pantheon	Elementair besturingssysteem
	Suiker

5.2. Meerdere versies van GCC

Hoewel elke Linux-distributie wordt geleverd met een "canonieke" versie van GCC, is het mogelijk om er meerdere op dezelfde machine te installeren en ertussen te schakelen, net zoals we deden op macOS metxcode-select. Om dit te doen zullen we Linux gebruikenupdate-alternatievencommando. We gaan ervan uit dat we op Ubuntu 18.04 LTS zitten:

gcc --versiegcc 7.5.0

sudo apt-get install gcc-6 g++-6

sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-7 60 --slave /usr/bin/g++ g++ /usr/bin/g++-7sudo update-alternatives --install /usr/ bin/gcc gcc /usr/bin/gcc-6 50 --slave /usr/bin/g++ g++ /usr/bin/g++-6

sudo update-alternatives --set gcc /usr/bin/gcc-6gcc --versiongcc 6.5.0g++ --versiong++ 6.5.0

sudo update-alternatieven --auto gccgcc --versiongcc 7.5.0g++ --versiong++ 7.5.0

5.3. Linux 32-bits

Om 32bit-applicaties vanaf een 64bit Ubuntu-systeem te compileren, is het noodzakelijk om demultilibpakket:

sudo apt-get installeer gcc-multilib

Maar die zijn er momenteelproblemenmet cross-compiling die de GTK+-bibliotheek omvat, dus het zal niet mogelijk zijn om dezelfde machineontwikkeling te gebruiken om op beide architecturen voort te bouwen, net zoals bij Windows. Consoletoepassingen of bibliotheken die geen toegang hebben tot GTK kunnen in 32-bits worden gecompileerd vanaf een 64-bits computer.

Het is niet mogelijk om in 32 bits te compileren vanuit een 64 bit Ubuntu-systeemapplicaties die GTK+3 gebruiken. Hiervoor moet u een 32-bits Linux-systeem gebruiken.

5.4. Linux-ARM

DeARM Geavanceerde RISC-machinearchitectuur is de dominante op de markt voor embedded apparaten zoals smartphones en tablets. Momenteel biedt NAppGUI geen ondersteuning voor de ontwikkeling van mobiele iOS/Android-applicaties, maar wel andere typen borden die "desktop"-versies van Linux ARM ondersteunen, zoals de Raspberry PI. Om onze code naar de Raspberry Pi te porten moeten we dezelfde stappen volgen als in Ubuntu Linux (Figuur 17). Beide distributies zijn gebaseerd op Debian, dus GCC, CMake en Make zijn rechtstreeks beschikbaar viaapt-get.

5.5. Clang op Linux

GCC is de standaardcompiler die wordt geïnstalleerd met debouw-essentieelpakket. We kunnen Clang echter gebruiken als we dat liever hebben. Het eerste dat u moet doen, is de compiler installeren:

sudo apt-get install clangclang --versionclang versie 10.0.0-4ubuntu1

Vervolgens moeten we CMake de compiler vertellen die hij moet gebruiken, met behulp van de variabelenCCEnCXX:

export CC=/usr/bin/clangexport CXX=/usr/bin/clang++cmake -S . -B build -DNAPPGUI_DEMO=NO -DCMAKE_BUILD_TYPE=Releasecmake --build build

Als we terug willen naar GCC, vertrekken weCCEnCXXblanco:

export CC=export CXX=cmake -S . -B build -DNAPPGUI_DEMO=NO -DCMAKE_BUILD_TYPE=Releasecmake --build build

5.6. Ninja op Linux

Op dezelfde manier als in Windows en macOS kunnen we de Ninja-generator gebruiken. De eerste stap is om het te installeren:

sudo apt-get install ninja-buildninja --versie 1.10.1

En we gebruiken het zoals we eerder zagen:

cmake -G Ninja -S . -B build -DNAPPGUI_DEMO=NO -DCMAKE_BUILD_TYPE=Releasecmake --build build

cmake -G "Ninja Multi-Config" -S . -B build -DNAPPGUI_DEMO=NOcmake --build build --config Release

CMake ondersteunt"Ninja Multi-Config"vanaf versie 3.17.

Net als in "Unix Makefiles" kunnen we GCC en Clang gebruiken met Ninja, met behulp van deCCEnCXXvariabelen.

5.7. Eclipse CDT

Door rechtstreeks met de terminal te werken, hebben we grote flexibiliteit bij het configureren van onze eigen tools. Teruggaan naar de console en typencmake --build ./build -j 4zal alles wat je nodig hebt opnieuw compileren. Echter gebruikGDBdirect zal behoorlijk vervelend zijn, dus het gebruik van een geïntegreerde debugger (of IDE) wordt bijna essentieel. Voor de ontwikkeling van NAppGUI maken wij intensief gebruikEclipse CDT. Deze omgeving stelt ons in staat te programmeren met een methodologie die vergelijkbaar is met die van Visual Studio en Xcode: stel breekpunten in, inspecteer de stapel en variabelen, zoek naar bestanden in de codedirectory, meerdere bewerkingen, grootschalige zoekopdrachten, enz.

Het enige verschil is dat we de-G "Eclipse CDT4 - Unix-makefiles"generator in CMake die, naast deMaakbestand, zal de. cprojectEn.projectvereist om het project in Eclipse te importeren.

Open Eclipse en doe hetBestand->Importeren->Bestaande projecten in de werkruimte. Er verschijnt een dialoogvenster waarin we debouwenmap die we hebben geconfigureerd in CMake (/bouwen). Eclipse opent het project, plaatst een boom met alle bestanden aan de linkerkant en we zullen ermee compilerenProject->Alles bouwen. Bij het debuggen (Die in dit geval) zullen we een profiel aanmakenUitvoeren->Debug-configuraties->C/C++-toepassing. Klik[Project zoeken...]en selecteerDood gaanuit de vervolgkeuzelijst. Eindelijk drukken we[Foutopsporing]om de applicatie interactief te debuggen (Figuur 18).

Enkele interessante Eclipse CDT-opties hieronderVenster->Voorkeuren.

• Uitvoeren/Debuggen->Starten->Beëindigen en opnieuw starten tijdens het starten.

Het gebruik van Eclipse is slechts een aanbeveling. U heeft de volledige vrijheid om de tools te gebruiken die u het beste acht.

5.8. Visual Studio-code

Een andere interessante omgeving om op Linux te ontwikkelen is Visual Studio Code. Met de juiste extensies is het mogelijk om op een zeer comfortabele en vloeiende manier in C/C++ te werken met CMake. Om het te installeren:

sudo apt-get installatiecode

We hebben op zijn minst deC/C++-uitbreidingspakketdie ook ondersteuning voor CMake (Figuur 19).

Wij openen ons project metOpen folder. Later voeren we CMake uit vanuit de omgeving zelf:[F1]->CMake:Configureren. De eerste keer zal VSCode vragen naar de locatie van hetCMakeLists.txtvoornaamst (Figuur 20) (/src/CMakeLists.txt).

Na de configuratie kunnen we ermee compileren[F1]->CMake:Build. In deUitvoertabblad van VSCode zullen we de evolutie van het proces zien:

[build] [ 97%] Gebouw C object demo/die/CMakeFiles/Die.dir/resgen/res_die.c.o[build] [ 98%] Gebouwd doel Bode[build] [ 98%] Gebouw C object demo/products/CMakeFiles /Products.dir/products.c.o[build] [ 98%] Gebouwde doelfractals[build] [ 98%] Gebouw C-objectdemo/products/CMakeFiles/Products.dir/prview.c.o[build] [ 99%] CXX koppelen uitvoerbaar ../../Debug/bin/Die[build] [100%] Gebouw C object demo/products/CMakeFiles/Products.dir/resgen/res_products.c.o[build] [100%] Gebouwd doel Die[build] [100%] Koppeling van het uitvoerbare CXX-bestand ../../Debug/bin/Products[build] [100%] Doelproducten gebouwd

Om fouten op te sporen, moet u eerst het doel (of het uitvoerbare bestand) selecteren[F1]->CMake: Stel het foutopsporingsdoel in(Figuur 21).

En we starten de debugger met[F1]->CMake:Debug(Figuur 22).

6. Configuraties

Een NAppGUI-applicatie kan in drie verschillende configuraties worden gecompileerd, afhankelijk van het niveau van foutopsporing dat we nodig hebben.

• Foutopsporing: Bevat foutopsporingsinformatie in de binaire bestanden en voert geen code-optimalisaties uit. Het is de ontwikkelaarsversie.
• Uitgave: Verwijder debug-informatie en voer alle mogelijke optimalisaties uit. Het is de versie voor de gebruiker.
• ReleaseWithAssert: Het is de releaseversie, maar laat deBeweertuitspraken actief. Het is gericht op de eindgebruiker, maar in gevallen waarin het nodig is om gedetailleerde informatie te verkrijgen over mogelijke afwijkingen, ten koste van een afname van de algehele prestaties van het programma.

Zowel Visual Studio als Xcode zijn omgevingen met meerdere configuraties, dat wil zeggen dat we rechtstreeks vanuit de editor zelf tussen de een en de ander kunnen schakelen. In Visual Studio hebben we een vervolgkeuzelijst bovenaan het (Figuur 23) redacteur.

In Xcode is het iets meer verborgen. Wij doenProduct->Schema->Schema bewerken. Er verschijnt een pop-upvenster. SelecteerUitvoeren->Info->Buildconfiguratie(Figuur 24).

Helaas,Unix-merkondersteunt geen meerdere configuraties. Dit dwingt ons om deCMAKE_BUILD_TYPE(Figuur 25) om de configuratie in CMake in te stellen voordat hetMaakbestanden. We moeten opnieuw rennencmake -S ./src -B ./buildals we de configuratie wijzigen, wordt de nieuwe configuratie van kracht.