Sei sulla pagina 1di 13

INSTALLAZIONE E UTILIZZO DI Code::Blocks 17.

12
per sistemi Windows
Code::Blocks è un IDE (Integrated development Environment – Ambiente di sviluppo
integrato) che permette di scrivere, compilare, fare il debug ed eseguire i propri
programmi in linguaggio C (e altri).

Download
Si può scaricare gratuitamente la versione per attuale di Codeblocks per vari sistemi
operativi dal sito http://www.codeblocks.org/ alla voce Downloads
Per Windows si indicano direttamente i link per il download:
https://www.fosshub.com/Code-Blocks.html?dwl=codeblocks-17.12mingw-setup.exe,
oppure:
http://sourceforge.net/projects/codeblocks/files/Binaries/17.12/Windows/codeblocks-
17.12mingw-setup.exe
Cliccando sui link sopra, inizia il download (86.2 MB).
Si noti che il nome del file contiene la stringa mingw: questo significa che oltre
all’IDE viene installato anche il compilatore (gcc) e il debugger (gdb).

Per Linux è preferibile usare i comandi propri della distribuzione che si utilizza per
installare i pacchetti del compilatore, del debugger e di Code::Blocks. Per OSX è
necessario scaricare il compilatore di Apple XCode, quindi Code::Blocks non è più
necessario (cercare tutorial in rete su come installare XCode su OSX).

Le istruzioni seguenti sull’utilizzo di un ambiente di sviluppo integrato sono in linea


di principio valide per qualsiasi ambiente di sviluppo in qualsiasi sistema operativo;
qui ci si focalizzerà su Code::Blocks, per gli altri è necessario identificare i
comandi/bottoni corrispondenti.

Installazione (Windows)
Fare doppio click sul file scaricato, quindi:
1. Accettare di fare modifiche al sistema
2. Next
3. I agree per accettare le condizioni di utilizzo
4. Nella sezione Choose components verificare che l’ultima voce (“MinGW
Compiler Suite”) sia selezionata, quindi premere Next
5. Indicare la directory (cartella) dove installare Code::Blocks, è possibile
lasciare il valore di default che per Windows è C:\Program Files
(x86)\CodeBlocks, quindi premere Install
6. Attendere l’estrazione dei file
7. Alla richiesta di lanciare Code::Blocks, rispondere NO
8. Next dopo che i file sono stati installati
9. Finish
Creazione di un progetto
Un programma può essere composto da uno o più file sorgenti che dopo la
compilazione vengono assemblati dal linker per costituire un unico programma
eseguibile, questi sorgenti vengono collettivamente identificati come un unico
progetto.
La prima volta è necessario selezionare il compilatore e associare i file di
programmazione a Code::Blocks.
Far partire il Codeblocks.
Nella schermata per la scelta del compilatore selezionare con un click il compilatore
GCC che dovrebbe avere l’indicazione “detected” (cioè trovato sul sistema), premere
il bottone sulla destra Set as default e quindi premere OK.
Si apre quindi l’interfaccia di programmazione e viene chiesto se associare i file
C/C++ a Codeblocks, selezionare la terza opzione (“Yes, associate Code::Blocks to
C/C++ file types”).
Per creare un progetto, lanciato Code::Blocks, si seguano i passi indicati:
1. Al centro della schermata iniziale

fare click su “Create a new project”, oppure utilizzare il menu


FileNewProject
2. Nella finestra “New from template”

selezionare “Console Application” e premere il bottone Go


3. Premere Next
4. Selezionare il compilatore C e NON C++

e premere Next
5. Dare un nome al progetto in “Project Title”, ad esempio “Esercizio1.1” e, se il
campo “Folder to create object in:” è vuoto, selezionare (con … dove
collocare i file del progetto, es. in “C:\Esercizi”:

Come si vede, viene creato un file .cbp con il nome del progetto e questo è
collocato dove indicato all’ultima riga. questi campi vengono impostati
automaticamente, non cambiarli
6. Premere Next
7. Alla finestra di dialogo seguente:

8. selezionare il compilatore: “GNU GCC compiler” se non è già selezionato,


non modificare gli altri campi (lasciare i segni di spunta nei due quadratini)
9. Premere Finish
10. Si presenta la schermata iniziale, come la seguente (qui tagliata):

dove si vede a sinistra il tab Projects con il nome del progetto (Esercizio1.1)
e sotto di esso Sources, cliccando Sources vengono mostrati i file di cui è
composto il progetto. Inizialmente c’è un unico file che viene chiamato
main.c (ma si può cambiare) e possono essere aggiunti altri file per progetti
più complessi.
Se non si vede la sezione Projects, cliccare sui triangoli a sinistra o a destra
sulla stessa riga (vedere la figura sopra).
Se non si vede la finestra Management che contiene Projects cliccare sulla
voce di menu View e quindi su Manager (Shift-F2).
11. Fare un doppio click su main.c per aprire la finestrella di programmazione
dove immettere il codice, Code::Blocks predispone un semplice programmino
che dovrà essere cancellato per far posto al proprio programma:

12. Per salvare il file si seleziona File/Save as, si preme Control-S, o si clicca
sul bottone con il dischetto singolo.
Apertura di un progetto già creato
E’ possibile aprire un progetto creato precedentemente facendo click sulla voce
“Open an existing project…” che si ottiene quando Code::Blocks viene mandato in
esecuzione, oppure direttamente sul suo nome in “Recent projects” nel menu File.

Compilazione ed esecuzione
Questi comandi si trovano sia in una delle toolbar:

sia nel menu Build:

Ci sono le stesse icone, ad es. si vede che il triangolo verde (Run) equivale a
Control-F10, posizionando il mouse sulle icone della toolbar appare l’indicazione di
che cosa siano.

Per compilare è preferibile usare il comando Build (F9), ossi l’icona con
l’ingranaggio:
Quando si effettua la compilazione, vengono segnalati in una finestrella in basso gli
errori sintattici e i warning, ciascuno con il numero della riga dove questi si sono
verificati.

La zona grigia a fianco delle righe di codice riporta i numeri delle righe. Un doppio
click sull’indicazione dell’errore posiziona il cursore alla riga con l’errore e un
quadratino rosso la identifica. Non necessariamente l’errore è alla riga indicata (ad es.
la mancanza di un punto e virgola viene rilevata solo alla riga successiva), inoltre un
errore può generarne molti altri in cascata, questi in genere vengono eliminati dalla
correzione dell’errore iniziale.

L’operazione di build compila i file (il file in questo caso) e ne fa il link con le
librerie. La sola compilazione non fa il link.
Per eseguire il programma compilato si deve cliccare su Run (triangolino verde a
destra di Build, Control-F10). Attenzione che cliccare su Run NON fa anche la
compilazione per cui viene mandata in esecuzione la versione precedente del
programma. È necessario fare prima il build oppure cliccare su Build and Run (icona
composta da ingranaggio e triangolino verde) che prima esegue il build e se va a buon
fine esegue il programma.

Come fare il debug di un programma


Si hanno a disposizione diversi strumenti per fare il debug di un programma, questo
deve essere stato compilato nella modalità Debug (è il default), si può vedere se è così
nella schermata con il codice:

Quando il programma funziona correttamente è possibile selezionare la modalità


Release in cui il compilatore ottimizza il codice modificandolo (ad esempio per avere
la massima velocità di esecuzione), il codice ottimizzato è diverso e di più difficile
comprensione rispetto al codice di partenza. A livello didattico non è necessario
considerarlo.

Ricerca errori - debugging


Quando il programma viene compilato correttamente non ha errori sintattici, ma non
necessariamente produce i risultati voluti, questo perché il programmatore ha
sbagliato a realizzare l’algoritmo (errori logici).
La ricerca degli errori logici (bugs italianizzato in bachi) di un programma viene
chiamato debugging e il metodo più efficace per attuarlo è eseguire il programma
istruzione per istruzione (passo passo, step-by-step), l’utilità è evidente: ad es. nel
caso di istruzioni if si vede il ramo che viene eseguito, è sempre possibile vedere
(watch) il valore delle variabili dopo che ogni istruzione viene eseguita così da
accorgersi quando i valori mostrati non sono quelli che ci si aspetta (e quindi il
problema potrebbe essere proprio lì vicino).

I comandi per il debug si trovano sia in una delle toolbar:

sia nel menu Debug (dove viene anche indicato il nome e la scorciatoia da tastiera):

Il debugger (gdb) è un programma separato dal compilatore (gcc) e viene installato


insieme al compilatore (in Windows). Per verificare se è correttamente impostato
premere sul triangolino rosso (F8). Se dà errori vedere più avanti.

Quando il programma viene mandato in esecuzione, compare la finestra di interazione


con il programma stesso, è una finestra a caratteri (console):
I vari comandi lì disponibili sono i seguenti (è comodo abituarsi ad usare la tastiera
per questioni di velocità, ma si possono ovviamente usare i bottoni e il menu):

F8 – Start/Continue
esegue il programma e si ferma ai breakpoint, se necessario prima compila e
fa il link; se il programma è stato interrotto continua l'esecuzione. Nel caso si
aprisse una finestrella chiedendo se si vuole cambiare la “perspective”
selezionare “Don’t annoy me again!” e cliccare sul bottone No);
F7 – Next line
esegue una sola riga (per volta) del programma (modalità passo passo), se è
una chiamata a funzione questa viene eseguita senza fermarsi; in genere un
programma ha una sola istruzione per riga per cui equivale al seguente (ma è
più comodo da utilizzare), è il più utilizzato;
Alt-F7 – Next instruction
esegue una sola istruzione (per volta) del programma (modalità passo passo),
se è una funzione, la esegue senza fermarsi;
Shift-F7 – Step into instruction
se l’istruzione da eseguire è una funzione, entra in questa per eseguire passo
passo le sue istruzioni (Next instruction e Next line la eseguono come se fosse
un’unica istruzione, senza eseguire passo passo le istruzioni);
Debug/Stop Debugger
ferma definitivamente il programma (se eseguito passo passo) e chiude la
console.

Per eseguire un programma in modalità passo passo (step-by-step) a partire da una


certa riga di codice occorre posizionare un breakpoint alla quella riga. Un breakpoint
(punto di interruzione) è un segnale che indica che l’esecuzione del programma deve
fermarsi PRIMA di eseguire la riga con il breakpoint. Tutte le precedenti il breakpoint
verranno eseguite senza interruzioni. Ovviamente se si vuole iniziare subito con
l’esecuzione passo passo del programma il breakpoint dovrà essere messo alla prima
riga contenente un codice operativo (qundi la prima dopo le definizioni delle
variabili). Si fa quindi partire il programma in modalità debug (triangolino rosso o
F8), NON con Run (Control-F10).

Per impostare un breakpoint a una determinata riga è sufficiente fare click nella zona
grigia subito a destra dei numeri di riga, un punto rosso identifica la presenza di un
breakpoint. Per eliminarlo si procede allo stesso modo. Ci possono essere più
breakpoint nello stesso programma e per continuare velocemente l’esecuzione fino al
successivo breakpoint si può usare Run/Continue (F8).
Quando il programma è in esecuzione ed è sospeso ad un breakpoint, la riga da
eseguire è indicata con un triangolino giallo:

Come già indicato, usando Next line o Next instruction o meglio ancora premendo
F7 si passa alla riga successiva e ci si ferma automaticamente.
Per terminare l’esecuzione del programma si clicca sul bottone con la X bianca (vedi
sotto).

Ogni volta che il programma è eseguito in modalità debug e si è fermi, è possibile


ispezionare il valore delle variabili attraverso la finestrella dei Watch, si clicca sul
bottone a destra di quello con la X bianca e si seleziona dal menu a discesa la voce
Watches:

Si ottiene la finestrella dei Watch che conviene trascinare in basso a destra perché non
sia flottante. Il riquadro dove verrà posizionata viene visualizzato in azzurro:
Può essere necessario ripetere questa operazione (mentre il programma è in
esecuzione). Nella finestra dei Watches è possibile vedere il valore delle variabili
cambiare mentre il programma è in esecuzione passo passo e anche modificarle se
necessario.

Compatibilità con gli standard


Poiché il gcc è conforme a diverse versioni del linguaggio è possibile richiedere che
esso invece si attenga rigidamente a una di queste. In particolare se si desidera che sia
completamente aderente allo standard C89 ANSI/C90 ISO si deve selezionare la voce
di menu Settings  Compiler e al tab Compiler flags nella sezione General
mettere un segno di spunta alla voce:
“In C mode, this is equivalent to -std=c90,…”
e più sotto nella sezione Warnings:
“Enable warnings demanded by strict ISO C90 …”
Selezionare quindi il tab “Other compiler options” e scrivere nella casella
sottostante:
-Wno-missing-braces
per evitare warning relativi alle doppie parentesi graffe:

Chiudere premendo OK.

Problemi di installazione del debugger


Talvolta durante l’installazione dell’IDE non viene impostata correttamente la
posizione del debugger. Se premendo il triangolino rosso si verificano degli errori del
tipo:
ERROR: You need to specify a debugger program in the debuggers's settings.
(For MinGW compilers, it's 'gdb.exe' (without the quotes))
(For MSVC compilers, it's 'cdb.exe' (without the quotes))
è necessario impostarne il percorso una volta per tutte.
Nel menu, selezionare Settings e poi Debugger…, nella finestrella che appare
cliccare Default, il riquadro rosso indica che non è stato impostato il percorso dove si
trova gdb32.exe, quindi cliccare sul bottone alla sua destra …:
Si apre una finestra per selezionare il debugger, se Code::Blocks è stato installato in
C:\Program Files (x86)\CodeBlocks, posizionarsi nella directory
C:\Program Files (x86)\CodeBlocks\MinGW\gdb32\bin e cliccare su
gdb32.exe, quindi cliccare sul bottone Open. Il campo resta rosso, ma si legge il
nuovo percorso. Chiudere la finestrella e riaprirla (Settings  Debugger… 
Default) per verificare che lo sfondo rosso sia scomparso. Ora il debugger è
funzionante.

Problemi durante l’esecuzione con il debugger


Può capitare che il programma in esecuzione nel debugger non risponda più, non si
fermi ai breakpoint o abbia altri comportamenti non corretti. In questo caso si cerchi
di chiudere il programma con il bottone rosso con la X bianca, talvolta questo non è
sufficiente e il programma e/o il debugger continua a essere in memoria anche se non
c’è più la sua finestra visibile. In questi casi è necessario terminare manualmente il
programma. Conviene innanzi tutto salvare il programma (Contrl-S), poi si mostra
l’elenco dei processi di Windows con Control-Shift-Esc (Control-Maiusc-Esc nella
tastiera italiana), si cercare o il nome del proprio programma (es.
Esercizio1.1.exe) o il programma gdb32 e lo si termina con il bottone
Termina dopo averlo selezionato (o con il tasto di destra del mouse). Non serve
terminare il programma Code::Blocks.
Argomenti sulla riga di comando
Se il programma richiede degli argomenti sulla riga di comando, per indicarli si
seleziona Projects/Set program’s arguments… nella barra dei menu:

Potrebbero piacerti anche