Lezione 9 – Arrivederci (make & Makefile)

arkkimede 8 Giugno 2021 Corso C, Software Lascia un commento 432 Visualizzazioni

Ebbene si, questa è l’ultima lezione di questo corso sul C.

Si spera che quanto promesso nella lezione 0 sia stato raggiunto.

In futuro magari qualche argomento specifico sarà proposto, ma vedremo (potrebbe anche essere una vostra richiesta specifica….)

Aver seguito questo corso non vi rende programmatori, solo programmando ci riuscirete.

Molte cose non sono state trattate ma su internet scoprirete che sicuramente prima di voi qualcuno avrà avuto il vostro stesso problema e vi fornirà una possibile soluzione.

Come ultimo argomento, (come da titolo), vogliamo vedere come è fatto un Makefile per compilare il sorgente. Tale procedura può anche essere usata per generare una libreria.

Il codice è costituito da tante piccole funzioni ognuna delle quali risolve un piccolo problema: cooperando tra di loro ed orchestrate da un programma principale sono in grado di risolvere grossi problemi.

A titolo di esempio, realizzeremo una calcolatrice con varie funzioni.

Organizzazione della directory di lavoro

Anche questa ultima lezione non prevede l’uso di un IDE. Molti forse non apprezzano questa scelta, ma la lezione è comunque utile perché spiega come impostare l’ambiente di lavoro e scrivere il codice separando le varie funzioni. Si propone anche un eseguibile in grado di generare un Makefile e compilare il codice, ma se usate un IDE, questo lo farà per voi.

Per prima cosa nella cartella in cui vogliamo sviluppare la calcolatrice, generiamo tre sotto cartelle:

La prima conterrà i sorgenti, la seconda gli headers e la terza il risultato parziale della compilazione ossia i file punto o.

Vediamo prima di tutto come funziona la calcolatrice:

Fig1 – Menu principale

Nella Fig1 possiamo vedere il menu principale della calcolatrice. Supponiamo di selezionare 1, avremo: (vedi Fig2)

Fig2 – Somma

dove sono già stati inseriti i due addendi. Se si risponde s (si) si potrà eseguire un’altra somma se n (no) riapparirà il menu principale per effettuare un’altra scelta. Digitando 0 il programma si arresta.

Di seguito esamineremo solo alcune funzioni, in quanto tutto il codice è disponibile sul repository GitHub come archivio compresso (tgz).

Iniziamo con il main.c

/********************************************
** Programma principale della calcolatrice
**
** arkkimede
** Giugno 2021
**
*********************************************/

#include <stdio.h>
#include <stdlib.h>
#include <menu.h>
#include <make_somma.h>
#include <make_sottrazione.h>
#include <make_moltiplicazione.h>
#include <make_divisione.h>
#include <make_media.h>
#include <make_fattoriale.h>
#include <make_seno.h>
#include <make_coseno.h>
#include <make_tangente.h>
int main()
{
   int selez;

   while(1)
   {
      selez = menu();
      if (selez == 0)
        break;

      switch (selez)
      {
         case 1:
           make_somma();
         break;
         case 2:
           make_sottrazione();
         break;
         case 3:
           make_moltiplicazione();
         break;
         case 4:
           make_divisione();
         break;
         case 5:
           make_media();
         break;
         case 6:
           make_fattoriale();
         break;
         case 7:
           make_seno();
         break;
         case 8:
           make_coseno();
         break;
         case 9:
           make_tangente();
         break;
      }
   }
}

/********************************************

** Programma principale della calcolatrice

** arkkimede

** Giugno 2021

*********************************************/

#include <stdio.h>

#include <stdlib.h>

#include <menu.h>

#include <make_somma.h>

#include <make_sottrazione.h>

#include <make_moltiplicazione.h>

#include <make_divisione.h>

#include <make_media.h>

#include <make_fattoriale.h>

#include <make_seno.h>

#include <make_coseno.h>

#include <make_tangente.h>

int main()

{

int selez;

while(1)

{

selez = menu();

if (selez == 0)

break;

switch (selez)

{

case 1:

make_somma();

break;

case 2:

make_sottrazione();

break;

case 3:

make_moltiplicazione();

break;

case 4:

make_divisione();

break;

case 5:

make_media();

break;

case 6:

make_fattoriale();

break;

case 7:

make_seno();

break;

case 8:

make_coseno();

break;

case 9:

make_tangente();

break;

}

Notate tutti gli include relativi a tutte le funzioni chiamate dal main. Si tratta di un loop infinito, interrotto solo se la funzione menu restituisce 0, altrimenti uno switch indirizza verso la funzione desiderata.

Vediamo adesso la funzione menu con il suo header, in cui abbiamo introdotto una nota di colore.

menu.c

/***********************************************
** Codice che genera il menu della calcolatrice
**
** arkkimede
** Giugno 2021
**
***********************************************/

#include <menu.h>
int menu()
{
   int selez;

   system("clear");               // Pulizia dello schermo
   printf("\x1b[1;31m");          // Le scritte a video saranno rosse
   printf("   ============   \n");
   printf("   Calcolatrice \n");
   printf("   ============   \n\n");

   printf("\x1b[0m");             // Ritorno al colore originale

   printf("\x1b[1;33m");          // Cambiamo in Giallo
   printf("   Operazioni disponibili:\n\n");
   printf("\x1b[0m");i            // Interrompiamo il giallo

   printf("   1 Somma\n");
   printf("   2 Sottrazione\n");
   printf("   3 Moltiplicazione\n");
   printf("   4 Divisione\n");
   printf("   5 Media\n");
   printf("   6 Fattoriale\n");
   printf("   7 Seno\n");
   printf("   8 Coseno\n");
   printf("   9 Tangente\n");
   printf("   0 Exit\n\n");


   printf("\x1b[1;31m");            // Ritorniamo al rosso

   printf("   ==================================   \n");
   printf("   Seleziona il numero corrispondente\n");
   printf("   dell'operazione che vuoi eseguire\n");
   printf("   ==================================   \n");
   printf("\x1b[0m");               // Interrompiamp il rosso
   scanf("%d",&selez);

   return selez;
}

/***********************************************

** Codice che genera il menu della calcolatrice

** arkkimede

** Giugno 2021

***********************************************/

#include <menu.h>

int menu()

{

int selez;

system("clear"); // Pulizia dello schermo

printf("\x1b[1;31m"); // Le scritte a video saranno rosse

printf(" ============ \n");

printf(" Calcolatrice \n");

printf(" ============ \n\n");

printf("\x1b[0m"); // Ritorno al colore originale

printf("\x1b[1;33m"); // Cambiamo in Giallo

printf(" Operazioni disponibili:\n\n");

printf("\x1b[0m");i // Interrompiamo il giallo

printf(" 1 Somma\n");

printf(" 2 Sottrazione\n");

printf(" 3 Moltiplicazione\n");

printf(" 4 Divisione\n");

printf(" 5 Media\n");

printf(" 6 Fattoriale\n");

printf(" 7 Seno\n");

printf(" 8 Coseno\n");

printf(" 9 Tangente\n");

printf(" 0 Exit\n\n");

printf("\x1b[1;31m"); // Ritorniamo al rosso

printf(" ================================== \n");

printf(" Seleziona il numero corrispondente\n");

printf(" dell'operazione che vuoi eseguire\n");

printf(" ================================== \n");

printf("\x1b[0m"); // Interrompiamp il rosso

scanf("%d",&selez);

return selez;

}

menu.h

#ifndef MENU_
#define MENU_

#include <stdio.h>
#include <stdlib.h>

int menu(void);

#endif

#ifndef MENU_

#define MENU_

#include <stdio.h>

#include <stdlib.h>

int menu(void);

#endif

Osserviamo prima l’header. Contiene stdlib.h perché lì è definita la funzione system ed stdio.h per tutte le funzioni di lettura e stampa. Vi è anche la dichiarazione della funzione che non prevede input ma genera un output intero. Il tutto è inglobato nel costrutto #ifndef #endif, per evitare di includere più volte la stesso punto h.

Nella funzione, la prima cosa da osservare è come cambiare colore alle scritte. E’ sufficiente stampare:

printf(“\x1b[1;31m”);

dove 31 indica il rosso secondo questa casistica:

<= 29 Bianco
30 Grigio
31 Rosso
32 Verde
33 Giallo
34 Blu
35 Magenta (viola chiaro)
36 Ciano (celeste)
>=37 bianco

Se nella printef, dopo la parentesi quadra, l’uno lo sostituiamo con uno 0 si ottengono gli stessi colori solo meno brillanti (il grigio su fondo nero non si vede).

Per ripristinare il colore di default basta stampare:

printf(“\x1b[0m”);

L’istruzine system(“clear”) esegue il comando di sistem clear, che pulisce lo schermo e riporta il cursure in alto a sinistra dello schermo.

A questo punto vediamo make_somma ed il suo header

make_somma.c

#include <make_somma.h>
#include <somma.h>

void make_somma(void)
{
   double termine1, termine2;
   double risultato;
   char *r;

   r = (char *)malloc(2);

   while(1)
   {
      system("clear");

      printf("\x1b[1;31m");
      printf("   =====\n");
      printf("   Somma\n");
      printf("   =====\n\n");
      printf("\x1b[0m");

      printf("   Inserisci il primo termine della somma: ");
      scanf("%lf",&termine1);
      printf("   Inserisci il secondo termine della somma: ");
      scanf("%lf",&termine2);
      risultato = somma(termine1 , termine2);
      printf("   Il risultato è %lf\n",risultato);
      printf("   Vuoi fare un'altra somma? (s/n) ");
      scanf("%s",r);
      if ( r[0] == 'n' || r[0] == 'N')
        break;
   }
   free(r);
}

#include <make_somma.h>

#include <somma.h>

void make_somma(void)

{

double termine1, termine2;

double risultato;

char *r;

r = (char *)malloc(2);

while(1)

{

system("clear");

printf("\x1b[1;31m");

printf(" =====\n");

printf(" Somma\n");

printf(" =====\n\n");

printf("\x1b[0m");

printf(" Inserisci il primo termine della somma: ");

scanf("%lf",&termine1);

printf(" Inserisci il secondo termine della somma: ");

scanf("%lf",&termine2);

risultato = somma(termine1 , termine2);

printf(" Il risultato è %lf\n",risultato);

printf(" Vuoi fare un'altra somma? (s/n) ");

scanf("%s",r);

if ( r[0] == 'n' || r[0] == 'N')

break;

}

free(r);

}

make_somma.h

#ifndef MAKESOMMA_
#define MAKESOMMA_

#include <stdlib.h>
#include <stdio.h>

void make_somma(void);


#endif

#ifndef MAKESOMMA_

#define MAKESOMMA_

#include <stdlib.h>

#include <stdio.h>

void make_somma(void);

#endif

Si noti l’inclusione di somma.h nel sorgente in quanto dopo utilizzerà quella funzione. A questo punto vediamo somma ed il suo header

somma.c

#include <somma.h>

double somma(double termine1, double termine2)
{
   double risultato;
   risultato=( termine1+termine2);
   return risultato;
}

#include <somma.h>

double somma(double termine1, double termine2)

{

double risultato;

risultato=( termine1+termine2);

return risultato;

}

somma.h

#ifndef SOMMA_
#define SOMMA_

double somma(double termine1, double termine2);

#endif

#ifndef SOMMA_

#define SOMMA_

double somma(double termine1, double termine2);

#endif

In sostanza ogni modulo deve avere tutti gli headers per poter essere compilata (ossia tutte le dichiarazioni delle funzioni che verranno usate.

Da ultimo vediamo la media che utilizza la somma e la divisione

make_media.c

#include <make_media.h>
#include <divisione.h>
#include <somma.h>

void make_media(void)
{
   double termine1, termine2;
   double risultato;
   char *r;

   r = (char *)malloc(2);

   while(1)
   {
      system("clear");

      printf("\x1b[1;31m");
      printf("   =====\n");
      printf("   Media\n");
      printf("   =====\n\n");
      printf("\x1b[0m");

      printf("   Inserisci il primo termine della media: ");
      scanf("%lf",&termine1);
      printf("   Inserisci il secondo termine della media: ");
      scanf("%lf",&termine2);
      risultato = divisione(somma(termine1,termine2),2.);
      printf("   Il risultato è %lf\n",risultato);
      printf("   Vuoi fare un'altra media? (s/n) ");
      scanf("%s",r);
      if ( r[0] == 'n' || r[0] == 'N')
        break;
   }
   free(r);
}

#include <make_media.h>

#include <divisione.h>

#include <somma.h>

void make_media(void)

{

double termine1, termine2;

double risultato;

char *r;

r = (char *)malloc(2);

while(1)

{

system("clear");

printf("\x1b[1;31m");

printf(" =====\n");

printf(" Media\n");

printf(" =====\n\n");

printf("\x1b[0m");

printf(" Inserisci il primo termine della media: ");

scanf("%lf",&termine1);

printf(" Inserisci il secondo termine della media: ");

scanf("%lf",&termine2);

risultato = divisione(somma(termine1,termine2),2.);

printf(" Il risultato è %lf\n",risultato);

printf(" Vuoi fare un'altra media? (s/n) ");

scanf("%s",r);

if ( r[0] == 'n' || r[0] == 'N')

break;

}

free(r);

}

make_media.h

#ifndef MAKEMEDIA_
#define MAKEMEDIA_

#include <stdlib.h>
#include <stdio.h>

void make_media(void);


#endif

#ifndef MAKEMEDIA_

#define MAKEMEDIA_

#include <stdlib.h>

#include <stdio.h>

void make_media(void);

#endif

e quindi nel .h solo l’inclusione per pulire lo schermo e fare i/o. Nel .c l’inclusione degli headers per fare la somma e la divisione.

A questo punto vediamo come è fatto il Makefile

################################################
# Automatic Makefile generation
# arkkimede
# RaspberryItaly
# Ver 3.0
# Giugno 2021
################################################


CC=gcc

WARN=-Wall

DEBUG=

OPT=-O3

CCFLAGS = -c ${DEBUG} ${OPT} ${WARN}

LDFLAGS = -lm

SRCDIR  = src

HDSDIR  = hdr

OBJDIR  = obj

EXEDIR  = .

SRCS    = $(SRCDIR)/divisione.c \
          $(SRCDIR)/coseno.c \
          $(SRCDIR)/make_seno.c \
          $(SRCDIR)/make_tangente.c \
          $(SRCDIR)/menu.c \
....
          $(SRCDIR)/make_media.c \
          $(SRCDIR)/make_fattoriale.c

HDSS    = $(HDSDIR)/coseno.h \
          $(HDSDIR)/make_seno.h \
          $(HDSDIR)/menu.h \
          $(HDSDIR)/make_sottrazione.h \
          $(HDSDIR)/make_tangente.h \
...
          $(HDSDIR)/divisione.h

OBJS    = $(OBJDIR)/divisione.o \
          $(OBJDIR)/coseno.o \
          $(OBJDIR)/make_seno.o \
...
          $(OBJDIR)/make_fattoriale.o

PROGRAM = $(EXEDIR)/calcolatrice

$(PROGRAM): $(OBJS) $(SRCS)
    @echo " ... linking $(PROGRAM) ... "
    @$(CC) $(OBJS) $(LDFLAGS) -o $(PROGRAM)
    @echo " ... done "

$(OBJDIR)/divisione.o: $(SRCDIR)/divisione.c $(HDSDIR)/divisione.h
    @echo "I'm compiling divisione.c ... "
    @$(CC) -I$(HDSDIR) $(CCFLAGS) -o $(OBJDIR)/divisione.o $(SRCDIR)/divisione.c
$(OBJDIR)/coseno.o: $(SRCDIR)/coseno.c $(HDSDIR)/coseno.h $(HDSDIR)/moltiplicazione.h
    @echo "I'm compiling coseno.c ... "
    @$(CC) -I$(HDSDIR) $(CCFLAGS) -o $(OBJDIR)/coseno.o $(SRCDIR)/coseno.c
$(OBJDIR)/make_seno.o: $(SRCDIR)/make_seno.c $(HDSDIR)/make_seno.h $(HDSDIR)/seno.h
    @echo "I'm compiling make_seno.c ... "
    @$(CC) -I$(HDSDIR) $(CCFLAGS) -o $(OBJDIR)/make_seno.o $(SRCDIR)/make_seno.c
$(OBJDIR)/make_tangente.o: $(SRCDIR)/make_tangente.c $(HDSDIR)/make_tangente.h $(HDSDIR)/tangent
    @echo "I'm compiling make_tangente.c ... "
    @$(CC) -I$(HDSDIR) $(CCFLAGS) -o $(OBJDIR)/make_tangente.o $(SRCDIR)/make_tangente.c
$(OBJDIR)/menu.o: $(SRCDIR)/menu.c $(HDSDIR)/menu.h
    @echo "I'm compiling menu.c ... "
    @$(CC) -I$(HDSDIR) $(CCFLAGS) -o $(OBJDIR)/menu.o $(SRCDIR)/menu.c
....
$(OBJDIR)/make_fattoriale.o: $(SRCDIR)/make_fattoriale.c $(HDSDIR)/make_fattoriale.h $(HDSDIR)/m
    @echo "I'm compiling make_fattoriale.c ... "
    @$(CC) -I$(HDSDIR) $(CCFLAGS) -o $(OBJDIR)/make_fattoriale.o $(SRCDIR)/make_fattoriale.c

clean :
    @echo " I'm deleting all the .o and the executable"
    @rm -f $(OBJDIR)/divisione.o
    @rm -f $(OBJDIR)/coseno.o
    @rm -f $(OBJDIR)/make_seno.o
    @rm -f $(OBJDIR)/make_tangente.o
...
    @rm -f $(OBJDIR)/tangente.o
    @rm -f $(OBJDIR)/make_media.o
    @rm -f $(OBJDIR)/make_fattoriale.o
    @rm -f $(EXEDIR)/calcolatrice

################################################

# Automatic Makefile generation

# arkkimede

# RaspberryItaly

# Ver 3.0

# Giugno 2021

################################################

CC=gcc

WARN=-Wall

DEBUG=

OPT=-O3

CCFLAGS = -c ${DEBUG} ${OPT} ${WARN}

LDFLAGS = -lm

SRCDIR = src

HDSDIR = hdr

OBJDIR = obj

EXEDIR = .

SRCS = $(SRCDIR)/divisione.c \

$(SRCDIR)/coseno.c \

$(SRCDIR)/make_seno.c \

$(SRCDIR)/make_tangente.c \

$(SRCDIR)/menu.c \

....

$(SRCDIR)/make_media.c \

$(SRCDIR)/make_fattoriale.c

HDSS = $(HDSDIR)/coseno.h \

$(HDSDIR)/make_seno.h \

$(HDSDIR)/menu.h \

$(HDSDIR)/make_sottrazione.h \

$(HDSDIR)/make_tangente.h \

...

$(HDSDIR)/divisione.h

OBJS = $(OBJDIR)/divisione.o \

$(OBJDIR)/coseno.o \

$(OBJDIR)/make_seno.o \

...

$(OBJDIR)/make_fattoriale.o

PROGRAM = $(EXEDIR)/calcolatrice

$(PROGRAM): $(OBJS) $(SRCS)

@echo " ... linking $(PROGRAM) ... "

@$(CC) $(OBJS) $(LDFLAGS) -o $(PROGRAM)

@echo " ... done "

$(OBJDIR)/divisione.o: $(SRCDIR)/divisione.c $(HDSDIR)/divisione.h

@echo "I'm compiling divisione.c ... "

@$(CC) -I$(HDSDIR) $(CCFLAGS) -o $(OBJDIR)/divisione.o $(SRCDIR)/divisione.c

$(OBJDIR)/coseno.o: $(SRCDIR)/coseno.c $(HDSDIR)/coseno.h $(HDSDIR)/moltiplicazione.h

@echo "I'm compiling coseno.c ... "

@$(CC) -I$(HDSDIR) $(CCFLAGS) -o $(OBJDIR)/coseno.o $(SRCDIR)/coseno.c

$(OBJDIR)/make_seno.o: $(SRCDIR)/make_seno.c $(HDSDIR)/make_seno.h $(HDSDIR)/seno.h

@echo "I'm compiling make_seno.c ... "

@$(CC) -I$(HDSDIR) $(CCFLAGS) -o $(OBJDIR)/make_seno.o $(SRCDIR)/make_seno.c

$(OBJDIR)/make_tangente.o: $(SRCDIR)/make_tangente.c $(HDSDIR)/make_tangente.h $(HDSDIR)/tangent

@echo "I'm compiling make_tangente.c ... "

@$(CC) -I$(HDSDIR) $(CCFLAGS) -o $(OBJDIR)/make_tangente.o $(SRCDIR)/make_tangente.c

$(OBJDIR)/menu.o: $(SRCDIR)/menu.c $(HDSDIR)/menu.h

@echo "I'm compiling menu.c ... "

@$(CC) -I$(HDSDIR) $(CCFLAGS) -o $(OBJDIR)/menu.o $(SRCDIR)/menu.c

....

$(OBJDIR)/make_fattoriale.o: $(SRCDIR)/make_fattoriale.c $(HDSDIR)/make_fattoriale.h $(HDSDIR)/m

@echo "I'm compiling make_fattoriale.c ... "

@$(CC) -I$(HDSDIR) $(CCFLAGS) -o $(OBJDIR)/make_fattoriale.o $(SRCDIR)/make_fattoriale.c

clean :

@echo " I'm deleting all the .o and the executable"

@rm -f $(OBJDIR)/divisione.o

@rm -f $(OBJDIR)/coseno.o

@rm -f $(OBJDIR)/make_seno.o

@rm -f $(OBJDIR)/make_tangente.o

...

@rm -f $(OBJDIR)/tangente.o

@rm -f $(OBJDIR)/make_media.o

@rm -f $(OBJDIR)/make_fattoriale.o

@rm -f $(EXEDIR)/calcolatrice

Iniziamo ad esaminare come è fatto un Makefile.

Per prima cosa, le righe che iniziano con il simbolo #, sono dei commenti
Nella prima parte del Makefile vengono definite delle variabili tra cui notiamo
- CC=gcc che definisce il compilatore,
- WARN=-Wall che attiva tutti i possibili warning
- DEBUG= al momento vuoto ma se si vuole usare il debugger (p. es. gdb + wrapper DDD) da valorizzare con -g
- OPT=-O3 livello di ottimizzazione del codice
- CCFLAGS = -c ${DEBUG} ${OPT} ${WARN} i flag di compilazione (come negli script bash il valore della variabile lo si ottiene con ${})
- LDFLAGS = -lm sono i flag di linking e dove mettere tutte le libreire usate nel codice
- SRCDIR = src la cartella dei sorgenti
- HDSDIR = hdr la cartella degli headers
- OBJDIR = obj la caretella degli oggetti (.o)
- EXEDIR = . la cartella in cui si vuole posizionare l’eseguibile
- SRCS conterrà tutta la lista dei sorgenti
- HDSS la lista degli headers
- OBJS la lista degli oggetti
- PROGRAM = $(EXEDIR)/calcolatrice definisce l’eseguibile
Da questo punto in poi, il comando make, che compila il nostro codice tramite il Makefile controlla, secondo quanto riportato sempre nel Makefile, se un risultato è più recente dei file che dovevano produrlo:
$(PROGRAM): $(OBJS) $(SRCS) se ${PROGRAM} non esiste o è più vecchi degli ${OBJS} e ${SRCS}, secondo le regole riportate nelle righe successive si genera l’eseguibile (si noti che le righe con le istruzioni devono iniziare con il caratter TAB (\t)
Se ${PROGRAM} è precedente, si passa alle righe successive
$(OBJDIR)/divisione.o: $(SRCDIR)/divisione.c $(HDSDIR)/divisione.h, come prima, se divisione.o è precedente rispetto a divisione.c o divisione.h viene compilato secondo le righe successive, altrimenti si salta.
Allo stesso modo si procede per tutti i file
Quando saranno tutti aggiornati si ritorna alla riga di ${PROGRAM} per genera l’eseguibile
L’essere un risultato precedente ai file che lo possono aver generato, indica che i sorgenti sono stati modificati e quindi bisogna ri-generare il risultato.
make clean consente di cancellare oggetti ed eseguibile

Per compilare il programma è sufficiente eseguire il comando make. (Se non lo avete installato tramite il comando sudo apt-get install make, lo potrete installare).

Tutti i sorgenti modificati saranno compilati ed alla fine si otterrà l’eseguibile.

Il Makefie potreste scriverlo tramite un text editor ma nel repository GitHub troverete l’eseguibile makeMakefile che potrà farlo per voi.

Fig3 – Configurazione makeMakefile

La prima volta che gira vedrete una schermata come quella di Fig3.

Selezionando 1 inserirete src, 2 hdr e 3 obj, come cartella dell’eseguibile potete lasciare quella corrente (.) e tramite 5 inserirete il nome dell’eseguibile (calcolatrice), ottenendo qualcosa del genere:

Fig4 – makeMakefile configurato

a questo punto selezionando 0, genererete il vostro Makefile in modo automatico.

Viene anche scritto un piccolo file di configurazione makeMakefile.conf, che contiene queste impostazioni. Da adesso in poi, ogni volta che aggiungerete sorgenti o .h, sarà sufficiente far rigirare maleMakefile che aggiornerà tutto il progetto compreso il Makefile. Per compilare sarà sufficiente eseguire il comando make.

Se volete salvare il progetto occupando il meno spazio possibile (come farò io per generre l’archivio su GitHub), prima eseguite make clean che cancella eseguibile e .o e salvate.

Per rigenerare l’eseguibile, ovviamente basterà eseguire make.

Questo è tutto.

Siamo al momento vero degli arrivederci. E’ stato un piacere produrre questo corso e spero che per voi leggerlo sia stato un po’ interessante. Critche e commenti saranno sempre benvenuti e se c’è qualcosa che potrebbe essere esposto meglio, spero me lo comunichiate, per rendere questo lavoro anche utile.

Come ogni volta ricordiamo:

qui il forum di supporto al corso.
Se vuoi restare aggiornato, seguici anche sui nostri social: Facebook, Twitter, Youtube
Se vuoi anche trovare prodotti e accessori Raspberry Pi in offerta, seguici anche su Telegram !!

Arrivederci

arkkimede

RaspberryItaly Community Italiana

Lezione 9 – Arrivederci (make & Makefile)

Organizzazione della directory di lavoro

A proposito di arkkimede

Vedi Anche

MagPi in Italiano! Gioca ai Classici Horror Retrò su Raspberry Pi 5