Scrivere programmi console su c linux. Programmazione Linux. Come funziona la compilazione

È diventato chiaro che l'argomento è molto rilevante. Sono stati presi in considerazione alcuni errori e domande, di conseguenza si è deciso di tenere una seconda master class. Aggiunto e corretto!

Programmazione di master class in C sotto Linux. Studiamo l'API principale.

Questo tutorial è rivolto a persone che vogliono imparare l'API *nix di sistemi operativi simili, in particolare sotto Linux. Qui considereremo le caratteristiche dello sviluppo sotto il sistema operativo Linux, che includono:

• Familiarizzazione con il processo di creazione del software e le specifiche del compilatore C di GCC


• Sviluppo e utilizzo di librerie condivise


• Programmi di debug


• Esplorazione dei meccanismi di I/O di file di basso livello


• Studio dei meccanismi per garantire la comunicazione multitasking e interprocesso


• Utilizzo di file e socket di rete


• Studio e applicazione del meccanismo dei segnali


• Lo studio dei processi, i thread, la loro differenza, l'uso del multithreading, lo studio dei meccanismi di sincronizzazione dei thread e le loro problematiche


• Creare demoni, imparare la differenza tra demoni e software applicativo


• Esplorazione delle funzionalità di I/O della console


• File mappati in memoria e come usarli

Requisiti per i partecipanti alla master class: Conoscenza della lingua C, a livello del libro B.V. Kernighan, DM Ritchie "LINGUA C".

Il costo di questa master class sarà di 6.000 rubli.

La sede è la città di Mosca, nei locali di Hackspace Neuron.
Date: dal 4 luglio (lunedì) al 7 luglio (giovedì) circa dalle 10:00 alle 17:00 con pausa pranzo e pause tè/caffè.

Non è prevista la trasmissione online.
Numero di persone nel gruppo: 8-10.

La registrazione avviene tramite e-mail. [email protetta] o commenta questo post. Il tuo nome completo è richiesto per la registrazione. (per intero) e recapiti (numero di telefono e mail). È auspicabile descrivere lo scopo di frequentare questa master class, il livello di formazione e occupazione.

Programma dettagliato del corso:

Modulo 1: Introduzione

• Familiarizzazione con le specifiche della creazione di software in GNU/Linux


• Familiarizzazione con gli editor di testo della console (vi, nano, mcedit)


• Lavorare con il debugger gdb


• Assemblaggio software manuale e automatico (Makefile)


• Modello Client-Interface-Server (CIS).


• Edificio statico della biblioteca


• Biblioteche condivise


• Lavorare con le variabili d'ambiente

• Panoramica dei meccanismi di I/O Linux (Ubuntu)


• Descrittori di file


• Chiamate di sistema: apri, chiudi, scrivi, leggi e cerca


• Tipi di file


• Inode e hard link


• Permessi sui file


• file system proc


• Due modi per leggere il contenuto di una directory


• File sparsi e specifiche del loro utilizzo


• Blocco delle aree di un file

• Meccanismi di comunicazione interprocesso Linux (Ubuntu)


• Tubi senza nome (tubi)


• Tubi con nome


• Messaggi (coda di messaggi)


• Memoria condivisa


• Semafori

• Socket in uno spazio dei nomi di file (socket UNIX)


• Coppia prese


• Prese di rete (prese)

• Introduzione ai segnali


• Come i segnali differiscono da altri meccanismi di comunicazione tra processi


• Specifiche di gestione del segnale


• Modulo 6


• Processi di clonazione - fork()


• Sostituzione di un processo in esecuzione - exec()


• Zombie (zombie): cause e modi per eliminarli

• Fili e processi


• Le specifiche della creazione di applicazioni multithread (multithreading)


• Chiusura anticipata di un thread

• Creare un gestore di terminazione del thread


• Sincronizza le primitive


• Attributi del flusso

• La differenza tra un demone e un'utilità della console


• Specifiche di sviluppo dei demoni


• Creazione di un demone tramite socket di rete

• Specifiche dello sviluppo di applicazioni console


• Impedire il reindirizzamento dell'output


• Gestione del terminale


• Nascondere la password dell'utente durante l'autenticazione


• Controllo terminale con sequenze ESC

• Visualizzazione di un file normale


• Condivisione di un file


• Esposizioni private


• Altri usi di mmap

• Specifiche dello sviluppo di applicazioni a 64 bit


• Utilizzo della libreria ncurses

C è un linguaggio di programmazione abbastanza "antico", si è formato nei primi anni '70. Nonostante ciò, il C è una lingua viva, nel senso che oggi viene utilizzato attivamente. È stato concepito, utilizzato ed è utilizzato per scrivere parti essenziali del codice del programma di sistemi operativi simili a Unix. Su di esso vengono scritti anche programmi di utilità, compilatori e, meno spesso, programmi applicativi. Pertanto, C è chiamato linguaggio di programmazione del sistema.

La sua sopravvivenza può essere spiegata dal fatto che i principi di funzionamento dei sistemi operativi sono relativamente universali, non sono soggetti al progresso e alla diversità che si può osservare nell'ambiente del software desktop e mobile, delle applicazioni Web. Il C non è un linguaggio di livello sufficientemente alto, è più vicino all'architettura del computer. Di conseguenza, i programmi C sono compatti e veloci.

C non supporta la programmazione orientata agli oggetti. Il supporto OOP è implementato in C++. Sebbene quest'ultimo si sia evoluto dal linguaggio C, non è un "sequel" di esso, ma un linguaggio separato che può essere appreso senza conoscere il C. Tuttavia, imparare il C è utile prima di conoscere il suo "fratellino avanzato", perché la sintassi dei linguaggi è simile, il C non sovraccarica di superpoteri il cervello di un programmatore alle prime armi e insegna loro a capire l'essenza di ciò che sta accadendo.

C va bene per una prima introduzione alla programmazione? Se non stai studiando in un'università in una specialità relativa all'informatica, allora no. C implica la comprensione dell'organizzazione e dei principi di funzionamento dell'hardware, in particolare della memoria. Molto di questo viene fatto con i puntatori, giocano un ruolo chiave; questo argomento è abbastanza difficile da capire e di solito non viene studiato a scuola.

Naturalmente, con C, puoi imparare le basi della programmazione senza conoscere i puntatori. Tuttavia, una persona penserà di conoscere C, sapendo poco di per sé. Il linguaggio C è stato creato da programmatori professionisti esperti di hardware per scrivere il sistema operativo UNIX. Non era inteso come lingua per insegnare ai principianti.

Ambienti e compilatori per la programmazione in C

Se stai usando una delle distribuzioni GNU/Linux, qualsiasi editor di testo con l'evidenziazione della sintassi andrà bene e avrai anche bisogno di GCC e di un terminale.

Esistono editor per programmatori che includono vari componenti aggiuntivi, inclusi un terminale, la navigazione di directory e altri, ad esempio Geany o Atom.

C è un linguaggio di programmazione compilato. GNU/Linux utilizza GCC per ottenere file eseguibili, un insieme di compilatori, incluso un compilatore per C. Per ottenere un file eseguibile da un file sorgente (di solito a tali file viene assegnata l'estensione *.c), è necessario eseguire un comando in il terminale che assomiglia a questo:

gcc -o ciao ciao.c

Dove gcc è un comando che avvia un programma che esegue la compilazione e altre azioni; -o è una chiave che indica che stiamo specificando manualmente il nome del file eseguibile; ciao è il nome del file eseguibile risultante; hello.c è il nome del file del codice sorgente. Il nome del file eseguibile può essere omesso:

gcc ciao.c

In questo caso, l'eseguibile avrà il nome predefinito a.out.

Windows ha il suo set di compilatori: MinGW. Può essere utilizzato da solo, ma viene fornito con un semplice ambiente di sviluppo Dev-C++, che può essere una buona scelta per imparare a programmare in C e C++.

Durante il salvataggio, selezionare il tipo di file "File sorgente C (*.c)". La compilazione e l'esecuzione del programma avviene premendo il tasto F9. Dopo l'esecuzione, il programma si chiude immediatamente e il risultato non è visibile. Per evitare che ciò accada, vengono scritte due righe aggiuntive: #include e getch(). (Forse questo non è rilevante per una versione più recente di Dev-C++.)

"Hello World" in GNU/Linux:

#includere \n") ; }

"Hello World" su Windows:

#includere #includere int main() ( printf("Hello World \n") ; getch(); )

D'altra parte, esiste un gran numero di ambienti di sviluppo multipiattaforma. Ad esempio, modulo Eclipse + CDT, KDevelop, CLion. Quest'ultimo è a pagamento, prodotto da JetBrains, leader nello sviluppo di IDE, ma ha un periodo di prova di 30 giorni, che potrebbe essere sufficiente per l'apprendimento. CLion è più conveniente di altri IDE.

"Ciao mondo" in C

Prendendo come esempio il programma più semplice, notiamo subito alcune caratteristiche del linguaggio di programmazione C.

Nel linguaggio C, la funzione main() assume il ruolo di ramo principale del programma. Questa funzione deve essere sempre presente in un programma C completo e da esso parte l'esecuzione del programma. Tuttavia, le variabili dichiarate al suo interno non sono globali, il loro ambito si estende solo a main(). Tuttavia, nel linguaggio di programmazione C, quasi tutto il codice del programma è contenuto in una funzione e la funzione main() è la funzione principale e obbligatoria.

Per impostazione predefinita, la funzione main() restituisce un tipo di dati int, quindi non è necessario specificare il tipo di dati di ritorno. Tuttavia, il compilatore emette un avviso in questo caso.

La funzione printf() serve per l'output dei dati. Il suo scopo è simile alla procedura write() in Pascal e alla funzione print() in Python. La funzione printf() non si interrompe su una nuova riga dopo l'output. Pertanto, per saltare viene utilizzato un carattere speciale, indicato dalla combinazione \n. Le espressioni C complete sono separate da punto e virgola.

In C, le funzioni I/O non fanno parte del linguaggio. Ad esempio, in Python non è necessario importare alcun modulo per utilizzare le funzioni print() e input(). In C, non possiamo semplicemente chiamare la funzione printf(), perché semplicemente non esiste in C stesso. Questa funzione, così come molte altre, può essere inclusa utilizzando il file di intestazione stdio.h. A tale scopo, all'inizio del programma, la riga #includere . Include è tradotto dall'inglese come "include" e stdio è l'abbreviazione di "standard input-output (input-output)".

I file di intestazione (che terminano con *.h) di solito contengono dichiarazioni di determinate funzioni. Una dichiarazione è semplicemente una descrizione di una funzione: quali parametri prende e cosa restituisce. Il codice della funzione stesso (definizione) non si trova nel file di intestazione, ma nelle librerie (altri file) che potrebbero essere già compilate e che si trovano nelle directory di sistema. Prima di compilare il programma, viene avviato il preprocessore C. Tra le altre cose, include il contenuto dei file di intestazione specificati nel file di programma all'inizio del file di programma.

Lavoro pratico

Commenta la prima riga del codice del programma HelloWorld. Prova a compilare il programma. Sei riuscito a ottenere l'eseguibile? Quale avviso ha emesso il compilatore?

1 // - commento a riga singola in linguaggio C; /* … */ - commento su più righe in linguaggio C.

Molti programmatori principianti hanno paura
programmazione linux - nessuna semplicità di Windows
e visibilità. Tuttavia, per Linux c'è
molti ausili visivi
programmazione, e non è solo un clone Delphi.
Naturalmente, non possono diventare completi
un sostituto per lo stesso Visual Studio, ma abbastanza
contribuire ad accelerare il processo di sviluppo
programmi.

NetBean

Uno dei migliori IDE. Destinato
lavora con Java, con il suo aiuto puoi
sviluppare non solo multipiattaforma
Programmi Java, ma anche applicazioni web, servizi web e
client per loro, programmi J2ME, ecc. Forse
funziona su Windows, Linux, MacOS. L'IDE può essere esteso
vari plugin e componenti aggiuntivi che puoi
trovare sul sito. Allo stesso tempo, tutto è gratuito, quindi
mangia gratis! In generale - un numero indiscutibile
uno.

Designer QT/KDevelop

Un altro potente ambiente di sviluppo per
Piattaforma KDE e Gnome. C++ multipiattaforma
le applicazioni vanno solo in un modo. Per
programmi Qt non commerciali possono
usa gratis, esiste
per quasi tutte le distribuzioni.

Clone di Visual Basic, e non solo nel design,
ma anche nelle costruzioni del linguaggio. Ideale
strumento per i programmatori VB che lo desiderano
passare a Linux. Interfaccia semplice e intuitiva.
Accesso a tutti i principali database - MySQL,
PostgreSQL ecc. Funziona su quasi tutti
distribuzioni.

Editor WYSIWYG per la creazione di pagine web. In
molto simile all'editor di Macromedia o altro
lo stesso FrontPage. Supporta automatico
lavorare con il sito tramite FTP.

Python e Ruby IDE che fa
programmazione in un linguaggio abbastanza semplice
ed eccitante. Scritto in proprio
Pitone.

Eclipse non è affatto un IDE, ma un'intera piattaforma per
varie applicazioni. a norma
la consegna include plug-in aggiuntivi per
Supporto e sviluppo del linguaggio Java (JDT).
plugin per Eclipse (PDE - Plugin Development Environment). Per
dovrebbe essere il lavoro con altre lingue
plugin speciali installati - in Eclipse
può funzionare su quasi tutti
linguaggio di programmazione accessibile. Altro
vantaggio vale anche per
estensibilità: quantità gigantesca
utility (soprattutto per Java) ora
disponibile anche come plugin per Eclipse,
ad esempio Ant, JavaDoc, JUnit, JDepend, Check Style, Subversion.
Quindi non dobbiamo arrenderci
il loro sistema di controllo della versione, dal loro
controllori della qualità del codice, ecc.
Il terzo vantaggio è che lo è Eclipse
ambiente multipiattaforma, cioè
Ci sono versioni per vari
sistemi operativi (che non possono
permettersi lo stesso Visual Studio).

Sviluppatore J

Piattaforma di Oracle - non open source,
tuttavia è ancora gratuito. Come è chiaro da
i nomi sono ancora utilizzati dalla stessa multipiattaforma
Giava. Utilizza Sun JDK per l'esecuzione, quindi
Oracle non rivendica il creato
i programmi in teoria non avranno.

E infine, l'ambiente di controllo visivo
progetti per Gnome Desktop. Non meno utile
programma per programmatori rispetto a IDE.

Gli strumenti tradizionalmente utilizzati per scrivere programmi per sistemi operativi aperti sono gli strumenti di sviluppo GNU. Facciamo un piccolo retroscena storico. Il progetto GNU è stato fondato nel 1984 da Richard Stallman. La sua necessità era dovuta al fatto che a quel tempo la cooperazione tra i programmatori era difficile, poiché i proprietari di software commerciali ponevano numerosi ostacoli a tale cooperazione. L'obiettivo del progetto GNU era creare un insieme di software con un'unica licenza che non permettesse a nessuno di assegnare diritti esclusivi su questo software. Parte di questo kit è il toolkit per sviluppatori che utilizzeremo, che dovrebbe essere incluso in tutte le distribuzioni Linux.

Uno di questi strumenti è il compilatore GCC. Questo acronimo originariamente stava per GNU C Compiler. Ora significa - GNU Compiler Collection.

Creiamo il primo programma usando GCC. Per tradizione, il primo programma stamperà semplicemente il saluto "Hello world!" - "Ciao mondo!".

I file di codice sorgente per i programmi che creeremo sono file di testo semplice e possono essere creati utilizzando qualsiasi editor di testo (ad esempio GEdit KWrite, Kate e gli utenti Linux più tradizionali vi ed emacs). Oltre agli editor di testo, esistono ambienti di sviluppo specializzati con i propri editor integrati. Uno di questi strumenti è KDevelop. È interessante notare che ha un editor integrato e una console integrata situata proprio sotto l'editor. Quindi puoi direttamente in un programma, senza passare da una finestra all'altra, modificare il codice e dare comandi alla console.

Crea una directory ciao separata. Questa sarà la nostra prima directory di progetto. In esso, crea un file di testo hello.c con il seguente testo:

#includere

printf("Ciao mondo!\n");

Quindi nella console vai alla directory del progetto. Componi una squadra

Ora guarda da vicino cosa è successo. Nella directory è apparso un nuovo file a.out. Questo è il file eseguibile. Lanciamolo. Digita nella console:

Il programma dovrebbe avviarsi, ovvero dovrebbe apparire il testo:

Il compilatore gcc assegna il nome a.out a tutti gli eseguibili generati per impostazione predefinita. Se vuoi dargli un nome diverso, devi aggiungere il flag -o e il nome che vuoi assegnargli al comando di compilazione. Digitiamo il seguente comando:

gcc ciao.c -o ciao

Vediamo che un file eseguibile chiamato hello è apparso nella directory. Lanciamolo.

Come puoi vedere, il risultato è esattamente lo stesso file eseguibile, solo con un nome conveniente per noi.

Il flag -o è solo uno dei tanti flag del compilatore gcc. Alcuni altri flag verranno discussi in seguito. Puoi usare il sistema di aiuto di man per vedere tutti i possibili flag. Digita nella riga di comando:

Ti verrà presentato un sistema di aiuto per questo programma. Esamina cosa significa ogni bandiera. Presto ne incontreremo alcuni. Si esce dalla guida con il tasto q.

Ovviamente, hai notato che quando eseguiamo un programma dalla nostra directory di sviluppo, digitiamo un punto e una barra prima del nome del file. Perché stiamo facendo questo?

Il fatto è che se digitiamo solo il nome del file eseguibile, il sistema operativo lo cercherà nelle directory /usr/bin e /usr/local/bin e, ovviamente, non lo troverà. Le directory /usr/bin e /usr/local/bin sono le directory di sistema in cui si trovano i programmi eseguibili. Il primo è progettato per ospitare versioni stabili di programmi, solitamente inclusi in una distribuzione Linux. Il secondo è per i programmi installati dall'utente stesso (per la stabilità di cui nessuno garantisce). Un tale sistema è necessario per separarli l'uno dall'altro. Per impostazione predefinita, i programmi vengono installati nella directory /usr/local/bin quando vengono compilati. È altamente indesiderabile inserire qualcosa in più in /usr/bin o eliminare qualcosa da lì manualmente, perché ciò può portare a un arresto anomalo del sistema. Dovrebbero essere inseriti programmi, per la stabilità di cui sono responsabili gli sviluppatori della distribuzione.

Per eseguire un programma che si trova altrove, devi specificarne il percorso completo, in questo modo:

/home/dima/progetti/ciao/ciao

Oppure un'altra opzione: scrivi il percorso relativo alla directory corrente in cui ti trovi attualmente nella console. In questo caso, un punto indica la directory corrente, due punti: il genitore. Ad esempio, il comando ./hello esegue il programma hello che si trova nella directory corrente, il comando ../hello esegue il programma hello che si trova nella directory principale, il comando ./projects/hello/hello esegue il programma nelle sottodirectory che si trovano all'interno la directory corrente.

È possibile aggiungere directory aggiuntive all'elenco dei percorsi di sistema dei programmi. Per fare ciò, aggiungi un nuovo percorso alla variabile di sistema PATH. Ma per ora non divaghiamo dall'argomento principale. Le variabili di ambiente sono una conversazione separata.

Ora diamo un'occhiata a cosa fa il programma gcc. Il suo lavoro comprende tre fasi: preelaborazione, compilazione e collegamento (o collegamento).

Il preprocessore include il contenuto di tutti i file di intestazione specificati nelle direttive #include nel file principale. I file di intestazione di solito contengono dichiarazioni di funzioni utilizzate nel programma, ma non definite nel testo del programma. Le loro definizioni sono da qualche altra parte: in altri file sorgente o in librerie binarie.

La seconda fase è la compilazione. Consiste nel trasformare il testo del programma in linguaggio C/C++ in un insieme di istruzioni macchina. Il risultato viene memorizzato in un file oggetto. Naturalmente, su macchine con diverse architetture di processore, i binari si ottengono in formati diversi e su una macchina è impossibile eseguire un binario costruito su un'altra macchina (a meno che non abbiano la stessa architettura di processore e gli stessi sistemi operativi). Ecco perché i programmi per sistemi simili a UNIX sono distribuiti come codici sorgente: dovrebbero essere disponibili per tutti gli utenti, indipendentemente da chi ha quale processore e quale sistema operativo.

L'ultima fase è il layout. Consiste nel collegare tutti i file oggetto in un progetto in uno, collegare le chiamate di funzione alle loro definizioni e allegare file di libreria contenenti funzioni che sono chiamate ma non definite nel progetto. Di conseguenza, viene formato un file eseguibile, il nostro obiettivo finale. Se una funzione viene utilizzata in un programma, ma il linker non trova la posizione in cui questa funzione è definita, emetterà un messaggio di errore e rifiuterà di creare un file eseguibile.

Ora vediamo come appare tutto in pratica. Scriviamo un altro programma. Sarà la calcolatrice più primitiva in grado di aggiungere, sottrarre, moltiplicare e dividere. Una volta lanciato, chiederà a turno due numeri su cui operare, quindi richiederà di inserire il segno dell'operazione aritmetica. Può essere composto da quattro caratteri: "+", "-", "*", "/". Dopodiché, il programma mostra il risultato e si ferma (ci riporta al sistema operativo, o meglio, all'interprete dei comandi da cui abbiamo chiamato il programma).

Creiamo una nuova cartella kalkul per il progetto e creiamo il file kalkul.c al suo interno.

#includere

printf("Primo numero: ");

scanf("%f",&num1);

printf("Secondo numero: ");

scanf("%f",&num2);

printf(" Operatore (+ - * /): ");

mentre ((op = getchar()) != EOF)

printf("%6.2f\n",num1 + num2);

altrimenti se(op == "-")

printf("%6.2f\n",num1 - num2);

altrimenti se(op == "*")

printf("%6.2f\n",num1 * num2);

altrimenti se(op == "/")

printf("Errore: divisione per zero!\n");

rompere;

printf("%6.2f\n",num1 / num2);

Quindi, prima di tutto, come è stato detto, viene eseguita la preelaborazione. Per vedere cosa viene fatto in questa fase, useremo l'opzione -E. Questa opzione interrompe l'esecuzione del programma nella fase di elaborazione da parte del preprocessore. Il risultato è un file di codice sorgente con il contenuto dei file di intestazione inclusi in esso.

Nel nostro caso, abbiamo incluso un file di intestazione - stdio.h - una raccolta di funzioni I/O standard. Queste funzioni inviano il testo desiderato alla console e leggono anche le parole che inseriamo dalla console.

Immettere il seguente comando:

gcc -E kalkul.c -o kalkul.cpp

Abbiamo chiamato il file risultante kalkul.cpp. Aprilo. Si prega di notare che è piuttosto lungo. Questo perché includeva tutto il codice nel file di intestazione stdio.h. Inoltre, il preprocessore ha aggiunto qui alcuni tag che indicano al compilatore come comunicare con le funzioni dichiarate. Il testo principale del nostro programma è visibile solo in fondo.

Puoi anche vedere quali altre funzioni sono dichiarate nel file di intestazione stdio.h. Se desideri informazioni su una particolare funzione, puoi chiedere informazioni a riguardo nel built-in man. Ad esempio, se improvvisamente vuoi sapere cosa fa la misteriosa funzione fopen, puoi digitare:

Ci sono anche molte informazioni nelle informazioni del sistema di guida.

Puoi anche chiedere informazioni sull'intero file di intestazione in una volta.

Diamo ora un'occhiata alla fase successiva. Creiamo un file oggetto. Un file oggetto è una traduzione "verbatim" del nostro codice di programma in linguaggio macchina, ma senza collegare le funzioni richiamate con le loro definizioni. L'opzione -c viene utilizzata per generare un file oggetto.

Il nome del file risultante può essere omesso, poiché il compilatore prende semplicemente il nome del file sorgente e cambia l'estensione .c in .o (puoi specificare se vogliamo nominarlo in modo diverso).

Se stiamo creando un file oggetto da un'origine che è già stata elaborata dal preprocessore (come quella che abbiamo ottenuto sopra), allora dobbiamo indicare esplicitamente che il file in fase di compilazione è un file di codice sorgente che è stato elaborato dal preprocessore e ha tag di preprocessore. In caso contrario, verrà elaborato come un normale file C++, senza tag del preprocessore, il che significa che non verrà stabilita la relazione con le funzioni dichiarate. L'opzione -x viene utilizzata per indicare esplicitamente la lingua e il formato del file in elaborazione. Il file C++ elaborato dal preprocessore è indicato da cpp-output.

gcc -x cpp-output -c kalkul.cpp

Infine, l'ultimo passaggio è il layout. Otteniamo l'eseguibile dal file oggetto.

gcc kalkul.o -o kalkul

Puoi eseguirlo.

Ti chiedi: “Perché tutto questo trambusto con i passaggi intermedi? Non sarebbe meglio eseguire gcc kalkul.c -o kalkul una volta?"

Il fatto è che i programmi reali molto raramente sono costituiti da un unico file. Di norma, ci sono diversi file di origine e vengono combinati in un progetto. E in alcuni casi eccezionali, il programma deve essere assemblato da più parti scritte in lingue diverse. In questo caso, devi eseguire compilatori di linguaggi diversi in modo che ognuno ottenga un file oggetto dalla sua sorgente, quindi collegare questi file oggetto risultanti in un programma eseguibile.

Sandbox

Apprendimento C++. E se iniziassi su Linux?

Bollito!

Data la professione alla moda di programmatore e una certa storia d'amore nelle menti dei giovani, ispirata dal cinema hollywoodiano, le persone entrano nelle università e affrontano una serie di difficoltà: la loro testa inizia a dilatarsi drammaticamente, il che porta inevitabilmente prima alla stanchezza, e poi a delusione per la loro scelta. Resta il fatto: se ti associ a una professione che richiede un costante miglioramento di te stesso, allora inizia a farlo anche prima di entrare. Ci sono molti materiali che ti aiuteranno a essere più preparato nel processo di studio e ti permetteranno di trovare un lavoro nella tua specialità entro il 3-4° anno di studio. Spostare!

Sullo sfondo di tale ragionamento, è venuta da me per fare un piccolo tutorial su come scrivere, compilare ed eseguire un programma C++ in Linux senza strumenti speciali (IDE). Questo approccio introdurrà il programmatore alle prime armi al processo di sviluppo nel modo più banale, così come al sistema operativo Linux, che per lui è fondamentalmente nuovo. Alla fine del mio habrapost, scriverò una bibliografia e link utili.

Iniziamo con ciò di cui abbiamo bisogno:
-Distribuzione Linux (prendi Ubuntu);
-Installato il compilatore g++;
-Editor di testo normale (gedit);
-Terminale;

Andare!

1. Installazione di Linux e del software necessario.

2. Creazione di un file cpp.

#includere usando lo spazio dei nomi std; int main()( cout<< "Hello world!"; return 0; }

Chiudi, salva.

3. Compilazione e lancio.

PS Se almeno uno studente fa quello che ho scritto, considererò che la mia missione è completata. Ti auguro il meglio!
P.S.S. Collegamenti.