Articles

Eclipse 4.3 (Kepler) per la programmazione C/C++

Il Novembre 9, 2021 da

Eclipse è un Integrated Development Environment (IDE) open-source supportato da IBM. Il sito madre è @ www.eclipse.org. Eclipse è popolare per lo sviluppo di progetti Java. Supporta anche C/C++, PHP, Python, Perl, e altri sviluppi di progetti web tramite plug-in estensibili. Eclipse è multipiattaforma e funziona sotto Windows, Linux e Mac OS.

Come installare Eclipse C/C++ Development Tool (CDT) 8.1.2 per Eclipse 4.2.2 (Juno)

Passo 0: installare MinGW GCC o Cygwin GCC

Per usare Eclipse per la programmazione C/C++, hai bisogno di un compilatore C/C++. Su Windows, puoi installare MinGW GCC o Cygwin GCC. Scegli MinGW se non sei sicuro, perché MinGW è più leggero e facile da installare, ma ha meno caratteristiche.

  1. MinGW GCC: Leggi “Come installare MinGW”.
  2. Cygwin GCC: Leggi “Come installare Cygwin”. Assicurati di selezionare i pacchetti “gcc“, “g++“, “gdb” e “make” sotto la categoria “Devel“. (Sviluppo) – questi pacchetti non fanno parte dell’installazione predefinita.
Passo 1: installare Eclipse C/C++ Development Tool (CDT)

Due modi per installare CDT, a seconda che tu abbia precedentemente installato Eclipse:

  1. Se hai già installato “Eclipse for Java Developers” o altri pacchetti Eclipse, puoi installare il plug-in CDT come segue:
    Lancia Eclipse ⇒ Help ⇒ Install New Software ⇒ Nel campo “Work with”, tira giù il menu a discesa e seleziona “Kepler – http://download.eclipse.org/releases/kepler” (o juno per Eclipse 4.2; o helios per Eclipse 3.7).
    Nella casella “Name”, espandere il nodo “Programming Language” ⇒ Selezionare “C/C++ Development Tools” ⇒ “Next” ⇒ … ⇒ “Finish”.
  2. Se non hai installato alcun pacchetto Eclipse, puoi scaricare “Eclipse IDE for C/C++ Developers” da http://www.eclipse.org/downloads, e decomprimere il file scaricato in una directory di tua scelta.
Step 2: Configurazione

Non hai bisogno di fare alcuna configurazione, finché i binari Cygwin o MinGW sono inclusi nella variabile di ambiente PATH. CDT cerca la PATH per scoprire i compilatori C/C++.

Scrivere il tuo primo programma C/C++ in Eclipse

Programma C++

Passo 0: Lancia Eclipse
  1. Avvia Eclipse eseguendo “eclipse.exe” nella directory di installazione di Eclipse.
  2. Scegli una directory appropriata per il tuo spazio di lavoro (cioè, dove vorresti salvare i tuoi lavori).
  3. Se appare la schermata di “benvenuto”, chiudila cliccando sul pulsante “close”.
Passo 1: Creare un nuovo progetto C++

Per ogni applicazione C++, è necessario creare un progetto per conservare tutti i codici sorgente, i file oggetto, i file eseguibili e le risorse rilevanti.

Per creare un nuovo progetto C++:

  1. Scegliere il menu “File” ⇒ “Nuovo” ⇒ Progetto… ⇒ C/C++ ⇒ Progetto C++.
  2. Si apre la finestra di dialogo “Progetto C++”.
    1. Nel campo “Nome del progetto”, inserire “FirstProject“.
    2. Nella casella “Tipi di progetto”, selezionare “Eseguibile” ⇒ “Progetto vuoto”.
    3. Nella casella “Catene di strumenti”, scegliere il compilatore, ad es, “Cygwin GCC” o “MinGW GCC” ⇒ Next.
  3. Appare la finestra di dialogo “Select Configurations”. Seleziona sia “Debug” che “Release” ⇒ Fine.
Passo 2: Scrivere un programma Hello-world C++
  1. In “Project Explorer” (pannello più a sinistra) ⇒ Clicca col tasto destro su “FirstProject” (o usare il menu “File”) ⇒ Nuovo ⇒ File sorgente.
  2. Si apre la finestra di dialogo “Nuovo file sorgente”.
    1. Nel campo “File sorgente”, inserisci “Hello.cpp“.
    2. Clicca su “Fine”.
  3. Il file sorgente “Hello.cpp” si apre sul pannello dell’editor (fai doppio clic su “test.cpp” per aprire, se necessario). Inserisci i seguenti codici: 
    #include <iostream>using namespace std; int main() { cout << "Hello, world!" << endl; return 0;}
Se “Unresolved Inclusion Error”

Se l’errore “unresolved inclusion” appare accanto alla dichiarazione #include, gli “include paths for headers” non sono impostati correttamente. Selezionare il menu “Progetto” ⇒ Proprietà ⇒ C/C++ Generale ⇒ Percorsi e simboli ⇒ Nella scheda “Include”:

Per Cygwin GCC:

  1. “Aggiungi” le seguenti directory a “GNU C”, dove $CYGWIN_HOME è la tua directory installata in Cygwin:
    • $CYGWIN_HOME\lib\gcc\i686-pc-cygwin.5.x\include
    • $CYGWIN_HOME\lib\gcc\i686-pc-cygwin.5.x\include-fixed
    • $CYGWIN_HOME\usr\include
    • $CYGWIN_HOME\usr\include\w32api
  2. “Aggiungi” le seguenti directory a “GNU C++”, dove $CYGWIN_HOME è la tua directory installata su Cygwin:
    • $CYGWIN_HOME\lib\gcc\i686-pc-cygwin.5.x\include\c++
    • $CYGWIN_HOME\lib\gcc\i686-pc-cygwin.5.x\include\c++\i686-pc-cygwin
    • $CYGWIN_HOME\lib\gcc\i686-pc-cygwin.5.x\include\c++\backward
    • $CYGWIN_HOME\lib\gcc\i686-pc-cygwin.5.x\include
    • $CYGWIN_HOME\lib\gcc\i686-pc-cygwin.5.x\include-fixed
    • $CYGWIN_HOME\usr\include
    • $CYGWIN_HOME\usr\include\w32api

    Per MinGW GCC:

    1. “Aggiungi” le seguenti directory a “GNU C”, dove $MINGW_HOME è la tua directory installata di MinGW:
      • $MINGW_HOME\lib\gcc\mingw32.6.x\include
      • $MINGW_HOME\include
      • $MINGW_HOME\lib\gcc\mingw32.6.x\include-fixed
    2. “Aggiungi” le seguenti directory a “GNU C++”, dove $MINGW_HOME è la tua directory installata su Cygwin:
      • $MINGW_HOME\lib\gcc\mingw32.6.x\include\c++
      • $MINGW_HOME\lib\gcc\mingw32.6.x\include\c++\mingw32
      • $MINGW_HOME\lib\gcc\mingw32.6.x\include\c++\backward
      • $MINGW_HOME\lib\gcc\mingw32.6.x\include
      • $MINGW_HOME\include
      • $MINGW_HOME\lib\gcc\mingw32.6.x\include-fixed

    NOTA: Per trovare i percorsi degli header, puoi fare una ricerca sugli header come “stdio.h” (per C) e “iostream” (per C++) sotto la directory installata di Cygwin o MinGW.

    Nota: Se si incontra “errore durante il caricamento delle librerie condivise” durante il collegamento. Installa “libmpfr4” in Cygwin.
    Step 3: Compila/Costruisci

    Clicca con il tasto destro del mouse su “FirstProject” (o usa il menu “Project”) ⇒ scegli “Build Project” per compilare e collegare il programma.

    Step 4: Run

    Per eseguire il programma, clicca col tasto destro del mouse su “FirstProject” (o in qualsiasi punto del sorgente “test.cpp“, o seleziona il menu “Run”) ⇒ Run As ⇒ Local C/C++ Application ⇒ (Se lo chiedi, scegli il debugger gdb di Cygwin) ⇒ L’output “Hello, world!” appare sul pannello “Console”.

    NOTA: Devi creare un nuovo progetto C++ per OGNI tuo problema di programmazione. Questo è disordinato per scrivere programmi giocattolo!

    Programma C

    Segui gli stessi passi come sopra. Crea un “Progetto C” (invece di “Progetto C++”). Prova il seguente programma Hello-world (chiamato “Hello.c“).

    #include <stdio.h> int main() { printf("Hello, world!\n"); return 0;}

    Programma C++ con Makefile

    Negli esempi precedenti, usiamo il cosiddetto managed-make dove Eclipse genera automaticamente un makefile per costruire il programma. Possiamo anche scegliere di scrivere il nostro makefile per un controllo completo del processo di costruzione.

    Passo 1: Creare un progetto C++ Makefile

    Dal menu “File” ⇒ Nuovo ⇒ Progetto… ⇒ C/C++ ⇒ Progetto C++ ⇒ In “Nome del progetto”, inserire “HelloCppMakefile” ⇒ In “Project type”, scegli “Makefile Project”, “Empty Project” ⇒ In “Toolchains”, scegli “Cygwin GCC” o “MinGW GCC”. Ignora il messaggio di avvertimento.

    Passo 2: Scrivere un programma C++

    Clicca con il tasto destro sul progetto ⇒ Nuovo ⇒ File sorgente ⇒ In “File sorgente”, inserisci “Hello.cpp” ⇒ Inserisci i seguenti codici sorgente:

    #include <iostream>using namespace std; int main() {cout << "Hello, world!" << endl;return 0;}
    Passo 3: Scrivere un Makefile

    Clicca destro sul progetto ⇒ Nuovo ⇒ File ⇒ In “Nome del file”, inserisci “makefile” ⇒ Inserisci i seguenti codici. Nota che devi usare un Tab (NON spazi) per il rientro.

    all: Hello.exe clean:rm Hello.o Hello.exe Hello.exe: Hello.og++ -g -o Hello.exe Hello.o Hello.o: Hello.cppg++ -c -g Hello.cpp
    Passo 4: Costruire il progetto

    Clicca con il tasto destro del mouse sul progetto ⇒ Costruisci il progetto.

    Passo 5: Esegui il programma

    Clicca con il tasto destro del mouse sul progetto ⇒ Esegui come ⇒ Applicazione locale C/C++.

    Scrivi un makefile per compilare i programmi-giocattolo sotto un progetto.

    Leggi la documentazione

    Dovresti almeno sfogliare la “Workbench User Guide” e la “C/C++ Development User Guide” di Eclipse – accessibili tramite la pagina “Welcome” o il menu “Help”. Questo ti risparmierà molte ore di agonia cercando di capire come fare alcune cose in seguito.

    Debugging dei programmi C/C++ in Eclipse CDT

    La capacità di usare un debugger grafico per il debug del programma è cruciale nella programmazione. Potrebbe risparmiarti innumerevoli ore a indovinare cosa è andato storto.

    Passo 0: Scrivere un programma C++ – Il seguente programma calcola e stampa il fattoriale di n (=1*2*3*...*n). Il programma, però, ha un errore logico e produce una risposta sbagliata per n=20 (“The Factorial of 20 is -2102132736” – un numero negativo?!).

    1234567891011121314
    		 
    #include <iostream>using namespace std; int main() { int n = 20; int factorial = 1; // n! = 1*2*3...*n for (int i = 1; i <= n; i++) { factorial *= i; } cout << "The Factorial of " << n << " is " << factorial << endl; return 0;}
    		 
    The Factorial of 20 is -2102132736

    Utilizziamo il debugger grafico per eseguire il debug del programma.

    Passo 1: Impostare un breakpoint iniziale – Un breakpoint sospende l’esecuzione del programma per esaminare gli stati interni (es, valore delle variabili) del programma. Prima di avviare il debugger, è necessario impostare almeno un punto di interruzione per sospendere l’esecuzione all’interno del programma. Imposta un punto di interruzione alla funzione main() facendo doppio clic sul margine sinistro della linea che contiene main(). Un cerchio blu appare nel margine sinistro indicando che un punto di interruzione è impostato su quella linea.

    Passo 2: Avviare il Debugger – Clicca con il tasto destro del mouse sul progetto (o usa il menu “Run”) ⇒ “Debug As” ⇒ “Local C/C++ Application” ⇒ scegli “Yes” per passare alla prospettiva “Debug” (una prospettiva è una particolare disposizione dei pannelli per soddisfare una certa attività di sviluppo come la modifica o il debug). Il programma inizia l’esecuzione ma sospende la sua operazione al punto di interruzione, cioè la funzione main().

    Come illustrato nel seguente diagramma, la linea evidenziata (indicata anche da una freccia blu) indica l’istruzione da eseguire nel passo successivo.

    Passo 3: Step-Over e guardare le variabili e gli output – Clicca il pulsante “Step Over” (o seleziona “Step Over” dal menu “Run”) per fare un passo singolo attraverso il tuo programma. Ad ogni passo, esamina il valore delle variabili (nel pannello “Variabile”) e gli output prodotti dal tuo programma (nel pannello “Console”), se presenti. Puoi anche posizionare il cursore su qualsiasi variabile per ispezionare il contenuto della variabile.

    Single-stepping attraverso il programma e guardare i valori delle variabili interne e gli output prodotti è il mezzo definitivo nel debug dei programmi – perché è esattamente come il computer esegue il tuo programma!

    Step 4: Breakpoint, Run-To-Line, Resume e Terminate – Come detto, un breakpoint sospende l’esecuzione del programma e ti permette di esaminare gli stati interni del programma. Per impostare un punto di interruzione su una particolare dichiarazione, fate doppio clic sul margine sinistro di quella linea (o selezionate “Toggle Breakpoint” dal menu “Run”).

    “Resume” continua l’esecuzione del programma, fino al prossimo punto di interruzione, o fino alla fine del programma.

    “Single-step” attraverso un ciclo con un grande numero è lungo. Potresti impostare un punto di interruzione all’istruzione immediatamente al di fuori del ciclo (ad esempio, la linea 12 del programma sopra), e lanciare “Resume” per completare il ciclo.

    In alternativa, puoi posizionare il cursore su una particolare istruzione, e lanciare “Run-To-Line” dal menu “Run” per continuare l’esecuzione fino alla linea.

    “Terminate” termina la sessione di debugging. Termina sempre la sessione di debug in corso usando “Terminate” o “Resume” fino alla fine del programma.

    Passo 5: Tornare alla prospettiva C/C++ – Clicca sull’icona della prospettiva “C/C++” nell’angolo in alto a destra per tornare alla prospettiva “C/C++” per un’ulteriore programmazione (o menu “Window” ⇒ Open Perspective ⇒ C/C++).

    Non posso sottolineare di più che padroneggiare l’uso del debugger è fondamentale nella programmazione. Esplora le caratteristiche fornite dai debugger.

    Altre caratteristiche del debugger

    Modificare il valore di una variabile: Potete modificare il valore di una variabile inserendo un nuovo valore nel pannello “Variabile”. Questo è utile per modificare temporaneamente il comportamento di un programma, senza cambiare il codice sorgente.

    Step-Into e Step-Return: Per eseguire il debug di una funzione, dovete usare “Step-Into” per entrare nella prima istruzione del metodo. Potete usare “Step-Return” per tornare indietro al chiamante, in qualsiasi punto del metodo. In alternativa, puoi impostare un punto di interruzione all’interno di un metodo.

    NOTA: Se ricevi il messaggio di errore “Impossibile trovare un file sorgente a /cygdrive/c…” durante il debug, devi configurare una mappatura tra “/cygdrive/c” e “c:/” (assumendo che il tuo programma sia tenuto nel drive c. Da “Window” ⇒ “Preferenze” ⇒ “C/C++” ⇒ “Debug” ⇒ “Common Source Lookup Path”, selezionare “Add” ⇒ “Path Mapping”.

    Tips & Tricks

    Leggi Eclipse for Java’s Tips & Tricks per suggerimenti generali sull’uso di Eclipse.

    Sviluppo di software C/C++ usando GCC

    1. Puoi trovare i comandi usati in Eclipse CDT per costruire il progetto a “<workspace>\.metadata\.plugins\org.eclipse.cdt.ui\global-build.log“.
    2. Impostare include-paths, library-paths, e librerie: Quando si costruisce il programma, il compilatore ha bisogno dei file di intestazione per compilare i codici sorgente; il linker ha bisogno delle librerie per risolvere i riferimenti esterni. Il compilatore cerca negli “include-paths” gli header specificati nelle direttive #include. Il linker cerca nei “library-paths” le “librerie” necessarie per collegare il programma. In GCC, include-path è specificato tramite l’opzione -Idir o la variabile d’ambiente CPATH. Il library-path è specificato tramite l’opzione -Ldir o la variabile d’ambiente LIBRARY_PATH. La libreria libxxx.a è specificata tramite l’opzione -lxxx (lettera minuscola 'l', senza il prefisso lib e l’estensione .a).
      In Eclipse CDT, è possibile impostare i percorsi di inclusione, i percorsi di libreria e le librerie cliccando con il tasto destro sul progetto ⇒ Proprietà ⇒ C/C++ Generale ⇒ Percorsi e simboli ⇒ Nelle schede “Include”, “Percorsi di libreria” e “Librerie”. Le impostazioni sono applicabili solo al progetto selezionato.
      Per impostare i percorsi di inclusione e di libreria per tutti i progetti, imposta le variabili d’ambiente CPATH e LIBRARY_PATH. In Eclipse, scegliete “Window” ⇒ Preferences ⇒ C/C++ ⇒ Build ⇒ Environment.
      In alternativa, copiate gli header e le librerie nelle directory di sistema, e potete omettere gli include-paths e library-paths.
    3. OpenGL con GLUT: Per Cygwin, è necessario installare gcc, g++, gdb, make (sotto la categoria Devel) e opengl, freeglut (sotto la categoria graphics). Gli header gl.h, glu.h, glut.h sono tenuti in $cygwin\usr\include\w32api\GL. Usa #include <GL/gl__.h> per includere le intestazioni. Le librerie libopengl32.a libglu32.a e libglut32.a sono conservate in $cygwin\lib\w32api. Per specificare queste librerie nel collegamento, usa le opzioni -lopengl32 -lglu32 -lglut32 (senza il prefisso lib e l’estensione .a).
    4. OpenGL con SDL: scarica SDL da http://www.libsdl.org. Scegliere Librerie di sviluppo ⇒ win32 ⇒ mingw32 ⇒ Unzip. Copia la directory degli headers SDL (sotto include) in $cygwin\usr\include\w32api; copia tutti i file di libreria in lib in $cygwin\lib\w32api; copia la libreria run-time SDL.dll (sotto bin) in Windows/System32. Nel tuo programma, includi queste due intestazioni: #include <SDL/sdl.h> e #include <SDL/sdl_opengl.h>. Per il collegamento, aggiungi queste librerie: -lSDL -lSDLmain.
    5. #pragma Comment Directive: la direttiva pragma comment, ad esempio #pragma comment(lib, "opengl32.lib"), è spesso usata per includere una particolare libreria (come l’opzione -l). Questa direttiva dipendente dal sistema funziona sul compilatore di Windows, ma NON in GCC.
    6. Errore “multiple target patterns”: C’è un problema con GNU make (a $Cygwin\bin\make.exe). Sostituito da questa copia @ http://www.cmake.org/files/cygwin/make.exe.
    7. fflush(stdout): La libreria gcc usa l’I/O bufferizzato (in accordo con la specifica C). L’output viene scritto sul flusso di uscita solo dopo un carattere newline. Puoi lavare l’output con un fflush().
    8. Il nome del progetto non deve includere la parola “setup”: Se nominate il vostro progetto C/C++ con un nome che include la parola “setup“, allora il risultante “*setup*.exe” attiverà l’UAC (User Authorization Control) e richiederà il diritto di amministratore per essere eseguito. (Mi ci sono volute alcune ore per capirlo! Prova a rinominare un “hello.exe” in “mysetup.exe“.)

    File I/O in Eclipse

    Riferimento a Eclipse per File IO di Java.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.