Sudo apt install build-essentieel
Voor de installatie moet u een wachtwoord invoeren. Wanneer u dit invoert, kan dit de indruk wekken dat er niets gebeurt, maar in feite geeft de terminal de tekens om veiligheidsredenen eenvoudigweg niet weer.

Vervolgens moeten we in de terminal naar de map gaan waar we het bestand met de programmatekst hebben opgeslagen. Het verplaatsen wordt uitgevoerd met het cd-commando (Engels: change directory - change directory). Om de opdracht te gebruiken, schrijft u cd aan het begin en vervolgens, gescheiden door een spatie, het pad waar u naartoe wilt.

Om naar het bureaublad te gaan, is de opdracht als volgt:

Cd ~/Bureaublad\
Let op backslash-karakter\ in de mapnaam Desktop. De backslash ontsnapt aan een spatie en vertelt het cd-commando dat de spatie en de volgende tekens deel uitmaken van de naam. Het ~-symbool aan het begin van het pad geeft het pad aan thuismap gebruiker.

Om de inhoud van een map te bekijken, gebruikt u het ls-commando (afkorting van list).

Het compilatiecommando voor een C-programma ziet er als volgt uit:

Gcc -Wall -o hallo hallo.c
Waar:

• gcc - compiler voor de programmeertaal C;
• -Wall — de sleutel om alle compilerwaarschuwingen weer te geven;
• -o hallo — gebruik de schakeloptie -o om de naam van het uitvoerbestand op te geven;
• hello.c is de naam van ons bronbestand dat we aan het compileren zijn.

Voer ten slotte hallo uit door de programmanaam in te voeren, voorafgegaan door ./ :

./Hallo
Het voorvoegsel / vertelt de terminal dat het programma met de opgegeven naam in de huidige map moet worden uitgevoerd. (De punt is de conventionele naam van de huidige map.)

Het compileren van een C++-programma

#erbij betrekken int main(int argc, char **argv) ( std::cout<< "Hello, World!" << std::endl; return 0; }
We slaan de programmatekst op in een bestand met de naam hello2.cpp. Het compilatiecommando ziet er dus als volgt uit:

G++ -Wall -o hallo2 hallo2.cpp
Om het resultaat uit te voeren, voert u in de terminal het volgende in:

Conclusie

Je kunt meer lezen over programmeren in Ubuntu of een andere Linux-distributie in de boeken:

• Ivanov N. N. - Programmeren in Linux. Handleiding voor zelfstudie. — 2e editie;
• Neil Metieu, Richard Stones - Basisprincipes van programmeren in Linux: Trans. uit het Engels — 4e editie;
• Kolisnichenko DN - Ontwikkeling van Linux-applicaties.

Naam: Programmeren in C++ op Linux.

Het boek "Programmeren in C++ op Linux" is gewijd aan het ontwikkelen van toepassingen in C++ in de KDEvelop-ontwikkelomgeving. De auteur van het boek geeft een gedetailleerde beschrijving van de interacties tussen applicatiecomponenten, behandelt de basisprincipes van het werken met het hulpprogramma Qt Designer en bespreekt bedieningselementen voor dialoogvensters en de klassen waarvoor ze zijn gemaakt. Het boek leert het concept van Document/View, waarbij applicatie-interface-elementen worden gecreëerd. Onderwerpen als het opslaan en herstellen van verschillende informatie die op het scherm wordt weergegeven, het ontwikkelen van teksteditors, het organiseren van multitasking in applicaties op basis van op elkaar inwerkende processen, en het werken met klasse- en functiesjablonen komen ook aan bod. Als conclusie geeft de auteur nuttige aanbevelingen voor het creëren van een helpsysteem voor de ontwikkelde applicatie. Het boek is bedoeld voor professionele programmeurs.

Het boek is gewijd aan het maken van toepassingen geschreven in C++ in de ontwikkelomgeving van KDevelop. Er wordt een beschrijving gegeven van de interactie tussen applicatiecomponenten. We overwegen om met het hulpprogramma Qt Designer te werken en beschrijven de belangrijkste bedieningselementen die in dialoogvensters worden gebruikt, evenals de klassen die zijn gemaakt om ermee te werken. De lezer maakt kennis met het Document/View-concept en leert hoe u elementen van de gebruikersinterface van een applicatie kunt creëren. Daarnaast behandelen afzonderlijke hoofdstukken de kwesties van het weergeven van verschillende informatie op het scherm, het opslaan en herstellen vanuit een bestand, het maken van teksteditors, het werken met klasse- en functiesjablonen en het organiseren van multitasking in een applicatie op basis van op elkaar inwerkende processen. Ten slotte worden aanbevelingen gegeven voor het creëren van een applicatiehulpsysteem.

Inhoud:
Invoering
Voor wie is dit boek bedoeld?
Boek structuur
Conventies die in dit boek zijn aangenomen
Hardware- en softwarevereisten
Hoofdstuk 1 Interactie van applicatiecomponenten
Signalen en ontvangers
Signalen verzenden
Implementatie van ontvangers
Implementatie van de verbinding
Afhandeling van evenementen
Werken met een raam
Werken met inputfocus
Het gebruik van de muis
Het toetsenbord gebruiken
Drag-and-drop implementeren
Gebeurtenisfilters
Synthetische evenementen
Volgorde van gebeurtenisverwerking
Conclusie
Hoofdstuk 2 Dialoogvensters en basisbedieningen
Een gespreksapplicatie maken
Een sjabloontoepassing maken
Een vooraf ingesteld dialoogvenster maken
Het maken van de conversatietoepassing voltooien
Aangepaste dialoogvensters maken
Een dialoogvenster met tabbladen maken
Een wizard maken
Hoofdstuk 3 Controle klassen
Lijst klasse
Klassen van lineaire regelaar en lineaire indicator
Werken met datum en tijd
Hoofdstuk 4 Toepassings-, document- en weergaveklassen
Qt-applicatie met meerdere vensters
Documentklasse
Presentatie klasse
Toepassingsklasse
KDE-toepassing met meerdere vensters
Documentklasse
Presentatie klasse
Toepassingsklasse
Hoofdstuk 5 Gebruikersinterface-elementen maken
Qt-bibliotheek gebruikersinterface
Wijzigingen aanbrengen in het menu
Werken met de statusbalk
Gebruikersinterface van KDE-toepassingen
Wijzigingen aanbrengen in het menu
De werkbalk aanpassen
Werken met de statusbalk
Hoofdstuk 6 Informatie weergeven op het scherm
Figuren tekenen
Werken met een penseel
Een venster opnieuw tekenen
Weergaveobjecten synchroniseren
Tekstuitvoer
Werken met bitmaps
Apparaatafhankelijke bitmaps
Hardware-onafhankelijke bitimages
Hoofdstuk 1 Werken met documentbestanden
Informatie opslaan en herstellen in de applicatie
Dialoogvensters aanpassen
Wijzigingen aanbrengen in het menu
De werkmap instellen
Hoofdstuk 8 Werken met tekstdocumenten
Een eenvoudige teksteditor maken
Een complexere editor maken
De KDE-editor maken
Hoofdstuk 9 Verzamelingssjablonen en klassen
Sjablonen
Sjabloonconcept
Functiesjablonen
Klassensjablonen
Verzamelklassen
Soorten verzamelklassen
Arrays
Gekoppelde lijsten
Kaarten
Andere verzamelklassen
Hoofdstuk 10 Multitasking implementeren in een applicatie
Procesinteractie
Een client maken voor een eenvoudige server
Een complexere server creëren
Een klant aanmaken
Enkele opmerkingen
Hoofdstuk 11 Hulp in de app
Formulieren voor het indienen van referentie-informatie
Manieren om toegang te krijgen tot hulp
Methoden voor het presenteren van referentie-informatie
Formulieren voor het indienen van informatie
Hulp bij programmeercontext
Suggesties weergeven
Help-informatie weergeven in de statusbalk
Informatie verkrijgen over een specifiek element
gebruikersinterface
Commando Help Programmeren
Qt Applicatieopdracht Help-bestandsindeling
Een demo Qt-applicatie maken
Bijlage 1 Wat staat er op de cd
Bijlage 2 Internetbronnen
Onderwerpindex

Download het e-book gratis in een handig formaat, bekijk en lees:
Download het boek Programmeren in C++ op Linux - Nikolay Sekunov - fileskachat.com, snel en gratis downloaden.

Pdf downloaden
Hieronder kunt u dit boek tegen de beste prijs met korting kopen met bezorging in heel Rusland.

Hallo allemaal! Dit is het eerste artikel over C-programmeren, waarin we een testeditor zullen opzetten en iets zullen leren over de geschiedenis van de C-taal, de mogelijkheden, de voor- en nadelen.

De C-taal bestaat in 2012 40 jaar. C werd de grondlegger van C++, Java, Perl, C#, JavaScript, enz. Het is de populairste programmeertaal ter wereld. C is een procedurele programmeertaal. Codebestanden hebben de extensie .c en headerbestanden .h. In C kun je programmeren voor Linux, Windows, Windows Phone, Mac OS, iOS, Android, etc. Elke programmeur moet bekwaam zijn in de programmeertaal C. Om programmeur te worden is het lezen van boeken en artikelen alleen niet voldoende. Je moet ook oefenen. Daarom zullen we onze lessen herhalen met voorbeelden. Als u vragen heeft, kunt u deze stellen in de opmerkingen. Deze handleiding kan ook worden gebruikt door Windows- en Mac OS-gebruikers. Gebruikers van andere besturingssystemen kunnen bijvoorbeeld NetBeans als compiler gebruiken (NetBeans ondersteunt niet alleen C maar ook Java, PHP, C++, Python en Ruby)

Instellingen

Om te kunnen programmeren heb je een teksteditor (gedit) en een compiler (gcc - meegeleverd met Ubuntu) nodig. Het is niet nodig om de compiler te configureren, maar we zullen nu de teksteditor configureren.

Open Bewerking -> Instellingen. Vink de volgende vakjes aan:

• Toon regelnummers;
• Markeer de huidige regel;
• Markeer gepaarde haakjes;
• U kunt het thema ook wijzigen op het tabblad Lettertypen en kleuren.

Een paar "shenanigans" met gedit zullen het gemakkelijker maken om met een teksteditor te werken. En in de toekomst zullen we kijken naar een soort IDE (integratie-ontwikkelomgeving).

Zandbak

C++-opleiding. Wat als je op Linux begint?

Het kookt!

Gezien de mode van het programmeervak ​​en een zekere romantiek in de hoofden van jonge mensen, geïnspireerd door Hollywood-films, gaan mensen naar universiteiten en worden ze geconfronteerd met een aantal moeilijkheden: hun hoofden beginnen zich scherp uit te breiden, wat onvermijdelijk eerst leidt tot vermoeidheid en vervolgens tot teleurstelling in hun keuze. Het feit blijft: als je jezelf associeert met een beroep dat constante zelfverbetering vereist, begin hier dan al mee voordat je eraan begint. Er zijn veel materialen die je zullen helpen beter voorbereid te zijn tijdens je studie en waarmee je in het 3e tot 4e studiejaar een baan in je specialiteit kunt vinden. Beweging!

Tegen de achtergrond van een dergelijke redenering kwam iemand naar mij toe om een ​​korte tutorial te maken over het schrijven, compileren en uitvoeren van een programma in C++ op Linux zonder speciale tools (IDE). Deze aanpak zal een beginnende programmeur kennis kunnen laten maken met het ontwikkelingsproces in de meest triviale vorm, evenals met het Linux-besturingssysteem, dat fundamenteel nieuw voor hem is. Aan het einde van mijn habrapost zal ik een lijst met referenties en nuttige links schrijven.

Laten we beginnen met wat we nodig hebben:
-Linux-distributie (laten we Ubuntu nemen);
-G++-compiler geïnstalleerd;
-Reguliere teksteditor (gedit);
-Terminal;

Laten we gaan!

1. Installatie van Linux en benodigde software.

2. Maak een cpp-bestand.

#erbij betrekken naamruimte std gebruiken; int main())( cout<< "Hello world!"; return 0; }

Sluiten en opslaan.

3. Compilatie en lancering.

P.S. Als ten minste één student doet wat ik heb geschreven, beschouw ik mijn missie als voltooid. Het allerbeste!
P.S.S. Koppelingen.

Alle computerprogramma's zijn een reeks processorinstructies die uit een specifieke reeks bits bestaan. Er zijn enkele honderden van deze opdrachten en met behulp hiervan worden alle acties op uw computer uitgevoerd. Maar programma's rechtstreeks schrijven met behulp van deze commando's is moeilijk. Daarom zijn er verschillende programmeertalen uitgevonden die voor mensen gemakkelijker te begrijpen zijn.

Om een ​​programma gereed te maken voor uitvoering, assembleert een speciaal programma het vanuit de broncode in een programmeertaal tot machinecode-processorinstructies. Dit proces wordt compilatie genoemd. Linux is vrije software en daarom zijn de broncodes van de programma's voor iedereen beschikbaar. Als het programma niet in de repository staat of als u iets niet-standaard wilt doen, kunt u het programma compileren.

In dit artikel zullen we bekijken hoe Linux-programma's worden gecompileerd, hoe het compilatieproces werkt en ook hoe flexibel je alles kunt configureren.

Wij compileren programma's geschreven in C of C++, omdat dit de meest gebruikte taal is voor programma's die compilatie vereisen. We hebben dit onderwerp al een beetje bekeken in het artikel installatie van tar.gz in Linux, maar dat artikel is meer gericht op beginners die het niet zozeer hoeven uit te zoeken, maar eerder een kant-en-klaar programma nodig hebben.

In hetzelfde artikel wordt het onderwerp in meer detail besproken. Zoals u zich kunt voorstellen, is er speciale software nodig om de broncode om te zetten in processoropdrachten. We zullen de GCC-compiler gebruiken. Om het en alle benodigde tools op Ubuntu te installeren, voer je het volgende uit:

sudo apt install build-essential manpages-dev git automake autoconf

Vervolgens kunt u de juiste installatie- en compilerversie controleren:

Maar laten we, voordat we verder gaan met de programmacompilatie zelf, de componenten van dit proces in meer detail bekijken.

Hoe gebeurt het compileren?

Het compileren van een Linux-programma is een vrij complex proces. Het is zelfs nog ingewikkelder omdat de programmacode niet in één bestand of zelfs in alle bronbestanden aanwezig is. Elk programma gebruikt veel systeembibliotheken die standaardfuncties bevatten. Bovendien moet dezelfde code werken op verschillende systemen die verschillende versies van de bibliotheken bevatten.

In de eerste fase, zelfs voordat het compileren begint, moet een speciaal hulpmiddel controleren of uw systeem compatibel is met het programma en of alle benodigde bibliotheken beschikbaar zijn. Als er iets ontbreekt, wordt er een fout gegenereerd en moet u het probleem oplossen.

Vervolgens komt het parseren en converteren van de broncode naar objectcode; deze fase zou achterwege kunnen blijven, maar dit is nodig zodat de compiler verschillende optimalisaties kan uitvoeren, de omvang van het uiteindelijke programma kleiner kan maken en processoropdrachten efficiënter kan maken.

Vervolgens worden alle objectbestanden in één programma verzameld en aan systeembibliotheken gekoppeld. Na het voltooien van deze fase hoeft u alleen nog maar het programma in het bestandssysteem te installeren en dat is alles. Dit zijn de belangrijkste fasen van het samenstellen van programma's, en laten we nu dichter bij de praktijk komen.

Linux-programma's compileren

Het eerste dat we nodig hebben is de broncode van het programma zelf. In dit voorbeeld bouwen we de nieuwste versie van vim. Dit is een volledig neutraal programma, vrij eenvoudig en nuttig voor iedereen, dus het is perfect als voorbeeld.

Bronnen verkrijgen

Het eerste dat we nodig hebben is de broncode van het programma, die te vinden is op GitHub. Je kunt bronnen voor de meeste Linux-programma's vinden op GitHub. Daarnaast zijn er montage-instructies:

Laten we de bronnen van ons programma downloaden met behulp van het git-hulpprogramma:

git-kloon https://github.com/vim/vim

Je zou het archief ook op de website kunnen downloaden en vervolgens uitpakken in de gewenste map, maar dit zou handiger zijn. Het hulpprogramma maakt een map met de naam van het programma, we moeten het laten werken:

Configureren instellen

Vervolgens moeten we een script uitvoeren dat ons programma controleert op compatibiliteit met het systeem en de compilatieparameters configureert. Het heet configureren en wordt samen met de broncode door de programmaontwikkelaars geleverd. Het hele compilatieproces wordt beschreven in de Makefile, die door dit hulpprogramma wordt gemaakt.

Als configure niet in de bronmap staat, kunt u proberen de volgende scripts uit te voeren om deze te maken:

./bootstrap
$ ./autogen.sh

U kunt ook het automake-hulpprogramma gebruiken om dit script te maken:

aclocaal
$autoheader
$ automake --gnu --add-missing --copy --foreign
$ autoconf -f -Wall

Het automake-hulpprogramma en andere in zijn suite genereren de benodigde bestanden op basis van het Mackefile.am-bestand. Dit bestand is vereist bij de meeste projecten.

Nadat u de configuratie heeft geconfigureerd, kunnen we verdergaan met de configuratie. Een van de grote voordelen van het handmatig samenstellen van programma's is dat u kunt kiezen met welke opties u het programma wilt bouwen, waar het zich zal bevinden en welke extra functies moeten worden opgenomen. Dit alles wordt geconfigureerd met behulp van configure. De volledige set opties kan worden bekeken door het volgende uit te voeren:

./configure --help

Laten we eens kijken naar de meest gebruikte opties die standaard zijn voor alle programma's:

• --prefix=VOORVORM- de map voor het installeren van het programma, in plaats van /, deze kan bijvoorbeeld /usr/local/ zijn, dan worden alle bestanden niet langs het hoofdbestandssysteem gedistribueerd, maar in /usr/local;
• --bindir=DIR- de map voor het plaatsen van uitvoerbare bestanden moet in PREFIX staan;
• --libdir=DIR- standaardmap voor het plaatsen en zoeken van bibliotheken, ook in PREFIX;
• --includedir=DIR- map voor het plaatsen van manpagina's;
• --disable-functie- schakel deze functie uit;
• --enable-functie- schakel de functie in;
• --met-bibliotheek- activeert, net als enable, het opgegeven bibliotheek- of headerbestand;
• --zonder-bibliotheek- deze uitschakeling schakelt het gebruik van de bibliotheek uit.

U kunt configureren uitvoeren zonder opties om de standaardwaarden te gebruiken, maar u kunt ook handmatig de gewenste paden opgeven. In ons geval is ./configure aanwezig en kunnen we het gebruiken:

Tijdens de installatie controleert het hulpprogramma of alle vereiste bibliotheken op het systeem aanwezig zijn. Als dat niet het geval is, moet u deze installeren of deze functie indien mogelijk uitschakelen. De volgende fout kan bijvoorbeeld optreden: geen terminalbibliotheek gevonden bij het controleren op tgetent()... configure: fout: NIET GEVONDEN!

In dit geval moeten we de vereiste bibliotheek installeren. Het programma biedt bijvoorbeeld ncurses, dus plaatsen we:

sudo apt install libncurces-dev

Het lib-voorvoegsel wordt altijd toegevoegd vóór bibliotheken, en -dev betekent dat we een bibliotheek nodig hebben met alle headerbestanden. Zodra aan alle afhankelijkheden is voldaan, zal de installatie succesvol zijn.

Het programma bouwen

Zodra de installatie is voltooid en de Makefile gereed is, kunt u direct doorgaan met het bouwen van het programma. In dit stadium wordt de broncode direct omgezet in machinecode. Het make-hulpprogramma op basis van de Makefile zal alle noodzakelijke acties uitvoeren:

Hierna wordt het programma in de door u opgegeven map geïnstalleerd en kunt u er gebruik van maken. Maar de correctere manier is om een ​​pakket te maken om het programma te installeren. Dit gebeurt met behulp van het checkinstall-hulpprogramma, waarmee u zowel deb- als rpm-pakketten kunt maken, zodat het niet alleen in Ubuntu kan worden gebruikt. In plaats van make install voer je het volgende uit:

Installeer vervolgens eenvoudigweg het resulterende pakket met behulp van dpkg:

sudo dpkg installeer vim.deb

Hierna is de programmamontage volledig voltooid en geïnstalleerd, zodat u over kunt gaan tot volledig gebruik.

Als u het programma hebt geïnstalleerd met make install, kunt u het verwijderen door de omgekeerde opdracht in dezelfde map uit te voeren:

sudo make-installatie verwijderen

Met deze opdracht worden alle bestanden verwijderd die naar het bestandssysteem zijn gekopieerd.

Conclusies

In dit artikel hebben we gekeken hoe een Linux-programma wordt samengesteld. Dit proces kan moeilijk zijn voor beginners, maar over het algemeen is alles mogelijk als je een paar uur besteedt aan het oplossen van het probleem. Als je vragen hebt, stel ze dan in de reacties!

Ter afsluiting van de video over wat een compiler en tolk zijn: