Articolo originale qui.



Quello che presento ora è uno stile di lavoro che consente di compilare ed eseguire velocemente i programmi, effettuando anche l'operazione di debug attraverso l'utilizzo della console.
A seconda di quale distribuzione Linux utilizziate avrete installato sicuramente un buon editor di testo (su KDE io uso Kate) con il quale scrivere il sorgente del vostro programma e salvarlo con estensione .c .

Compilazione

Per il processo di compilazione del sorgente utilizziamo il compilatore gcc che risiede installato di default su ogni distribuzione che si rispetti.
Apriamo una console e con il comando cd raggiungiamo la cartella dove risiede il sorgente.

Per esempio: se il sorgente è in /home/utente/progetti/programma.c occorrerà digitare in console:
Codice:
[utente@nomepc]~ cd /home/utente/progetti
Per la compilazione ora digitiamo:
Codice:
[utente@nomepc progetti] gcc programma.c
In questo modo, se non vi sono errori nel codice, viene creato il file a.out eseguibile. Per dare un nome diverso all'eseguibile occorre aggiungere un parametro opzionale al comando di compilazione che diventa:
Codice:
[utente@nomepc progetti] gcc programma.c -o exeprog
Dove con exeprog indichiamo come si dovrà chiamare l'eseguibile creato. Un ulteriore opzione che fa stampare tutti i Warning di compilazione e aiuta a scovare errori altrimenti difficili da individuare è -Wall. Se si vuole fare il debug del programma occorre aggiungere anche il parametro -g.
In conclusione il comando di compilazione più completo è:
Codice:
[utente@nomepc progetti] gcc programma.c -o exeprog -Wall -g
Esecuzione

Per eseguire un programma occorre digitare, in console, il comando:
Codice:
[utente@nomepc progetti] ./exeprog
oppure
Codice:
[utente@nomepc progetti] ./a.out
Debug

Il programma utilizzato per il debug è il celeberrimo gdb che è alla base del 90% dei debugger grafici.
Se non è installato sul nostro sistema dovremo installarlo (esistono sicuramente dei pacchetti adatti a qualsiasi distribuzione). Per lanciare il debug di un eseguibile (compilato con l'opzione -g) dobbiamo digitare in console:
Codice:
[utente@nomepc progetti] gdb exeprog
Comparirà un nuovo prompt:
Codice:
(gdb)
Ecco riassunti i comandi principali:
  • l
Visualizza sorgente a partire dall’ultima riga visualizzata oppure dal numero di riga n
Codice:
l <n>
  • b
Imposta un breakpoint ad una certa riga n
Codice:
b n
  • r
Esegue il programma, fa partire il debug
Codice:
r [eventuali parametri]
  • s
Step (entra anche nelle funzioni)
  • n
Next (non entra nelle funzioni)
  • p
Visualizza il contenuto di una variabile
Codice:
p variabile
p *puntatore
p struttura->campo
p vettore@num_elementi
  • d
Come p, ma visualizza automaticamente le variabili ad ogni step (usarla con molta moderazione
  • c
Riprende l’esecuzione dopo un breakpoint
  • k
Uccide (kill) l’esecuzione del programma
  • q
Chiude gdb

Esempio

Codice:
(gdb) l 30
  25    FILE *fp;
  26
  27    if(argc != 4){
  28        help();
  29        exit(0);
  30    }
  31    fp = aprifile(argv[1], “rt”);
  32    h1 = leggifile(fp);
  33    fclose(fp);
  34    fp = aprifile(argv[2], “rt”);
(gdb) b 31
Breakpoint 1 at 0×8048671: file SimEsame.c, line 31.
(gdb) r input1.txt input2.txt output.txt
Starting program: SimEsame input1.txt input2.txt output.txt
 
Breakpoint 1, main (argc=4, argv=0xbfe10) at SimEsame.c:31
31              fp = aprifile(argv[1], “rt”);
(gdb) n
32              h1 = leggifile(fp);
(gdb) n
33              fclose(fp);
(gdb) n
34              fp = aprifile(argv[2], “rt”);
(gdb) n
35              h2 = leggifile(fp);
(gdb) n
36              fclose(fp);
(gdb) n
37              h3 = unisci(h1, h2);
(gdb) p h2
$1 = (nome *) 0×804a300
(gdb) p *h2
$2 = {s = 0×804a310 “Andrea”, next = 0×804a320}
(gdb) p h2->next
$3 = (struct tnome *) 0×804a320
(gdb) p *h2->next
$4 = {s = 0×804a330 “Attilio”, next = 0×804a340}
(gdb) c
Continuing.
 
Program exited normally.
(gdb)q
Alla prossima