Tipi di Dato in C

Ci sono parecchi modi per conservare dati in C, e sono tutti diversi l'uno dall'altro. I tipi di dato in cui le informazioni possono essere archiviate sono chiamati "data types". C perdona molto meno rispetto ad altri linguaggi per quanto riguarda i tipi di dato. Ne consegue che è importante comprendere i tipi di dato esistenti, le loro capacità e i loro limiti.

Una stranezza dei tipi di dato in C è che dipendono interamente dall'hardware sul quale stai eseguendo il codice. Un int nel tuo laptop sarà più piccolo rispetto a un int in un supercomputer, quindi conoscere i limiti dell'hardware sul quale stai lavorando è importante. Questa è anche la ragione per la quale i tipi di dato sono definiti con valori limite minimi e massimi - un valore int, come imparerai, potrà contenere valori da  -32767 a 32767; su certe macchine sarà però in grado di conservare valori anche eccedenti.

Ci sono due categorie in cui possiamo suddividere valori numerici: interi (integers) e in virgola mobile (floating points numbers). Gli interi sono numeri interi. Possono essere positivi, negativi oppure zero. Numeri come -321, 497, 19345, e -976812 sono tutti perfettamente validi, mentre 4.5 non lo è perché non è un numero intero.

I numeri in virgola mobile sono numeri con decimali. Comprendono anche i numeri interi, -321, 497, 19345, e -976812 che sono tutti validi, ma anche 4,5, 0,0004, -324,984, e altri numeri non interi sono validi.

C ci consente di scegliere tra parecchie opzioni per i nostri tipi di dato in quanto sono tutti conservati nel computer in modi diversi. Ne consegue che è importante conoscere limiti e capacità di ciascun tipo di dato per potere scegliere quello più appropriato.

Tipi di dato Interi

Caratteri: char

char contiene caratteri - cose come lettere, punteggiatura e spazi. In un computer i caratteri sono conservati come numeri, pertanto char contiene valori interi che rappresentano caratteri. L'effettiva transcodifica viene descritta dallo standard ASCII. Ecco una comoda tabella per cercare corrispondenze.

La dimensione reale, come tutti gli altri tipi di dato in C, dipende dall'hardware sul quale stai lavorando. Come minimo è di 8 bit, quindi contiene valori da 0 a 127. In alternativa si può usare un char con segno (signed char) che può contenere valori da  -128 a 127.

Interi Standard: int

La quantità di memoria che può utilizzare un singolo int dipende dall'hardware. Tuttavia puoi aspettarti che un int sia almeno di 16 bit. Il che vuol dire che può conservare valori da -32,768 a 32,767, o più a seconda dell'hardware.

Come per tutti gli altri tipi di dato c'è una variante senza segno (unsigned) che può essere usata. Il dato contenuto in un tipo unsigned int può essere positivo e zero ma non negativo, quindi può contenere valori da 0 a 65,535, o più a seconda dell'hardware.

Interi Corti: short

Questo tipo di dato non viene usato spesso, ma è meglio sapere che esiste. Come l'int può conservare valori da -32768 a 32767. Diversamente da int, tuttavia, queste sono tutte le sue capacità. Ogniqualvolta puoi usare short, puoi anche usare int.

Interi Lunghi: long

Il tipo di dato long conserva interi come il tipo int, ma offre una gamma di valori maggiore al costo di più memoria. long usa almeno 32 bit, e può quindi contenere valori da -2,147,483,648 a 2,147,483,647. In alternativa puoi usare unsigned long per una gamma di valori da 0 a 4,294,967,295.

Interi Ancora Più Lunghi: long long

Il tipo di dato long long è esagerato per quasi tutte le applicazioni, ma C ti consente comunque di usarlo. È in grado di conservare valori da  −9,223,372,036,854,775,807 a 9,223,372,036,854,775,807. In alternativa, esagerando ulteriormente, c'è il tipo senza segno unsigned long long, che conserva valori da 0 a 18,446,744,073,709,551,615.

Tipi di Dato in Virgola Mobile

Numeri in Virgola Mobile Base: float

float richiede almeno 32 bit per conservare il dato, ma offre fino a 6 cifre decimali da 1.2E-38 a 3.4E+38.

Doppi: double

double richiede il doppio di memoria rispetto a float (quindi almeno 64 bit). In cambio può offrire fino a 15 cifre decimali da 2.3E-308 a 1.7E+308.

Ottenere una gamma più ampia di double: long double

long double richiede almeno 80 bit. Pertanto può contenere fino a 19 cifre decimali da 3.4E-4932 a 1.1E+4932.

Scegliere il tipo di dato giusto

C ti fa scegliere il tipo di dato e ti fa essere molto specifico e intenzionale sul modo in cui lo fai. Questo ti dà molto potere sul tuo codice, ma è importante scegliere quello giusto.

In generale, dovresti scegliere il tipo minimo per il tuo scopo. Se sai che conterai interi da 1 a 10, non ti serve un long e neppure un double. Se sai che non avrai mai valori negativi, appoggiati alle varianti unsigned dei rispettivi tipi di dato. Fornendo questa funzionalità invece che facendolo automaticamente, C è in grado di produrre codice molto leggero ed efficiente. Tuttavia dipende da te, come programmatore, capire capacità e limiti e scegliere in modo appropriato.

Possiamo usare la funzione sizeof() per verificare la dimensione di una variabile. Dai un'occhiata al seguente programma in  C che mostra l'utilizzo dei diversi tipi:

#include <stdio.h>

int main()
{
    int a = 1;
    
    char b ='G';
    
    double c = 3.14;
    
    printf("Hello World!\n");
 
    //stampa le variabili definite qui sopra assieme alle loro dimensioni
    printf("Ciao! Sono un carattere. Il mio valore è %c e "
           "la mia dimensione è %lu byte.\n", b,sizeof(char));
    //puoi anche usare sizeof(b) qui sopra
 
    printf("Ciao! Sono un intero. Il mio valore è %d e "
           "la mia dimensione è %lu  byte.\n", a,sizeof(int));
    //puoi anche usare sizeof(a) qui sopra
 
    printf("Ciao! Sono una variabile in virgola mobile."
           " Il mio valore è %lf e la mia dimensione è %lu byte.\n",c,sizeof(double));
    //puoi anche usare sizeof(c) qui sopra
 
    printf("Ciao! A presto. :)\n");
    return 0;
}

Risultato:

Hello World!
Ciao! Sono un carattere. Il mio valore è G e la mia dimensione è 1 byte.
Ciao! Sono un intero. Il mio valore è 1 e la mia dimensione è 4  byte.
Ciao! Sono una variabile in virgola mobile. Il mio valore è 3.140000 e la mia dimensione è 8 byte.
Ciao! A presto. :)

Il Tipo Void

void specifica che non c'è un valore disponibile. Viene usato in tre tipi di situazione:

1. Funzione che ritorna void

Ci sono varie funzioni in C che non restituiscono alcun valore oppure puoi dire che restituiscono void. Una funzione senza valore di ritorno ha il tipo di valore ritornato void. Per esempio, void exit (int status);

2. Argomenti di funzione come void

Diverse funzioni in C non accettano parametri. Una funzione senza parametri può accettare un void. Per esempio, int rand(void);

3. Puntatori a void

Un puntatore di tipo void * rappresenta l'indirizzo di un oggetto, ma non il suo tipo. Per esempio una funzione di allocazione di memoria void *malloc( size_t size); ritorna un puntatore a void, che può essere convertito in qualsiasi altro tipo di dato.

I puntatori sono probabilmente la funzionalità di C più difficile da capire. Tuttavia sono una delle funzionalità che rendono C un linguaggio eccellente.

In questo articolo, partiremo dagli aspetti base dei puntatori fino ad arrivare al loro utilizzo con array, funzioni e strutture.

Quindi rilassati, prendi un caffè, e preparati per imparare tutto sui puntatori.

Sommario

A. Fondamenti

1. Cosa sono esattamente i puntatori?
2. Definizione e Notazione
3. Alcuni Puntatori Speciali
4. Puntatori Aritmetici

B. Array e Stringhe

1. Perché puntatori e array?
2. Array 1-D
3. Array 2-D
4. Stringhe
5. Array di Puntatori
6. Puntatori ad Array

C. Funzioni

1. Chiamata per Valore vs. Chiamata per Riferimento
2. Puntatori come Argomenti di Funzione
3. Puntatori come Valori di Ritorno da Funzione
4. Puntatore a Funzione
5. Array di Puntatori a Funzioni
6. Puntatore a Funzione come Argomento

D. Strutture

1. Puntatore a Struttura
2. Array di Strutture
3. Puntatore a Struttura come Argomento

E. Puntatore a Puntatore

F. Conclusione

A. Fondamenti

1. Cosa sono esattamente i puntatori?

Prima di passare alla definizione di puntatori, cerchiamo di capire cosa avviene quando scriviamo il seguente codice:

int digit = 42;

Un blocco di memoria è riservato dal compilatore per conservare un valore int. Il nome del blocco è digit e il valore assegnato a questo blocco è 42.

Ora, per ricordare il blocco, a esso viene assegnato un indirizzo o un numero di posizione (diciamo 24650).

Il valore del numero di posizione non è importante per noi, visto che è un valore casuale. Tuttavia possiamo accedere a questo indirizzo usando il carattere & (e commerciale) o indirizzo dell'operatore.

printf("Indirizzo di digit = %d.",&digit);
 /* stampa "Indirizzo di digit = 24650. */

Possiamo ottenere il valore della variabile digit dal suo indirizzo usando un altro operatore, * (asterisco), chiamato operatore di riferimento indiretto o dereferenziazione o valore all'indirizzo.

printf("Valore di digit = %d.", *(&digit);
 /* stampa "Valore di digit = 42. */

2. Definizione e Notazione

L'indirizzo di una variabile può essere conservato in un'altra variabile nota come variabile puntatore. La sintassi per conservare l'indirizzo di una variabile in un puntatore è:

tipoDato *nomeVariabilePuntatore = &nomeVariabile;

Per la nostra variabile digit, ciò si può scrivere in questo modo:

int *addressOfDigit = &digit;

oppure:

int *addressOfDigit;
addressOfDigit= &digit;

Questo si può leggere come  - Un puntatore a int (intero) addressOfDigit conserva l' indirizzo (addressOf(&)) della variabile digit.

Alcuni punti da capire:

tipoDato – Dobbiamo dire al computer quale tipo di dato conterrà la variabile il cui indirizzo andremo a conservare. In questo caso int era il tipo di dato di  digit.

Questo non vuol dire che addressOfDigit conserverà un valore di tipo int. Un puntatore a intero (come addressOfDigit) può solo conservare l'indirizzo di variabili di tipo int.

int variable1;
int variable2;
char variable3;
int *addressOfVariables;

* – Una variabile puntatore è una variabile speciale nel senso che viene usata per conservare un indirizzo di un'altra variabile. Per differenziarla dalle altre variabili che non conservano un indirizzo, usiamo * come simbolo nella dichiarazione.

Qui possiamo assegnare l'indirizzo di  variable1 e variable2 al puntatore di interi addressOfVariables ma non variable3 visto che è di tipo char. Ci serverebbe una variabile puntatore a carattere per contenere il suo indirizzo.

Possiamo usare la nostra variabile puntatore addressOfDigit per stampare l'indirizzo e il valore di  digit in questo modo:

printf("Indirizzo di digit = %d.", addressOfDigit);
 /* stampa "Indirizzo di digit = 24650." */
printf("Valore di digit = %d.", *addressOfDigit);
 /* stampa "Valore di digit = 42. */

Qui, *addressOfDigit può essere letto come il valore all'indirizzo conservato in addressOfDigit.

Nota che abbiamo usato %d come identificatore di formato per addressOfDigit. In effetti questo non è completamente corretto. L'identificatore corretto sarebbe %p.

Usando %p, l'indirizzo viene visualizzato come valore esadecimale. Un indirizzo di memoria può tuttavia essere visualizzato anche come intero oppure come valore ottale. Per questo, visto che non è il modo interamente corretto, viene mostrato un avvertimento.

int num = 5;
int *p = #
printf("Indirizzo usando %%p = %p",p);
printf("Indirizzo usando %%d = %d",p);
printf("Indirizzo usando %%o = %o",p);

Questo il risultato in base al compilatore che sto usando:

Indirizzo usando %p = 000000000061FE00
Indirizzo usando %d = 6422016
Indirizzo usando %o = 30377000

Questo è l'avvertimento mostrato quando usi  %d - " warning: format '%d' expects argument of type 'int', but argument 2 has type 'int *' " ("avvertimento: format %d si aspetta argomenti di tipo 'int', ma l'argomento 2 è di tipo 'int *').

3. Alcuni Puntatori Speciali

Il Puntatore Selvaggio

char *alphabetAddress; /* non inizializzato o puntatore selvaggio */
char alphabet = "a";
alphabetAddress = &alphabet; /* ora non più puntatore selvaggio */

Quando abbiamo definito il nostro puntatore a carattere alphabetAddress, non lo abbiamo inizializzato.

Tali puntatori sono noti come puntatori selvaggi (wild pointers). Conservano un valore spazzatura (vale a dire l'indirizzo di memoria) di un byte che non sappiamo se sia riservato o meno (ricorda int digit = 42;, abbiamo riservato un indirizzo di memoria quando l'abbiamo dichiarata).

Supponiamo di dereferenziare un puntatore selvaggio e di assegnare un valore all'indirizzo di memoria al quale sta puntando. Questo provocherà un comportamento inatteso visto che andremo a scrivere dati in un blocco di memoria che potrebbe essere libero oppure riservato.

Puntatore Null

Per assicurarci di non avere un puntatore selvaggio, possiamo inizializzare un puntatore con un valore NULL , rendendolo un puntatore null (null pointer).

char *alphabetAddress = NULL /* Puntatore null */ 

Un puntatore null punta al nulla, oppure a un indirizzo di memoria al quale gli utenti non possono accedere.

Puntatore Void

Un puntatore void può essere usato per puntare a una variabile associata a qualsiasi tipo di dato. Può essere riutilizzato per puntare a qualsiasi tipo di dato vogliamo. Viene dichiarato in questo modo:

void *puntatoreANomeVariabile = NULL;

Vista la loro natura molto generica, sono anche noti come puntatori generici (generic pointers).

Con la loro flessibilità, i puntatori void sono anche dotati di qualche vincolo. I puntatori void non possono essere dereferenziati come qualsiasi altro puntatore. È necessaria un'appropriata conversione di tipo (typecasting).

void *pointer = NULL;
int number = 54;
char alphabet = "z";
pointer = &number;
printf("Il valore di number = ", *pointer); /* Errore di compilazione */
/* Metodo corretto */
printf("Il valore di number = ", *(int *)pointer); /* stampa "Il valore di number = 54" */
pointer = &alphabet;
printf("Il valore di alphabet = ", *pointer); /* Errore di compilazione */
printf("Il valore di alphabet = ", *(char *)pointer); /* stampa "Il valore di alphabet = z */

Allo stessa stregua, i puntatori void richiedono una conversione di tipo per eseguire operazioni aritmetiche.

I puntatori void sono di grande uso in C. Funzioni di libreria come malloc() e calloc() che allocano dinamicamente memoria, ritornano puntatori void. qsort(), una funzione integrata di ordinamento in C, riceve una funzione come suo argomento che a sua volta riceve puntatori void come suoi argomenti.

Puntatori Pendenti

Un puntatore pendente (dangling pointer) punta a un indirizzo di memoria in uso per conservare una variabile. Visto che l'indirizzo a cui punta non è più riservato, l'uso potrebbe portare a risultati inaspettati.

main(){
  int *ptr;
  ptr = (int *)malloc(sizeof(int));
  *ptr = 1;
  printf("%d",*ptr); /* stampa 1 */
  free(ptr); /* deallocazione */
  *ptr = 5;
  printf("%d",*ptr); /* potrebbe o non potrebbe stampare 5 */
}

Anche se la memoria è stata deallocata da free(ptr), il puntatore a intero ptr punta ancora a quell'indirizzo di memoria non più riservato.

4. Puntatori Aritmetici

Ora sappiamo che i puntatori non sono come le altre variabili. Non conservano alcun valore, ma l'indirizzo di blocchi di memoria.

Pertanto dovrebbe essere piuttosto chiaro che non tutte le operazioni aritmetiche sarebbero valide con essi. Avrebbe senso moltiplicare o dividere due puntatori (che contengono indirizzi)?

I puntatori hanno poche ma immensamente utili operazioni valide:

1. Si può assegnare il valore di un puntatore a un altro solo se sono dello stesso tipo (a meno che non siano oggetto di conversione di tipo oppure uno di essi sia void *).

int ManU = 1;
int *addressOfManU = &ManU;
int *anotherAddressOfManU = NULL;
anotherAddressOfManU = addressOfManU; /* Valido */
double *wrongAddressOfManU = addressOfManU; /* Non Valido */

2.   Puoi solo aggiungere o sottrarre interi ai puntatori.

int myArray = {3,6,9,12,15};
int *pointerToMyArray = &myArray[0];
pointerToMyArray += 3; /* Valido */
pointerToMyArray *= 3; /* Non Valido */

Quando aggiungi (o sottrai) un intero (diciamo n) a un puntatore, non stai effettivamente aggiungendo (o sottraendo) n byte al valore del puntatore. Stai in realtà aggiungendo (o sottraendo) n-volte in byte la dimensione del tipo di dato della variabile puntata.

int number = 5;
 /* Supponiamo che l'indirizzo di number sia 100 */
int *ptr = &number;
int newAddress = ptr + 3;
 /* Uguale a ptr + 3 * sizeof(int) */

Il valore conservato in newAddress non sarà 103, ma 112.

3. La sottrazione e il confronto di puntatori è valida solo se entrambi sono membri dello stesso array. La sottrazione tra puntatori fornisce il numero di elementi che li separano.

int myArray = {3,6,9,12,15};
int sixthMultiple = 18;
int *pointer1 = &myArray[0];
int *pointer2 = &myArray[1];
int *pointer6 = &sixthMuliple;
 /* Espressione valida */
if(pointer1 == pointer2)
pointer2 - pointer1;
 /* Espressione non valida */
if(pointer1 == pointer6)
pointer2 - pointer6

4.  Puoi assegnare o confrontare un puntatore con  NULL.

L'unica eccezione alle regole qui sopra è che l'indirizzo del primo blocco di memoria dopo l'ultimo elemento di un array segua un puntatore aritmetico.

Puntatori e array coesistono. Queste valide manipolazioni di puntatori sono immensamente utili con gli array, e le discuteremo nella prossima sezione.

B. Array e Stringhe

1. Perché puntatori e array?

In C, i puntatori e gli array hanno una relazione piuttosto forte.

La ragione per la quale dovrebbero essere discussi insieme è che quello che puoi ottenere con la notazione di array (nomeArray[indice]) può anche essere ottenuto con i puntatori, in genere più velocemente.

2. Array 1-D

Osserviamo cosa succede quando scriviamo int myArray[5];.

Cinque blocchi consecutivi di memoria a partire da myArray[0] fino a myArray[4] sono creati con valori spazzatura al loro interno. Ciascun blocco ha una dimensione di 4 byte.

Pertanto se l'indirizzo di myArray[0] è, diciamo, 100, l'indirizzo dei restanti blocchi sarebbe 104, 108, 112 e 116.

Dai un'occhiata al seguente codice:

int prime[5] = {2,3,5,7,11};
printf("Risultato usando &prime = %d\n",&prime);
printf("Risultato usando prime = %d\n",prime);
printf("Risultato usando &prime[0] = %d\n",&prime[0]);

/* Output */
Risultato usando &prime = 6422016
Risultato usando prime = 6422016
Risultato usando &prime[0] = 6422016

Quindi, &prime, prime, e &prime[0] danno tutti lo stesso indirizzo, giusto? Bene, aspetta e continua a leggere, perché avrai una sorpresa (e forse un po' di confusione).

Cerchiamo di incrementare  &prime, prime, e &prime[0] di 1.

printf("Risultato usando &prime = %d\n",&prime + 1);
printf("Risultato usando prime = %d\n",prime + 1);
printf("Risultato usando &prime[0] = %d\n",&prime[0] + 1);

/* Output */
Risultato usando &prime = 6422036
Risultato usando prime = 6422020
Risultato usando &prime[0] = 6422020

Aspetta! Come mai il risultato di &prime + 1 è diverso dagli altri due? Perché prime + 1 e &prime[0] + 1 sono ancora uguali? Rispondiamo a queste domande.

prime e &prime[0] puntano entrambi all'elemento 0 dell'array prime. Quindi il nome stesso di un array è a sua volta un puntatore all'elemento 0 dell' array.

Qui entrambi puntano al primo elemento di 4 byte di dimensione. Quando aggiungi 1 ad essi, ora puntano all'elemento con indice 1 dell'array. Ne consegue un aumento nell'indirizzo di 4.

&prime, d'altro canto, è un puntatore a un array int di dimensione 5. Conserva l'indirizzo base dell'array prime[5], che è uguale all'indirizzo del primo elemento. Pertanto un aumento di 1 risulta in un indirizzo con un aumento di 5 x 4 = 20 byte.

In breve, arrayName e &arrayName[0] puntano all'elemento 0 mentre  &arrayName punta all'intero array.

Possiamo accedere agli elementi dell'array usando variabili indicizzate come questa:

int prime[5] = {2,3,5,7,11};
for( int i = 0; i < 5; i++)
{
  printf("indice = %d, indirizzo = %d, valore = %d\n", i, &prime[i], prime[i]);
}

Possiamo fare la stessa cosa usando i puntatori che sono sempre più veloci rispetto all'uso dell'indicizzazione.

int prime[5] = {2,3,5,7,11};
for( int i = 0; i < 5; i++)
{
  printf("indice = %d, indirizzo = %d, valore = %d\n", i, prime + i, *(prime + i));
}

Entrambi i metodi danno questo risultato:

indice = 0, indirizzo = 6422016, valore = 2
indice = 1, indirizzo = 6422020, valore = 3
indice = 2, indirizzo = 6422024, valore = 5
indice = 3, indirizzo = 6422028, valore = 7
indice = 4, indirizzo = 6422032, valore = 11

Quindi &arrayName[i] e arrayName[i] sono lo stesso di  arrayName + i e  *(arrayName + i), rispettivamente.

3. Array 2-D

Gli array bidimensionali sono array di array.

int marks[5][3] = { { 98, 76, 89},
                    { 81, 96, 79},
                    { 88, 86, 89},
                    { 97, 94, 99},
                    { 92, 81, 59}
                  };

Si può pensare a marks come un array di 5 elementi, ognuno dei quali è un array monodimensionale che contiene 3 interi. Lavoreremo su una serie di programmi per comprendere le diverse espressioni di indicizzazione.

printf("L'indirizzo dell'intero array 2-D = %d\n", &marks);
printf("L'aggiunta di 1 risulta in %d\n", &marks +1);

/* Output */
L'indirizzo dell'intero array 2-D = 6421984
L'aggiunta di 1 risulta in 6422044

Come con gli array 1-D, &marks punta all'intero array 2-D, marks[5][3]. Pertanto incrementando di 1 ( = 5 array x 3 interi ciascuno x 4  byte = 60) risulta un aumento di 60 byte.

printf("Indirizzo dell'array 0 = %d\n", marks);
printf("L'aggiunta di 1 risulta in %d\n", marks +1);
printf("Indirizzo dell'array 0 =%d\n", &marks[0]);
printf("L'aggiunta di 1 risulta in %d\n", &marks[0] + 1);

/* Output */
Indirizzo dell'array 0 = 6421984
L'aggiunta di 1 risulta in 6421996
Indirizzo dell'array 0 = 6421984
L'aggiunta di 1 risulta in 6421996

Se marks fosse un array 1-D, marks e &marks[0] avrebbero puntato allo stesso elemento 0 . Per un array 2-D, gli elementi ora sono array 1-D. Di conseguenza, marks e &marks[0] puntano all'elemento dell'array con indice  0 , e l'aggiunta di 1 punta al primo array.

printf("Indirizzo dell'elemento 0 dell'array 0 = %d\n", marks[0]);
printf("L'aggiunta di 1 risulta in %d\n", marks[0] + 1);
printf("Indirizzo dell'elemento 0 del primo array = %d\n", marks[1]);
printf("L'aggiunta di 1 risulta in %d\n", marks[1] + 1);

 /* Output */
Indirizzo dell'elemento 0 dell'array 0 = 6421984
L'aggiunta di 1 risulta in 6421988
Indirizzo dell'elemento 0 del primo array = 6421996
L'aggiunta di 1 risulta in 6422000

Ora viene la differenza. Per un array 1-D, marks[0] darebbe il valore dell'elemento 0. Un incremento di 1 aumenterebbe il valore di 1.

Ma in un array 2-D , marks[0] punta all'elemento 0 dell'array 0. In modo simile,  marks[1] punta all'elemento 0 del primo array. Un incremento di 1 punterebbe al primo elemento del primo array.

printf("Valore dell'elemento 0 dell'array 0 = %d\n", marks[0][0]);
printf("L'aggiunta di 1 risulta in %d", marks[0][0] + 1);

/* Output */
Valore dell'elemento 0 dell'array 0 = 98
L'aggiunta di 1 risulta in 99

Questa è la parte nuova,  marks[i][j] fornisce il valore dell'elemento j dell'array i. Un incremento a esso cambia il valore conservato in marks[i][j]. Ora proviamo a scrivere marks[i][j] in termini di puntatori.

Sappiamo dalla nostra precedente discussione che marks[i] + j punterebbe all'elemento i dell'array j. Dereferenziandolo significherebbe ottenere il valore a quell'indirizzo. Pertanto marks[i][j] è uguale a *(marks[i] + j).

Dalla nostra discussione sugli array 1-D, marks[i] è uguale a *(marks + i). Quindi marks[i][j] può essere scritto come *(*(marks + i) + j) in termini di puntatori.

Ecco un riepilogo delle notazioni a confronto per gli array monodimensionali e bidimensionali.

4. Stringhe

Una stringa è un array monodimensionale di caratteri che finisce con un carattere null (\0). Quando scriviamo char name[] = "Srijan";, ciascun carattere occupa un byte di memoria con l'ultimo che è sempre \0.

In modo simile agli array visti in precedenza, name e &name[0] puntano al carattere a indice 0 nella stringa mentre &name punta all'intera stringa. Inoltre,  name[i] può essere scritto come *(name + i).

/* Array di Stringhe */
char top[6][15] = {
                    "Liverpool",
                    "Man City",
                    "Man United",
                    "Chelsea",
                    "Leicester",
                    "Tottenham"
                  };

printf("Puntatore a un array 2-D = %d\n", &top);
printf("L'aggiunta di 1 risulta in %d\n", &top + 1);

 /* Output */
// Puntatore a un array 2-D = 6421952
// L'aggiunta di 1 risulta in 6422042

printf("Puntatore all'indice 0 della stringa = %d\n", &top[0]);
printf("L'aggiunta di 1 risulta in %d\n", &top[0] + 1);

 /* Output */
// Puntatore all'indice 0 della stringa = 6421952
// L'aggiunta di 1 risulta in 6421967

printf("Puntatore all'indice 0 della stringa = %d\n", top);
printf("L'aggiunta di 1 risulta in %d\n", top + 1);

 /* Output */
// Puntatore all'indice 0 della stringa = 6421952
// L'aggiunta di 1 risulta in 6421967

printf("Puntatore all'elemento a indice 0 della quarta stringa = %d\n", top[4]);
printf("Puntatore al primo elemento della quarta stringa = %c\n", top[4] + 1);

 /* Output */
// Puntatore all'elemento a indice 0 della quarta stringa = 6422012
// Puntatore al primo elemento della quarta stringa = 6422013

printf("Valore del primo carattere della terza stringa = %c\n", top[3][1]);
printf("Lo stesso usando puntatori = %c\n", *(*(top + 3) + 1));

 /* Output */
// Valore del primo carattere della terza stringa = h
// Lo stesso usando puntatori = h

Si può accedere e manipolare anche un array di caratteri bidimensionale oppure un array di stringhe come discusso prima.

/* Array di Stringhe */
char top[6][15] = {
                    "Liverpool",
                    "Man City",
                    "Man United",
                    "Chelsea",
                    "Leicester",
                    "Tottenham"
                  };

printf("Puntatore a un array 2-D = %d\n", &top);
printf("L'aggiunta di 1 risulta in %d\n", &top + 1);

 /* Output */
// Puntatore a un array 2-D = 6421952
// L'aggiunta di 1 risulta in 6422042

printf("Puntatore all'indice 0 della stringa = %d\n", &top[0]);
printf("L'aggiunta di 1 risulta in %d\n", &top[0] + 1);

 /* Output */
// Puntatore all'indice 0 della stringa = 6421952
// L'aggiunta di 1 risulta in 6421967

printf("Puntatore all'indice 0 della stringa = %d\n", top);
printf("L'aggiunta di 1 risulta in %d\n", top + 1);

 /* Output */
// Puntatore all'indice 0 della stringa = 6421952
// L'aggiunta di 1 risulta in 6421967

printf("Puntatore all'elemento a indice 0 della quarta stringa = %d\n", top[4]);
printf("Puntatore al primo elemento della quarta stringa = %c\n", top[4] + 1);

 /* Output */
// Puntatore all'elemento a indice 0 della quarta stringa = 6422012
// Puntatore al primo elemento della quarta stringa = 6422013

printf("Valore del primo carattere della terza stringa = %c\n", top[3][1]);
printf("Lo stesso usando puntatori = %c\n", *(*(top + 3) + 1));

 /* Output */
// Valore del primo carattere della terza stringa = h
// Lo stesso usando puntatori = h

5. Array di Puntatori

Oltre agli array di tipo  int e  char, esiste anche un array di puntatori. Questo tipo di array sarebbe semplicemente una collezione di indirizzi. Questi indirizzi potrebbero puntare a variabili singole oppure a un altro array.

La sintassi per dichiarare un array di puntatori è la seguente:

tipoDato *nomeVariabile[dimensione];

/* Esempi */
int *example1[5];
char *example2[8];

Seguendo la precedenza degli operatori, il primo esempio potrebbe essere letto come -  example1 è un array([]) di 5 puntatori a int. In modo simile, example2 è un array di 8 puntatori a char.

Possiamo conservare un array di stringhe bidimensionale top usando un array di puntatori, risparmiando anche della memoria.

char *top[] = {
                    "Liverpool",
                    "Man City",
                    "Man United",
                    "Chelsea",
                    "Leicester",
                    "Tottenham"
                  };

top conterrà gli indirizzi base di tutti i rispettivi nomi. L'indirizzo base di  "Liverpool" sarà conservato in top[0], "Man City" in top[1], e così via.

Nella dichiarazione precedente, abbiamo richiesto 90 byte per conservare i nomi. Qui servono solo ( 58 (somma dei byte dei nomi) + 12 ( byte richiesti per conservare l'indirizzo nell'array) ) 70 byte.

La manipolazione di stringhe o interi diventa molto più facile quando si usa un array di puntatori.

Se proviamo a inserire "Leicester" davanti a "Chelsea", dobbiamo solo invertire i valori di  top[3] e top[4] in questo modo:

char *temporary;
temporary = top[3];
top[3] = top[4];
top[4] = temporary;

Senza puntatori, avremmo dovuto scambiare ogni carattere delle stringhe, il che avrebbe richiesto più tempo. Ecco perché le stringhe sono generalmente dichiarate usando i  puntatori.

6. Puntatori ad Array

Come i puntatori a int o i puntatori a char, abbiamo anche puntatori ad array. Questo puntatore punta all'intero array invece che ai suoi elementi.

Ricordi che abbiamo discusso di come &arrayName punti all'intero array? Ecco, si tratta di un puntatore ad array.

Un puntatore ad array può essere dichiarato in questo modo:

tipoDato (*nomeVariabile)[dimensione];

/* Esempi */
int (*ptr1)[5];
char (*ptr2)[15];

Nota le parentesi. Senza di esse, avremmo un array di puntatori. Il primo esempio può essere letto come  - ptr1 è un puntatore a un array di 5 int (interi).

int goals[] = { 85,102,66,69,67};
int (*pointerToGoals)[5] = &goals;
printf("Indirizzo conservato in pointerToGoals %d\n", pointerToGoals);
printf("Dereferenziandolo, otteniamo %d\n",*pointerToGoals);

/* Output */
Indirizzo conservato in pointerToGoals 6422016
Dereferenziandolo, otteniamo 6422016

Quando dereferenziamo un puntatore, otteniamo il valore a quell'indirizzo. Alla stessa stregua, dereferenziando un puntatore ad array, otteniamo l'array e il nome al quale punta l'array che punta all'indirizzo base. Possiamo confermare che *pointerToGoals fornisce l'array goals se troviamo la sua dimensione.

printf("Dimensione di goals[5] = %d, *pointerToGoals);

/* Output */
Dimensione di goals[5] = 20

Se lo dereferenziamo nuovamente, otterremo il valore conservato in quell'indirizzo. Possiamo stampare tutti gli elementi usando pointerToGoals.

for(int i = 0; i < 5; i++)
  printf("%d ", *(*pointerToGoals + i));

/* Output */
85 102 66 69 67

I puntatori e puntatori ad array sono piuttosto utili se accoppiati a funzioni. A seguire nella prossima sezione!

C. Funzioni

1. Chiamata per Valore vs. Chiamata per Riferimento

Dai un'occhiata al programma qui sotto:

#include <stdio.h>

int multiply(int x, int y){
  int z;
  z = x * y;
  return z;
}

main(){
  int x = 3, y = 5; 
  int product = multiply(x,y);
  printf("Prodotto = %d\n", product);
  /* stampa "Prodotto = 15" */
}

La funzione multiply() riceve due argomenti int e ritorna il loro prodotto come  int.

Nella chiamata a multiply(x,y), passiamo i valori di x e y (assegnati in main()), che sono gli effettivi argomenti, per multiply().

I valori degli effettivi argomenti sono passati o copiati negli argomenti formali x e y ( di multiply()).  x e y di multiply() sono diversi da quelli di main(). Questo si può verificare stampando i loro indirizzi.

#include <stdio.h>

int multiply(int x, int y){
  printf("Indirizzo di x in multiply() = %d\n", &x);
  printf("Indirizzo di y in multiply() = %d\n", &y);
  int z;
  z = x * y;
  return z;
}

main(){
  int x = 3, y = 5;
  printf("Indirizzo di x in main() = %d\n", &x);
  printf("Indirizzo di y in main() = %d\n", &y);
  int product = multiply(x,y);
  printf("Prodotto = %d\n", product);
}

/* Output */
Indirizzo di x in main() = 6422040
Indirizzo di y in main() = 6422036
Indirizzo di x in multiply() = 6422000
Indirizzo di y in multiply() = 6422008
Prodotto = 15

Visto che abbiamo creato valori conservati un una nuova posizione, ci costa memoria. Non sarebbe meglio se potessimo eseguire la stessa operazione senza sprecare spazio?

La chiamata per riferimento ci consente di farlo. Passiamo gli indirizzi o riferimenti delle variabili alla funzione, la quale non crea una copia. Usando l'operatore di dereferenziazione *, possiamo avere accesso al valore conservato in quegli indirizzi.

Possiamo anche riscrivere il programma qui sopra usando una chiamata per riferimento.

#include <stdio.h>

int multiply(int *x, int *y){
  int z;
  z = (*x) * (*y);
  return z;
}

main(){
  int x = 3, y = 5; 
  int product = multiply(&x,&y);
  printf("Prodotto = %d\n", product);
   /* Stampa "Prodotto = 15" */
}

2. Puntatori come Argomenti di Funzione

In questa sezione, esamineremo vari programmi nei quali passiamo valori di tipo int, char, array e stringhe come argomenti usando puntatori.

#include <stdio.h>

void add(float *a, float *b){
 float c = *a + *b;
 printf("L'addizione fornisce %.2f\n",c);
}

void subtract(float *a, float *b){
 float c = *a - *b;
 printf("La sottrazione fornisce %.2f\n",c);
}

void multiply(float *a, float *b){
 float c = *a * *b;
 printf("La moltiplicazione fornisce %.2f\n",c);
}

void divide(float *a, float *b){
 float c = *a / *b;
 printf("La divisione fornisce %.2f\n",c);
}

main(){
    printf("Digita due numeri :\n");
    float a,b;
    scanf("%f %f",&a,&b);
    printf("Cosa vuoi fare con questi numeri?\nAggiungi : a\nSottrai : s\nMoltiplica : m\nDividi : d\n");
    char operation = '0';
    scanf(" %c",&operation);
    printf("\nEseguo...\n\n");
    switch (operation) {
    case 'a':
        add(&a,&b);
        break;
    case 's':
        subtract(&a,&b);
        break;
    case 'm':
        multiply(&a,&b);
        break;
    case 'd':
        divide(&a,&b);
        break;
    default:
        printf("Input non valido!!!\n");

  }

}

Abbiamo creato quattro funzioni,  add(), subtract(), multiply() e divide() per eseguire operazioni aritmetiche su due numeri,  a e b.

Gli indirizzi di a e b sono passati alle funzioni. All'interno della funzione, usando  * abbiamo accesso ai valori e stampiamo il risultato.

In modo simile, possiamo passare array come argomenti usando un puntatore al loro primo elemento.

#include <stdio.h>

void greatestOfAll( int *p){
  int max = *p;
  for(int i=0; i < 5; i++){
    if(*(p+i) > max)
       max = *(p+i);
  }
  printf("L'elemento più grande è %d\n",max);
}
main(){
  int myNumbers[5] = { 34, 65, -456, 0, 3455};
  greatestOfAll(myNumbers);
   /* Stampa :L'elemento più grande è 3455" */
}

Visto che il nome dell'array è esso stesso un puntatore al primo elemento, lo passiamo come argomento alla funzione greatestOfAll(). Nella funzione qui sopra, iteriamo attraverso l'array tramite un ciclo e un puntatore.

#include <stdio.h>
#include <string.h>

void wish(char *p){
 printf("Buona giornata, %s",p);
}

main(){
 printf("Digita il tuo nome : \n");
 char name[20];
 gets(name);
 wish(name);
}

Qui sopra passiamo la stringa name a wish() tramite un puntatore e stampiamo il messaggio.

3. Puntatori come Valori di Ritorno da Funzione

#include <stdio.h>

int* multiply(int *a, int *b){
  int c = *a * *b;
  return &c;
}

main(){
  int a= 3, b = 5;
  int *c = multiply (&a,&b);
  printf("Prodotto = %d",*c);
}

La funzione multiply() riceve due parametri a  int. Anch'essa ritorna un puntatore a  int che conserva l'indirizzo nel quale il prodotto viene salvato.

È molto facile pensare che il risultato sia 15. Ma non lo è!

Quando viene chiamata multiply(), l'esecuzione di  main() viene messa in pausa e ora la memoria viene allocata per l'esecuzione di multiply(). Dopo che l'esecuzione è completata, la memoria allocata a  multiply() viene deallocata.

Pertanto, sebbene c ( locale a main()) conservi l'indirizzo del prodotto, non c'è garanzia che il dato sia ancora presente visto che la memoria è stata deallocata.

Quindi significa che i puntatori non possono essere ritornati da una funzione? No!

Possiamo fare due cose. Conservare l'indirizzo nello heap o sezione globale oppure dichiarare la variabile statica (static) in modo che il suo valore persista.

Le variabili statiche possono essere create semplicemente usando la parola chiave static prima del tipo di dato in fase di dichiarazione della variabile.

Per conservare indirizzi nello heap, possiamo usare le funzioni di libreria malloc() e calloc() che allocano memoria dinamicamente.

Il programma seguente spiega entrambi i metodi, che ritornano il risultato di 15.

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

/* Usando malloc() */

int* multiply(int *a, int *b){
  int *c = malloc(sizeof(int));
  *c = *a * *b;
  return c;
}

main(){
  int a= 3, b = 5;
  int *c = multiply (&a,&b);
  printf("Prodotto = %d",*c);
}

/* Usando la parola chiave static */
#include <stdio.h>

int* multiply(int *a, int *b){
  static int c;
  c = *a * *b;
  return &c;
}

main(){
  int a= 3, b = 5;
  int *c = multiply (&a,&b);
  printf("Prodotto = %d",*c);
}

4. Puntatore a Funzione

Come un puntatore a diversi tipi di dati, abbiamo anche un puntatore a funzione.

Un puntatore a funzione (function pointer) conserva l'indirizzo di una funzione. Tuttavia non punta ad alcun dato. Punta alla prima istruzione nella funzione.

La sintassi per dichiarare un puntatore a funzione è la seguente:

 /* Dichiarazione di un funzione */
tipoRitornato nomeFunzione(tipoParametro1, tipoParametro2, ...);

 /* Dichiarazione di un puntatore a funzione */
tipoRitornato (*nomePuntatore)(tipoParametro1, tipoParametro2, ...);
nomePuntatore = &nomeFunzione; /* oppure nomePuntatore = nomefunzione; */

L'esempio che segue chiarisce:

int* multiply(int *a, int *b)
{
    int *c = malloc(sizeof(int));
    *c = *a * *b;
    return c;
}

main()
{ 
    int a=3,b=5;
    int* (*p)(int*, int*) = &multiply; /* oppure int* (*p)(int*, int*) = multiply; */
    int *c = (*p)(&a,&b); /* oppure int *c = p(&a,&b); */
    printf("Prodotto = %d",*c);
}

La dichiarazione per il puntatore  p alla funzione multiply() può essere letto come (seguendo la precedenza degli operatori) - p è un puntatore a funzione con due puntatori di tipo int( oppure due puntatori a int) come parametri che ritorna un puntatore a int.

Visto che il nome della funzione è anche un puntatore alla funzione, l'uso di & non è necessario. Inoltre l'eliminazione di * dalla chiamata alla funzione non influisce sul programma.

5. Array di Puntatori a Funzioni

Abbiamo visto come creare un array di puntatori a  int, char, e così via. Allo stesso modo, possiamo creare un array di puntatori a funzione.

In questo array, ogni elemento conserverà un indirizzo di una funzione, dove tutte le funzioni sono dello stesso tipo. Vale a dire che hanno lo stesso numero di parametri e tipo dato di ritorno.

Andremo a modificare un programma che abbiamo esaminato in precedenza in questa sezione. Conserveremo gli indirizzi di add(), subtract(), multiply() e divide() in un array facendo una chiamata a funzione tramite indicizzazione.

#include <stdio.h>

void add(float *a, float *b){
 float c = *a + *b;
 printf("L'addizione fornisce %.2f\n",c);
}

void subtract(float *a, float *b){
 float c = *a - *b;
 printf("La sottrazione fornisce %.2f\n",c);
}

void multiply(float *a, float *b){
 float c = *a * *b;
 printf("La moltiplicazione fornisce %.2f\n",c);
}

void divide(float *a, float *b){
 float c = *a / *b;
 printf("La divisione fornisce %.2f\n",c);
}

main(){
    printf("Digita due numeri :\n");
    float a,b;
    scanf("%f %f",&a,&b);
    printf("Cosa vuoi fare con questi numeri?\nAggiungi : a\nSottrai : s\nMoltiplica : m\nDividi : d\n");
    char operation = '0';
    scanf(" %c",&operation);
    void (*p[])(float* , float*) = {add,subtract,multiply,divide};
    printf("\nEseguo...\n\n");
    switch (operation) {
    case 'a':
        p[0](&a,&b);
        break;
    case 's':
        p[1](&a,&b);
        break;
    case 'm':
        p[2](&a,&b);
        break;
    case 'd':
        p[3](&a,&b);
        break;
    default:
        printf("Input non valido!!!\n");

  }

}

Qui la dichiarazione può essere letta come - p è un array di puntatori a funzione con due puntatori float come parametri e valore di ritorno void.

6. Puntatore a Funzione come Argomento

Come qualsiasi altro puntatore, i puntatori a funzione possono anche essere passati a un'altra funzione, nota come funzione callback. La funzione dalla quale viene passata è nota come funzione chiamante.

Un modo migliore per capire sarebbe dare uno sguardo a qsort(), che è una funzione integrata in C. Viene usata per ordinare un array di interi, stringhe, strutture e così via. La dichiarazione per qsort() è:

void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void *));

qsort() riceve quattro argomenti:

1. un puntatore void verso l'inizio dell'array da ordinare
2. il numero di elementi
3. la dimensione di ciascun elemento
4. un puntatore a funzione che riceve due puntatori void come argomenti e ritorna un int

Il puntatore a funzione punta a una funzione di confronto che ritorna un intero maggiore di zero se il primo argomento è maggiore del secondo, un intero minore di zero se il secondo argomento è maggiore del primo e zero se sono uguali.

Il programma seguente mostra il suo utilizzo:

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

int compareIntegers(const void *a, const void *b)
{
  const int *x = a;
  const int *y = b;
  return *x - *y;
}

main(){

  int myArray[] = {97,59,2,83,19,97};
  int numberOfElements = sizeof(myArray) / sizeof(int);

  printf("Prima dell'ordinamento - \n");
  for(int i = 0; i < numberOfElements; i++)
   printf("%d ", *(myArray + i));

  qsort(myArray, numberOfElements, sizeof(int), compareIntegers);

  printf("\n\nDopo l'ordinamento - \n");
  for(int i = 0; i < numberOfElements; i++)
    printf("%d ", *(myArray + i));
 }

/* Output */

Prima dell'ordinamento -
97 59 2 83 19 97

Dopo l'ordinamento -
2 19 59 83 97 97

Visto che il nome di una funzione è esso stesso un puntatore, possiamo passare compareIntegers come quarto argomento.

D. Strutture

1. Puntatore a Struttura

Come i puntatori a intero, ad array e a funzione, abbiamo anche puntatori a struttura.

struct records {
    char name[20];
    int roll;
    int marks[5];
    char gender;
};

struct records student = {"Alex", 43, {76, 98, 68, 87, 93}, 'M'};

struct records *ptrStudent = &student;

Qui abbiamo dichiarato un puntatore ptrStudent di tipo struct records e abbiamo assegnato l'indirizzo di student a ptrStudent.

ptrStudent conserva l'indirizzo base di  student, che è l'indirizzo base del primo membro della struttura. Incrementando di 1 si incrementerebbe l'indirizzo di sizeof(student) byte.

printf("Indirizzo della struttura = %d\n", ptrStudent);
printf("Indirizzo del membro `name` = %d\n", &student.name);
printf("L'incremento di 1 risulta in %d\n", ptrStudent + 1);

/* Output */
Indirizzo della struttura = 6421984
Indirizzo del membro `name` = 6421984
L'incremento di 1 risulta in 6422032

Possiamo accedere ai membri di student usando ptrStudent in due modi: con il nostro vecchio amico* oppure usando -> ( infix oppure operatore freccia).

Con *, continueremo a usare .(operatore punto) laddove con -> non avremo bisogno dell'operatore punto.

printf("Nome senza usare ptrStudent : %s\n", student.name);
printf("Nome usando ptrStudent e * : %s\n", ( *ptrStudent).name);
printf("Nome usando ptrStudent e -> : %s\n", ptrStudent->name);

/* Output */
Nome senza usare ptrStudent: Alex
Nome usando ptrStudent e *: Alex
Nome usando ptrStudent e ->: Alex

Allo stesso modo possiamo accedere e modificare anche altri membri. Nota che le parentesi sono necessarie quando si usa * visto che l'operatore punto (.) ha maggiore precedenza rispetto a *.

2. Array di Strutture

Possiamo creare un array di tipo struct records e usare un puntatore per accedere agli elementi e ai loro membri.

struct records students[10];

 /* Puntatore al primo elemento (struttura) dell'array */
struct records *ptrStudents1 = &students;

 /* Puntatore a un array di 10 struct records */
struct records (*ptrStudents2)[10] = &students;

Nota che ptrStudent1 è un puntatore a student[0] laddove ptrStudent2 è un puntatore all'intero array di 10 struct records. Aggiungendo 1 a ptrStudent1 punterebbe a student[1].

Possiamo usare ptrStudent1 con un ciclo per iterare sugli elementi e i loro membri.

for( int i = 0; i <  10; i++)
  printf("%s, %d\n", ( ptrStudents1 + i)->name, ( ptrStudents1 + i)->roll);

3. Puntatore a Struttura come Argomento

Possiamo anche passare l'indirizzo di una variabile di tipo struttura a una funzione.

#include <stdio.h>

struct records {
    char name[20];
    int roll;
    int marks[5];
    char gender;
};

main(){
 struct records students = {"Alex", 43, {76, 98, 68, 87, 93}, 
'M'};
 printRecords(&students);
}

void printRecords( struct records *ptr){
  printf("Name: %s\n", ptr->name);
  printf("Roll: %d\n", ptr->roll);
  printf("Gender: %c\n", ptr->gender);
  for( int i = 0; i < 5; i++)
   printf("Marks in %dth subject: %d\n", i, ptr->marks[i]);
}

 /* Output */
Name: Alex
Roll: 43
Gender: M
Marks in 0th subject: 76
Marks in 1th subject: 98
Marks in 2th subject: 68
Marks in 3th subject: 87
Marks in 4th subject: 93

Nota che la struttura struct records viene dichiarata all'esterno di main(). Questo per assicurarsi che sia disponibile globalmente e possa essere usata da printRecords().

Se la struttura venisse definita all'interno di main(), il suo ambito sarebbe limitato a main(). Inoltre una struttura deve essere dichiarata prima della dichiarazione della funzione.

Come per le strutture, possiamo avere puntatori a union e possiamo accedere ai membri tramite l'operatore freccia(->).

E. Puntatore a Puntatore

Finora abbiamo esaminato puntatori per diversi tipi di dato, array, stringhe, funzioni, strutture e unioni.

La domanda che sorge spontanea è - ma un puntatore a puntatore?

Ho buone notizie per te! Esistono anche quelli.

int var = 6;
int *ptr_var = &var;

printf("Indirizzo di var = %d\n", ptr_var);
printf("Indirizzo di ptr_var = %d\n", &ptr_var);

/* Output */
Indirizzo di var = 6422036
Indirizzo di ptr_var = 6422024

Per conservare l'indirizzo della variabile var di tipo int, abbiamo un puntatore a  int ptr_var. Avremmo bisogno di un altro puntatore per conservare l'indirizzo di ptr_var.

Visto che ptr_var è di tipo int *, per conservare il suo indirizzo avremmo dovuto creare un puntatore a int *. Il codice che segue mostra come deve essere fatto.

int * *ptr_ptrvar = &ptr_var; /* oppure int* *ppvar oppure int **ppvar */

Possiamo usare ptr_ptrvar per accedere all'indirizzo di ptr_var e usare la doppia dereferenziazione per accedere al valore di var.

printf("Indirizzo di ptr_var = %d\n", ptr_ptrvar);
printf("Indirizzo di var = %d\n", *ptr_ptrvar);
printf("Valore di var = %d\n", *(*ptr_ptrvar));

/* Output */
Indirizzo di ptr_var = 6422024
Indirizzo di var = 6422036
Valore di var = 6

Non sono richieste le parentesi quando si dereferenzia ptr_ptrvar, ma è buona pratica usarle. Possiamo creare un altro puntatore a ptr_ptrptrvar, che conserverà l'indirizzo di ptr_ptrvar.

Visto che ptr_ptrvar è di tipo int**, la dichiarazione di ptr_ptrptrvar sarà:

int** *ptr_ptrptrvar = &ptr_ptrvar;

Possiamo ancora accedere a  ptr_ptrvar, ptr_var e var usando ptr_ptrptrvar.

printf("Indirizzo di ptr_ptrvar = %d\n", ptr_ptrptrvar);
printf("Valore per ptr_ptrvar = %d\n",*ptr_ptrptrvar);
printf("Indirizzo di ptr_var = %d\n", *ptr_ptrptrvar);
printf("Valore per ptr_var = %d\n", *(*ptr_ptrptrvar));
printf("Indirizzo di var = %d\n", *(*ptr_ptrptrvar));
printf("Valore per var = %d\n", *(*(*ptr_ptrptrvar)));

/* Output */
Indirizzo di ptr_ptrvar = 6422016
Valore per ptr_ptrvar = 6422024
Indirizzo di ptr_var = 6422024
Valore per ptr_var = 6422036
Indirizzo di var = 6422036
Valore per var = 6

Se modifichiamo il valore di un qualsiasi puntatore usando ptr_ptrptrvar oppure ptr_ptrvar, il puntatore non punterebbe più alla variabile.

F. Conclusione

Bene! Sì, abbiamo finito. Siamo partiti dai puntatori e abbiamo finito con i puntatori (per così dire). Non dicono che la curva di apprendimento è un cerchio?

Cerca di ricapitolare tutti i sotto argomenti che hai letto. Se li ricordi, ben fatto! Rileggi quelli che non riesci a ricordare.

Questo articolo è terminato, ma non dovresti smettere con i puntatori, fai esperimenti. Successivamente, potresti dare un'occhiata alla Allocazione dinamica della memoria (Dynamic Memory Allocation) per conoscere meglio i puntatori.

Nella programmazione, dovrai spesso avere a che fare con l'ambito di una variabile. L'ambito di una variabile determina se è possibile o meno accedervi e modificarla all'interno di un blocco specifico di codice.

In questo tutorial, imparerai l'ambito di una variabile nel linguaggio di programmazione C. Vedrai alcuni esempi di codice per aiutarti a comprendere le differenze tra variabili locali e globali.

Cos'è l'ambito di una variabile?

Prima di proseguire per conoscere l'ambito locale e globale di una variabile, capiamo cosa significa ambito.

In termini semplici, l'ambito di una variabile è il suo tempo di vita nel programma.

Questo vuol dire che l'ambito di una variabile è il blocco di codice all'interno dell'intero programma dove la variabile è stata dichiarata, usata e può essere modificata.

Nella sezione successiva, imparerai cos'è l'ambito locale delle variabili.

Ambito Locale delle Variabili in C – Blocchi Annidati

In questa sezione, imparerai come funzionano le variabili locali in C. Prima scriveremo del codice per un paio di esempi, quindi generalizzeremo il principio di ambito.

▶ Ecco il primo esempio:

#include <stdio.h>

int main() 
{
    int my_num = 7;
    {
        //aggiunge 10 a my_num
        my_num = my_num +10;
        //oppure più brevemente my_num +=10
        printf("my_num è %d",my_num);
    }
    
    return 0;
}

Cerchiamo di capire cosa fa il programma qui sopra:

In C, un blocco di codice è delimitato da parentesi graffe: {}. Le parentesi graffe di apertura e chiusura indicano rispettivamente l'inizio e la fine di un blocco.

• La funzione main() ha una variabile di tipo intero my_num che viene inizializzata con il valore 7 nel blocco più esterno.
• C'è un blocco più interno che cerca di aggiungere 10 alla variabile my_num.

Ora, compilando ed eseguendo il programma qui sopra, si ottiene il risultato:

//Output

my_num è 17

Puoi notare quanto segue:

• Il blocco più interno è in grado di accedere al valore di my_num che è stato dichiarato nel blocco più esterno e modificarlo aggiungendo 7 al valore contenuto.
• Il valore di my_num ora è 17, come indicato nel risultato.

Ambito Locale delle Variabili in C – Blocchi Annidati Esempio 2

▶ Ecco un altro esempio sull'argomento:

#include <stdio.h>

int main() 
{
    int my_num = 7;
    {
        int new_num = 10;
    } 
    printf("new_num è %d",new_num); //questa è la riga 9
    return 0;
}

• In questo programma, la funzione main() ha una variabile di tipo intero my_num nel blocco più esterno.
• Un'altra variabile, new_num viene inizializzata nel blocco più interno, che è annidato nel blocco più esterno.
• Stiamo cercando di accedere e stampare il valore della variabile del blocco più interno new_num dal blocco più esterno.

Se cerchi di compilare il codice qui sopra, noterai che la compilazione non va a buon fine, e otterrai il seguente errore, il cui messaggio tradotto è "errore: 'new_num' non dichiarata, (usata per la prima volta in questa funzione)":

Line   Message
9      error: 'new_num' undeclared (first use in this function)

Questo perché la variabile new_num è stata dichiarata nel blocco più interno e il suo ambito è limitato al suddetto blocco. In altre parole, è locale rispetto al blocco più interno e non può essere utilizzata nel blocco più esterno.

In base alle osservazioni qui sopra, scriviamo il seguente principio generico per l'ambito locale delle variabili:

{
    /BLOCCO PIU' ESTERNO/
    
      {
        
        
        //Il contenuto del blocco più esterno che si trova immediatamente prima dell'inizio di questo blocco
        //è ACCESSIBILE qui
        
        /BLOCCO PIU' INTERNO/
        
        
      }
     
       //Il contenuto del blocco più interno NON è accessibile qui
 }

Ambito Locale delle Variabili in C – Blocchi Diversi

Nell'esempio precedente, hai imparato che l'accesso da un blocco più esterno alle variabili annidate in un blocco più interno non è consentito.

In questa sezione, imparerai circa l'ambito locale di variabili dichiarate in blocchi diversi.

#include <stdio.h>

int main()
{
    int my_num = 7;
    printf("%d",my_num);
    my_func();
    return 0;
}

void my_func()
{
    printf("%d",my_num);
}

Nell'esempio qui sopra:

• La variabile di tipo intero my_num è dichiarata all'interno della funzione main().
• All'interno della funzione main(), il valore di my_num viene stampato.
• C'è un'altra funzione, my_func(), che cerca di accedere e stampare il valore di my_num.
• Quando inizia l'esecuzione del programma con la funzione main(), c'è una chiamata a my_func() all'interno della funzione main().

▶ Ora compila ed esegui il programma qui sopra. Otterrai il messaggio di errore qui sotto (traduzione: "errore 'my_num' non dichiarata (primo uso in questa funzione)):

Line   Message
13     error: 'my_num' undeclared (first use in this function)

Se noti, nella riga 13, la funzione my_func() tenta di accedere alla variabile my_num che è stata dichiarata e inizializzata all'interno della funzione main().

Pertanto l'ambito della variabile my_num è confinato alla funzione main(), e si dice che è locale alla funzione main().

Possiamo rappresentare genericamente questa nozione di ambito locale come segue:

{

    /BLOCCO 1/
    // da qui non si può accedere al contenuto del BLOCCO 2
    
}


{

    /BLOCCO 2/
    // da qui non si può accedere al contenuto del BLOCCO 1
    
} 

Ambito Globale delle Variabili in C

Finora, hai imparato a conoscere l'ambito locale delle variabili C. In questa sezione imparerai come dichiarare variabili globali in C.

▶ Iniziamo con un esempio.

#include <stdio.h>
int my_num = 7;

int main()
{
    printf("si può accedere a my_num da main() e il suo valore è %d\n",my_num);
    //chiama my_func
    my_func();
    return 0;
}

void my_func()
{
  printf("si può accedere a my_num anche da my_func() e il suo valore è %d\n",my_num);
} 

Nell'esempio qui sopra:

• La variabile my_num è dichiarata al di fuori delle funzioni main() e my_func().
• Cerchiamo di accedere a my_num all'interno della funzione main() e ne stampiamo il valore.
• Chiamiamo la funzione my_func() all'interno della funzione main().
• La funzione my_func() cerca anche di accedere al valore di my_num per stamparlo.

Questo programma si compila senza errori e il risultato è mostrato qui sotto:

//Output
si può accedere a my_num da main() e il suo valore è 7
si può accedere a my_num anche da my_func() e il suo valore è 7

In questo esempio, ci sono due funzioni  –  main() e my_func().

Tuttavia la variabile my_num non è locale ad alcuna funzione nel programma. Una variabile di questo tipo, non locale ad alcuna funzione, ma si dice che ha un ambito globale e viene chiamata variabile globale.

Questo principio di ambito globale delle variabili può essere riepilogato come segue:

//tutte le variabili globali sono dichiarate qui
function1()
    {
    
    // è possibile accedere a tutte le variabili globali dall'interno di function1
    
    }
function2()
    {
    
    // è possibile accedere a tutte le variabili globali dall'interno di function2
     
    } 

Riepilogo

In questo tutorial, hai imparato la differenza tra ambito locale e globale. Questo è un tutorial di livello introduttivo sull'ambito delle variabili in C.

In C, esistono modificatori di accesso per controllare il livello di accessibilità di cui una variabile dispone. Puoi modificare la modalità di accesso usando le parole chiave corrispondenti quando dichiari le variabili.

Ci vediamo al prossimo tutorial. Fino ad allora, buona programmazione!

Utilizzando il linguaggio di programmazione C, può capitarti di voler cambiare il comportamento di un loop, e le istruzioni continue e break ti aiutano a saltare iterazioni e uscire dal loop in determinate condizioni.

In questo tutorial, imparerai come alterare le strutture di controllo di un programma con le istruzioni break e continue.

Iniziamo.

Come usare break per uscire da un loop in C

In C, se vuoi uscire da un loop quando si verifica una condizione specifica, puoi usare l'istruzione break.

Come tutte le istruzioni in C, anche l'istruzione break deve terminare con un punto e virgola (;).

Prendiamo un esempio per capire come funziona.

Considera il seguente snippet di codice.

#include<stdio.h>
int main()
{
    int conteggio = 0;
    while(conteggio < 100)
    {
        printf("Il valore del conteggio è %d \n", conteggio);
        conteggio++;
    }
    return 0;
}

In questo esempio, il loop while ripete le istruzioni nel corpo del loop finché conteggio è minore di 100.

Il conteggio parte da 0 e aumenta di 1 a ogni iterazione.

Questo è il flusso normale della struttura di controllo.

Modifichiamolo un po'.

• Prendiamo un intero num_prefe dall'utente. Ipotizziamo che num_prefe sia il numero preferito dell'utente nell'insieme {0, 1, 2, ..., 99}.
• Durante ogni iterazione del loop, bisogna verificare se il valore attuale di conteggio sia uguale a num_prefe.
• Vogliamo uscire dal loop quando conteggio è uguale a num_prefe.

Come possiamo fare?

Dai un'occhiata al seguente snippet di codice:

#include<stdio.h>
int main()
{
    // Prende come input il numero preferito dell'utente
    int num_prefe;
    printf("Inserisci il tuo numero preferito da 0 a 99: ");
    scanf("%d", &num_prefe);
    
    int conteggio = 0;
    while(conteggio < 100)
    {
        printf("\nIl valore del conteggio è %d.", conteggio);
        if (conteggio == num_prefe)
    		break;
        conteggio++;
    }
    return 0;
}

• Durante ogni iterazione, usiamo if (conteggio == num_prefe) per controllare se conteggio è uguale a num_prefe.  Abbiamo aggiunto un'istruzione break; al corpo dell'istruzione if.
• Finché conteggio ≠ num_prefe, l'istruzione break; non viene mai raggiunta.
• Quando conteggio è uguale a num_prefe, l'istruzione break; viene attivata e usciamo dal loop.
• Il controllo adesso raggiunge la prima istruzione fuori dal loop.

Qui sotto puoi vedere un output di esempio:

Nota che usciamo dal loop una volta che il conteggio raggiunge 3, che in questo caso è num_prefe.

Nella prossima sezione, vedremo un altro esempio per consolidare questo concetto.

Esempio di istruzione break in C

▶ Considera il seguente esempio:

• A[10] è un array di 10 interi ed è inizializzato con degli zeri.
• Vogliamo prendere gli elementi dell'array A da un utente e calcolare la somma degli elementi nell'array.
• Tuttavia, vogliamo che ogni elemento di A non sia più grande di 20.
• Una volta che l'utente inserisce un numero maggiore di 20, vogliamo terminare il loop. È qui che l'istruzione break; torna utile.

Guarda il seguente snippet di codice, che fa esattamente questo.

#include <stdio.h>

int main()
{
    int A[10] = {0};
    int somma = 0;
    
    for(int i = 0; i < 10; i++)
    {
        printf("Inserisci un numero: ");
        scanf("%d",&A[i]);
        if (A[i] > 20)
            break;
        
        somma += A[i];
    }
    printf("Somma: %d",somma);
    return 0;
}

• somma è inizializzata a 0.
• In ogni passaggio del loop, l'utente deve inserire un numero, che viene aggiunto al valore corrente di somma.
• Se l'utente inserisce un numero maggiore di 20, usciamo dal loop.

Nota come il loop termina una volta che l'utente inserisce un numero maggiore di 20 – in questo caso 21. La somma degli altri due numeri (2 e 3) viene stampata sulla console.

Se hai mai utilizzato delle istruzioni switch in C, è probabile che tu abbia usato l'istruzione break; per uscire dalla scaletta dei case non appena viene riscontrata una corrispondenza con l'etichetta del case.

In ogni caso, lo scopo di questo tutorial è mostrare il modo di utilizzare le istruzioni break; e continue; per cambiare il comportamento di un loop.

Come usare continue per saltare delle iterazioni in C

In C, se vuoi saltare delle iterazioni quando si verifica una specifica condizione, puoi usare un'istruzione continue.

A differenza dell'istruzione break, l'istruzione continue non causa l'uscita dal loop. Invece, salta solo le iterazioni per cui la condizione è vera.

Una volta che l'istruzione continue; viene attivata, le istruzioni nel resto del loop vengono saltate e il loop passa all'iterazione successiva.

Esempio di istruzione continue in C

Usiamo l'esempio della sezione precedente, modificandolo un po'.

Diciamo che non vogliamo uscire dal loop quando l'utente inserisce un numero maggiore di 20. Piuttosto, vogliamo ignorare questi specifici input e calcolare la somma degli altri numeri nell'array A.

• Supponiamo che l'utente inserisca 10 numeri, 1 dei quali maggiore di 20.
• Il nostro codice dovrebbe calcolare e mostrare la somma dei restanti 9 numeri.

Come possiamo fare?

Possiamo usare l'istruzione continue; per saltare solo le iterazioni per cui l'input dell'utente è maggiore di 20. 🙂

Guarda il codice qui sotto:

#include <stdio.h>

int main()
{
    int A[10] = {0};
    int somma = 0;
    
    for(int i = 0; i < 10; i++)
    {
        printf("Inserisci un numero: ");
        scanf("%d",&A[i]);
        if (A[i] > 20)
            continue;
        
        somma += A[i];
    }
    printf("Somma: %d", somma);
    return 0;
}

Nell'output puoi vedere che il primo input è 21, che è maggiore di 20.

Tuttavia, il loop compie dieci iterazioni. E se sei pronto un altro rapido esercizio, puoi verificare che la somma degli altri numeri (2, 3, 5, 4, 7, 15, 14, 2 e 5) fa proprio 57. ✅

Conclusione

In questo tutorial, hai imparato come usare le istruzioni break; e continue; per controllare i loop in C.

Ricapitolando, abbiamo visto:

• Come uscire da un loop in base a delle condizioni specifiche con l'istruzione break;.
• Come saltare delle iterazioni in base a delle condizioni specifiche con l'istruzione continue;.

Spero che tu abbia trovato utile questo tutorial. Buona programmazione! 😄

Questo tutorial ti fornirà un'ampia panoramica dei concetti di base del linguaggio di programmazione C.

Parleremo della storia del linguaggio, di dove e perché viene utilizzato, del processo di compilazione e di altri fondamentali concetti di programmazione, comuni alla maggior parte dei linguaggi di programmazione più popolari.

Questa non è una guida completa al linguaggio, ma piuttosto ti permetterà di raggiungere una buona comprensione dei concetti importanti di C partendo dal livello di un principiante assoluto.

Ogni linguaggio possiede la propria sintassi e dei modi specifici di fare le cose, ma i concetti che tratteremo qui sono comuni e applicati a tutti i linguaggi di programmazione.

Comprendere il funzionamento delle cose e questi concetti generali può richiedere molta della strada del tuo viaggio nella programmazione, ma sul lungo termine ti renderà più semplice capire nuove tecnologie.

Sommario

1. Storia del linguaggio
2. Caratteristiche di C e perché dovresti impararlo
3. Dove viene utilizzato C?
4. Processo di compilazione
5. Hello world
6. File di intestazione
7. Programma main
8. Commenti
9. Ottenere un output sulla console
10. Variabili
11. Assegnazione
12. Dichiarazione e inizializzazione
13. Nomenclatura delle variabili
14. Visibilità delle variabili
15. Tipi di dati
16. Specificatori di formato
17. Operatori
18. Operatori aritmetici
19. Operatore di assegnazione
20. Operatori logici
21. Operatori di confronto
22. Funzioni
23. Argomenti
24. Output
25. Metodi
26. Chiamare una funzione
27. Espressioni booleane
28. Istruzioni condizionali
29. Loop

Storia del linguaggio di programmazione C

La storia del linguaggio di programmazione C è strettamente legata alla storia dello sviluppo del sistema operativo Unix.

Se proviamo a capire cosa ha portato allo sviluppo del sistema operativo che ha cambiato il mondo della programmazione, sapremo quali sono stati gli step che hanno determinato lo sviluppo di C.

In breve, C è nato dalla necessità di trovare un linguaggio da applicare al sistema operativo Unix.

Progetto MAC e MULTICS

Iniziò tutto nel 1965, quando il progetto sperimentale MAC fu completato al MIT – il primo sistema del suo genere, che ha segnato l'inizio dell'era MULTICS. Utilizzava una tecnologia chiamata CTSS (Compatible Time Sharing System).

Per l'epoca fu un'innovazione fondamentale. In quel momento, si era all'inizio dell'era mainframe, dove computer enormi, potenti ed estremamente costosi occupavano stanze intere.

Per svolgere delle attività, i programmatori dovevano scrivere il codice a mano, per poi perforare delle schede di carta che codificavano il programma appena scritto.

Lo facevano consegnando i fogli di carta su cui era scritto il programma a degli operatori che utilizzavano una macchina perforatrice per creare dei buchi nelle schede, che rappresentavano dati e istruzioni.

Poi utilizzavano un lettore di schede perforate connesso al computer mainframe per leggere le schede. In seguito, la sequenza dei buchi nella scheda veniva convertita in informazione digitale. Semplici operazioni necessitavano di tempi lunghi a causa di questo metodo e ogni macchina poteva essere usata soltanto da una persona alla volta.

L'idea del time sharing ha cambiato ogni cosa. Invece di usare le schede, delle console multiple (che al tempo erano costituite da terminali meccanici detti telescriventi) venivano attaccate al computer principale. Ciò ha permesso a molte persone di usare lo stesso computer simultaneamente.

Più di 100 terminali telescriventi distribuiti attorno al campus del MIT erano collegati al grande computer centrale. Il sistema supportava fino a 30 utenti, ognuno dei quali usava quei terminali in remoto allo stesso tempo.

Il sistema operativo del computer centrale svolgeva più compiti contemporaneamente, passando tra le persone che volevano eseguire attività computazionali dai terminali connessi e dando pochi secondi a ognuno di loro.

Forniva ciò che può assomigliare a un servizio continuo, con molti programmi in esecuzione simultanea. In realtà, passava molto velocemente da un programma di un utente all'altro, dando alla persona l'illusione di avere l'intero computer per sé.

Questo sistema si è dimostrato estremamente efficiente, efficace e produttivo, permettendo di risparmiare tempo e denaro sul lungo termine, dato che quei computer erano estremamente costosi.

Ciò che avrebbe richiesto giorni interi per essere completato, ora era fattibile in molto meno tempo, favorendo l'accesso all'utilizzo dei computer.

Seguendo il successo del CTSS, il MIT decise che era tempo di basarsi su questo sistema e portarlo allo step successivo, creando un sistema più avanzato di time sharing.

Ma immaginavano un progetto ben più ambizioso: volevano costruire un sistema da usare come risorsa informatica per i programmatori, capace di supportare contemporaneamente centinaia di accessi di utenti al mainframe. E gli utenti sarebbero stati in grado di condividere dati e risorse tra di loro.

Questo progetto richiedeva più risorse, così si unirono alla General Electric e ai Bell Labs.

Il nuovo progetto, chiamato MULTICS (da Multiplexed Information and Computing Service), fu implementato nel mainframe della General Electric, il GE 635.

Il team lavorò su MULTICS per svariati anni, ma nel 1969 il progetto fu abbandonato dai Bell Labs perché stava richiedendo troppo tempo ed era troppo costoso.

Bell Labs: il centro dell'innovazione

L'abbandono del progetto MULTICS da parte dei Bell Labs lasciò molti impiegati frustrati e in cerca di alternative.

Mentre stava lavorando su MULTICS, il team creò un ambiente informatico senza precedenti. Lavoravano con sistemi basati sul time sharing e conoscevano la sua efficacia. Questi programmatori avevano una vasta conoscenza dei sistemi operativi e volevano espandere le innovazioni partite da quel progetto.

Un gruppo guidato da Ken Thompson e Dennis Ritchie voleva utilizzare un ambiente comune e creare un file system da poter condividere. Avrebbe avuto le caratteristiche innovative che apprezzavano del progetto MULTICS ma un'implementazione più semplice e meno costosa.

Condivisero le loro idee e iniziarono tentare.

I Bell Labs crearono un ambiente aperto e collaborativo che permise all'espressione creativa e all'innovazione di sbocciare. Facevano molta ricerca e incoraggiavano il pensiero indipendente nella risoluzione dei problemi per migliorare le loro soluzioni iniziali.

Attraverso tanti confronti e sperimentazione hanno realizzarono un cambiamento epocale scrivendo la storia.

Mentre stava ancora lavorando su MULTICS, Ken Thompson creò un gioco chiamato Space Travel. Lo aveva inizialmente scritto per MULTICS, sul GE 635, ma quando i Bell Lab si chiamarono fuori, adattò il gioco in un programma Fortran da eseguire sul sistema operativo GECOS del GE 635.

Il gioco aveva molti problemi – su GECOS non funzionava così bene come faceva su MULTICS e aveva bisogno di una macchina diversa e meno costosa su cui girare.

A Ken Thompson furono negati i fondi richiesti per creare un diverso sistema operativo, dato che i Bell Labs si erano chiamati già fuori dal progetto. Alla fine, riuscì a trovare un vecchio minicomputer DEC PDP-7 poco usato con cui fare un tentativo – era l'unico sistema disponibile.

Iniziò a scrivere il suo gioco su quel semplice sistema ma era limitato dal software del computer. Così, mentre ci stava lavorando su, finì a implementare lo scheletro del file system che il suo team aveva ideato.

Partì con un file system gerarchico, un interprete della riga di comando e altri programmi di utilità. In un mese, riuscì a creare un sistema operativo con un assembler, un editor e uno shell, con funzionalità ridotte e più semplici rispetto a MULTICS: era nata la prima versione di Unix.

Gli albori di Unix e del linguaggio assembly

All'inizio del progetto, Ken Thompson non poteva programmare sul computer DEC PDP-7. I suoi programmi dovevano essere compilati e tradotti sul più potente mainframe GE 635 e poi l'output doveva essere fisicamente trasferito sulla scheda del PDP-7.

Il DEC PDP-7 aveva una memoria molto ridotta di soli 8 KB. Per far fronte a questa limitazione, il file system, la prima versione del kernel di Unix e praticamente ogni altra cosa nel progetto era programmata in assembly. L'uso di assembly permetteva a Thompson di manipolare direttamente e controllare ogni parte della memoria di quel computer.

Il linguaggio assembly è un linguaggio di programmazione di basso livello che utilizza del codice simbolico ed è vicino al linguaggio macchina, il codice binario. Le istruzioni del codice e ogni istruzione nel linguaggio corrispondono strettamente alle istruzioni-macchina specifiche per l'architettura del computer.

È dipendente dalla macchina e specifico, così che un'insieme di istruzioni ha risultati molto differenti a seconda della macchina su cui viene eseguito. I programmi scritti in linguaggio assembly sono pensati per uno specifico tipo di processore – quindi un programma scritto in assembly non si adatta a processori diversi.

A quel tempo, era comune scrivere sistemi operativi usando il linguaggio assembly e quando iniziarono a lavorare su Unix, non avevano in mente di renderlo portabile.

A loro non interessava che il sistema operativo fosse in grado di operare su sistemi e architetture macchina diversi. Questa idea arrivò più tardi. La loro priorità era l'efficienza del software.

Mentre lavoravano su MULTICS, usavano linguaggi di programmazione ad alto livello (PL/I all'inizio e poi BCPL). I programmatori si erano abituati a utilizzare linguaggi di programmazione ad alto livello per scrivere software come sistemi operativi, utilità e strumenti, per via dei vantaggi che offrivano (erano relativamente facili da usare e da capire).

Nell'uso di un linguaggio di programmazione di alto livello, c'è un'astrazione tra l'architettura del computer e svariati altri dettagli oscuri. Questo significa che il linguaggio si trova sopra il livello della macchina e non c'è manipolazione diretta della memoria dell'hardware.

I linguaggi di alto livello sono più facili da leggere, imparare, comprendere e gestire. Ciò fa sì che siano una scelta più facile per lavorare in gruppo. I comandi hanno una sintassi che ricorda l'inglese e i termini e le istruzioni sono più familiari e a misura d'uomo rispetto al formato simbolico di assembly.

Usare linguaggi di alto livello significa anche scrivere meno codice per compiere delle operazioni, mentre i programmi in assembly sono estremamente lunghi.

Fin dal principio, Thompson voleva usare un linguaggio di alto livello per Unix, ma era limitato dal DEC PDP-7.

Con il progredire del progetto e l'aggiunta di altre persone al gruppo, l'uso di assembly non era ideale. Thompson decise che Unix aveva bisogno di un linguaggio di programmazione di alto livello.

Nel 1970 ottenne i fondi per il più grande e potente DEC PDP-11, che sostanzialmente aveva più memoria.

Con un linguaggio di programmazione di alto livello, più veloce, strutturato ed efficiente in grado di sostituire assembly, tutti avrebbero potuto capire il codice e i compilatori sarebbero stati disponibili per macchine diverse.

Iniziarono ad esplorare linguaggi differenti per scrivere sistemi software da usare per implementare Unix.

Da B a C: il bisogno di un nuovo linguaggio

L'obiettivo era creare utilità – programmi che aggiungono funzionalità – da eseguire su Unix. Thompson tentò inizialmente di creare un compilatore FORTRAN ma poi optò per un linguaggio che aveva già utilizzato, BCPL (Basic Combined Programming Language).

BCPL era stato progettato e sviluppato alla fine degli anni '60 da Martin Richards. Il suo utilizzo principale era per scrivere compilatori e sistemi software.

Questo linguaggio era lento e aveva molte limitazioni, così quando Thompson iniziò a usarlo nel 1970 per il progetto Unix sul DEC PDP-7, fece degli aggiustamenti e delle modifiche e finì per scrivere un linguaggio tutto suo, chiamato B.

B aveva molte delle funzionalità di BCPL ma era un linguaggio più snello, con meno sintassi verbose e uno stile più semplice. Era ancora lento e non abbastanza potente per supportare le utilità di Unix, inoltre, non poteva trarre vantaggio dalle potenti funzionalità del PDP-11.

Dennis Ritchie decise di migliorare i due linguaggi precedenti, BCPL e B. Prese funzionalità e caratteristiche da entrambi e aggiunse altri concetti. Creò un linguaggio più potente ed efficiente – C – tanto quanto assembly. Questo nuovo linguaggio superò le limitazioni dei linguaggi precedenti, permettendo anche di sfruttare efficientemente le potenzialità della macchina.

Così, nel 1972, nacque C, con il primo compilatore C scritto e implementato per la prima volta sul DEC PDP-11.

Il linguaggio di programmazione C

Nel 1973, Dennis Ritchie riscrisse il codice sorgente di Unix e la maggior parte dei programmi e delle applicazioni usando il linguaggio di programmazione C, che divenne il linguaggio di implementazione standard del sistema operativo.

Reimplementò il kernel di Unix in C scrivendo quasi tutto il sistema operativo (ben oltre il 90%) in questo linguaggio di alto livello. C unisce sia le caratteristiche di leggibilità del linguaggio di alto livello con le funzionalità di basso livello, rendendolo la scelta perfetta per scrivere un sistema operativo.

Verso la fine degli anni '70, la popolarità di C iniziò a crescere e il linguaggio a diventare più ampiamente supportato e sviluppato. Fino a quel punto, C era ancora soltanto disponibile per i sistemi Unix e i compilatori non erano disponibili fuori dai Bell Labs.

L'aumento della popolarità derivò non solo dalle potenzialità date da C alla macchina, ma anche al programmatore. Fu d'aiuto anche il fatto che il sistema operativo Unix stesse diventando più diffuso a un ritmo addirittura maggiore.

Unix si distingueva da tutto ciò che era conosciuto per via della sua portabilità e della possibilità di essere eseguito su una varietà di macchine, sistemi e ambienti differenti.

C ha reso possibile la portabilità e dal momento in cui venne utilizzato come linguaggio del sistema Unix, ha guadagnato molta notorietà – sempre più programmatori hanno voluto provarlo.

Nel 1978, Brian Kernighan e Dennis Ritchie scrissero in collaborazione e pubblicarono la prima edizione del libro 'Il linguaggio di programmazione C', conosciuto nella comunità dei programmatori anche con il nome di 'K&R'. Per molti anni, questo è stato il testo di riferimento per la descrizione e definizione del linguaggio C.

Negli anni '80, la popolarità di C salì alle stelle dato che diversi compilatori furono creati e commercializzati. Molti gruppi e aziende che non erano state coinvolte nella progettazione di C iniziarono a produrre compilatori per ogni sistema operativo e architettura di computer, rendendo C disponibile su tutte le piattaforme.

Dato che queste società creavano i compilatori per conto proprio, iniziarono a cambiare le caratteristiche del linguaggio per adattare il compilatore a ogni piattaforma per cui era stato scritto.

Esistevano varie versioni di C con piccole differenze tra di loro. Mentre scrivevano i compilatori, questi gruppi svilupparono le proprie interpretazioni di alcuni aspetti del linguaggio, basate sulla prima edizione del libro 'Il linguaggio di programmazione C'.

Dopo tutte le prove e gli aggiustamenti, il libro non descriveva più il linguaggio originario, e i cambiamenti iniziarono a causare dei problemi.

Il mondo aveva bisogno di una versione comune di C, uno standard per il linguaggio.

Lo standard C

Nel 1983, l'ANSI (American National Standards Institute) formò una commissione per far sì che la definizione del linguaggio fosse standardizzata e indipendente dalla macchina. La commissione, chiamata X3J11, aveva il compito di fornire una definizione e una standardizzazione di C chiara ed esaustiva.

Dopo pochi anni, nel 1989, la commissione terminò il suo lavoro e lo rese ufficiale. Avevano definito uno standard commerciale per il linguaggio. Quella versione del linguaggio è conosciuta come 'ANSI C' o C89.

C venne utilizzato in tutto il mondo e un anno dopo, nel 1990, lo standard fu approvato e adottato dall'ISO (International Standards Organization). La prima versione, C90, fu chiamata ISO/IEC 9899:1990.

Da allora, ci sono state molte revisioni del linguaggio.

Nel 1999, fu pubblicata C99, la seconda versione dello standard (denominata ISO/IEC 9899:1999), che introdusse nuove funzionalità addizionali nel linguaggio. La terza versione, C11, fu pubblicata nel 2011. La più recente è la quarta, C17, denominata ISO/IEC 9899:2018.

La continuazione di C

C ha tracciato il sentiero per la creazione di un gran numero di linguaggi di programmazione diversi. Molti dei moderni linguaggi di programmazione di alto livello che usiamo e amiamo sono basati su C.

E molti dei linguaggi creati dopo C dovevano ovviare ai problemi che C non poteva risolvere, o superare alcune delle sue limitazioni. Ad esempio, il discendente più popolare di C è la sua estensione orientata agli oggetti C++, ma anche Go, Java e JavaScript si ispirano a C.

Le caratteristiche di C e perché dovresti impararlo

C è un linguaggio vecchio, ma attualmente è ancora popolare, anche dopo tutti questi anni.

Deve la sua popolarità all'ascesa e al successo di Unix, ma è andato ben oltre l'essere il linguaggio 'originario' di Unix. Attualmente è alla base della maggior parte, se non di tutti i server e sistemi nel mondo.

I linguaggi di programmazione sono strumenti che utilizziamo per risolvere specifici problemi informatici che ci influenzano su larga scala.

Non hai bisogno di conoscere C per creare pagine e applicazioni web, ma torna utile quando vuoi scrivere un sistema operativo, un programma che controlla altri programmi, un'utilità di programmazione per lo sviluppo del kernel o quando vuoi programmare dispositivi integrati in qualsiasi applicazione di sistema. C eccelle in tutte queste attività, quindi vediamo insieme alcune ragioni per apprendere questo linguaggio.

C aiuta a capire come funziona un computer

Nonostante C sia un linguaggio di programmazione general purpose, è principalmente usato per interagire con le funzioni macchina di basso livello. A parte le ragioni pratiche dietro all'apprendimento del linguaggio, conoscere C può aiutarti a capire come funziona effettivamente un computer, cosa accade dietro le quinte e come i programmi vengono realmente eseguiti sulle macchine.

Dato che C è considerato la base di altri linguaggi di programmazione, se sei in grado di comprendere i concetti su cui si basa, in seguito, ti sarà molto più facile imparare altri linguaggi.

Scrivere del codice C ci fa comprendere i processi nascosti che si verificano nei nostri computer, permettendoci ci avvicinarci all'hardware senza confonderci con il linguaggio assembly. Ci dà anche accesso a una moltitudine di azioni di basso livello restando leggibile come i linguaggi di alto livello.

C è veloce ed efficiente

Allo stesso tempo, non perdiamo la funzionalità, l'efficienza e il controllo di basso livello sull'esecuzione del codice che fornisce assembly.

Ricorda che ogni processore nell'hardware di un qualsiasi dispositivo possiede il proprio codice assembly, che è unico per quel processore e non è affatto compatibile con tutti i processori di altri dispositivi.

Usare C ci garantisce un approccio più veloce, facile e complessivamente meno macchinoso, nei confronti dell'interazione con il computer nel suo livello più basso. Infatti, è una commistione di funzionalità sia di alto che di basso livello e ci aiuta a svolgere un compito senza i problemi e le scocciature del lungo e spesso poco comprensibile codice assembly.

Dunque, C è quanto più vicino tu possa arrivare all'hardware del computer e costituisce un ottimo rimpiazzo per assembly (il vecchio standard per scrivere sistemi operativi) quando stai lavorando sull'implementazione di un software di sistema.

C è potente e flessibile

La stretta vicinanza all'hardware implica che il codice C debba essere scritto in modo esplicito e preciso. Ti dà una chiara immagine di un modello mentale per capire come il codice interagisce con il computer.

C non nasconde la complessità con cui una macchina opera. Ti dà potere e flessibilità, come l'abilità di assegnare, manipolare e scrivere direttamente nella memoria.

Il programmatore svolge un sacco di duro lavoro e il linguaggio permette di gestire e strutturare la memoria in un modo efficiente per la macchina, garantendo performance elevate, ottimizzazione e velocità. C permette al programmatore di fare ciò di cui ha bisogno.

C è portabile, prestante e indipendente dalla macchina

C è anche altamente portabile e indipendente dalla macchina. Anche se è vicino alla macchina e ha accesso alle sue funzioni di basso livello, possiede un'astrazione da quelle componenti, tale da rendere possibile la portabilità.

Dato che le istruzioni assembly sono specifiche per ogni macchina, i programmi non sono portabili. Un programma scritto su una macchina dovrebbe essere riscritto per essere eseguito su un'altra, ed è complicato gestire tutto ciò considerando l'architettura di ogni computer.

C è universale e i programmi scritti in C possono essere compilati ed eseguiti su un gran numero di piattaforme, architetture e una varietà di macchine senza perdite in termini di prestazioni. Questo è ciò che fa di C un'ottima scelta per la creazione di sistemi e programmi in cui la performance è cruciale.

C ha ispirato la creazione di molti linguaggi di programmazione

Molti linguaggi oggi comunemente usati, come Python, Ruby, PHP e Java, traggono ispirazione da C. Questi linguaggi moderni si basano su C per operare efficientemente. Anche le loro librerie, i loro compilatori e interpreti sono costruiti in C.

Questi linguaggi nascondono la maggior parte dei dettagli sul funzionamento reale di un programma e, utilizzandoli, non devi aver a che fare con l'assegnazione della memoria, bit e byte, in quanto ci sono più livelli di astrazione. Non hai bisogno di un simile controllo dettagliato con applicazioni di alto livello dove ogni interazione con la memoria può determinare degli errori.

Ma quando stai implementando una parte di un sistema operativo e di un dispositivo integrato, conoscere quei dettagli di basso livello e di manipolazione diretta può aiutarti a scrivere un codice più pulito.

C è un linguaggio compatto

Nonostante C possa essere piuttosto criptico e difficile da comprendere per i principianti, è in realtà un linguaggio ragionevolmente ridotto e compatto con una sintassi e un insieme di parole chiave e di funzioni integrate minimale. Quindi, puoi sperare di imparare e utilizzare le sue funzionalità basilari, già esplorandone il funzionamento.

Anche se non sei interessato a imparare come programmare un sistema operativo o un'applicazione di sistema, conoscere le basi di C e il modo in cui interagisce con il computer ti darà delle buone basi di concetti e principi informatici.

Inoltre, capire come funziona ed è organizzata una memoria è un concetto di programmazione fondamentale. Quindi, comprendere il funzionamento di un computer a un livello più profondo e i processi che avvengono al suo interno, può davvero aiutarti a imparare e utilizzare altri linguaggi.

Dove viene utilizzato C?

C'è tantissimo codice C nei dispositivi, prodotti e strumenti che che utilizziamo nelle nostre vite quotidiane. Questo codice è alla base di tutto, dai supercomputer ai gadget più piccoli.

Il codice C fa funzionare i sistemi integrati e i dispositivi smart di tutti i tipi. Alcuni esempi sono le applicazioni domestiche come frigoriferi, TV, macchine da caffè, lettori DVD e videocamere digitali.

Il tuo fitness tracker e il tuo smart watch? Basati su C. Il sistema di rilevamento GPS della tua automobile e i semafori? Hai indovinato – C. E ci sono molti altri esempi di sistemi integrati che si basano sul codice C usati nell'industria medicale, robotica e automobilistica.

Un'altra area in cui C è ampiamente usato è nello sviluppo di sistemi operativi e kernel. A parte Unix, per cui il linguaggio è stato creato, altri importanti e popolari sistemi operativi, in una certa misura, sono programmati in C.

Il kernel di Microsoft Windows è scriptato principalmente in C, così come il kernel di Linux. La maggior parte dei supercomputer e anche dei server di Intenet si basa su Linux. Ciò significa che C è alla base di un'ampia porzione di internet.

Linux alimenta anche i dispositivi Android, quindi il codice C fa funzionare non solo i supercomputer, ma anche i computer personali e gli smartphone. Perfino OSX è parzialmente programmato in C, facendo sì che anche i computer Mac si basino su C.

C è anche diffuso per lo sviluppo di applicazioni desktop e di interfacce grafiche (GUI). La gran parte delle applicazioni Adobe che utilizziamo per l'editing di foto e video e per la progettazione grafica (come Photoshop, Adobe illustrator e Adobe Premiere) è programmata con C o il suo successore, C++.

I compilatori, gli interpreti e gli assembler per una varietà di linguaggi sono progettati e costruiti con C – infatti, questi sono alcuni degli utilizzi più comuni del linguaggio.

Molti dei browser e delle loro estensioni sono realizzati con C, come Google Chromium e il file system di Google. Gli sviluppatori usano spesso C anche nella progettazione di database (MySQL e Oracle sono due dei sistemi di database più famosi realizzati in C) e per la grafica avanzata di molti videogiochi.

Da questa panoramica, possiamo vedere che C e il suo derivato C++ gestiscono la gran parte di internet e del mondo in generale. Molti degli apparecchi e delle tecnologie che usiamo nelle nostre vite quotidiane sono scritte o dipendono da C.

Il processo di compilazione di C: scrivi-compila-esegui

Cos'è un programma in C?

Un programma per computer scritto in C è un insieme ordinato di istruzioni comprensibili ed eseguibili da un computer. Punta a fornire una soluzione per uno specifico problema informatico e dice al computer di svolgere una determinata azione tramite una sequenza di istruzioni da seguire.

Essenzialmente, tutti i programmi sono soltanto semplici file di testo memorizzati nell'hard drive del computer, che utilizzano una sintassi speciale, definita dal linguaggio di programmazione che stai usando.

Ogni linguaggio ha le proprie regole che determinano cosa puoi scrivere e cosa è considerato valido e cosa no.

Un programma possiede delle parole chiave, ovvero delle parole specifiche che sono riservate e fanno parte del linguaggio. Contiene anche pezzi letterali di dati come stringhe e numeri. Ha parole specifiche che seguono le regole del linguaggio, che definiamo e introduciamo (come variabili e metodi).

Cos'è un compilatore?

I programmi sono scritti da noi e per noi. Sono fatti per essere compresi dalle persone.

Quando scriviamo programmi in forma leggibile, possiamo capirli – ma il computer potrebbe non esserne in grado. I computer non capiscono direttamente i linguaggi di programmazione, ma soltanto il binario. Quindi i programmi devono essere tradotti così che il computer possa realmente capire le istruzioni del programma.

I programmi scritti in linguaggi di alto livello possono essere compilati o interpretati. Fanno uso di parti speciali di software chiamati rispettivamente compilatori e interpreti.

Qual è la differenza tra un compilatore e un interprete?

Sia i compilatori che gli interpreti sono programmi, ma di una complessità di gran lunga superiore a quelli usuali e agiscono come traduttori. Prendono un programma così com'è scritto e lo trasformano in una forma comprensibile per il computer. E rendono possibile l'esecuzione di programmi su sistemi differenti.

I programmi compilati vengono prima convertiti in una forma comprensibile dal computer, ovvero vengono tradotti in linguaggio macchina prima di essere eseguiti. Il codice macchina è un linguaggio numerico – istruzioni binarie composte da una sequenza di 0 e  1.

La compilazione produce un programma eseguibile, che è un file contenente il codice in linguaggio macchina, che la CPU (Central Processing Unit) sarà in grado di leggere, capire ed eseguire direttamente.

Dopodiché, il programma può girare e il computer fa quello che il programma gli dice di fare. I programmi compilati hanno una corrispondenza più forte con l'hardware e possono manipolare più facilmente la CPU e la memoria del computer.

I programmi interpretati, d'altro canto, non sono eseguiti direttamente dalla macchina né hanno bisogno di essere tradotti in un programma in linguaggio macchina. Invece, utilizzano un interprete che traduce automaticamente e direttamente, ed esegue ogni dichiarazione o istruzione del codice riga per riga durante il run time.

C è un linguaggio di programmazione compilato. Ciò significa che usa un compilatore per analizzare il codice sorgente scritto in C che viene poi convertito in un file binario che l'hardware del computer può eseguire direttamente. Tutto ciò è specifico per ogni macchina.

Come utilizzare il compilatore GCC con esempi

Unix e altri sistemi simili hanno già un compilatore C integrato e installato. Questo vuol dire che Linux e MacOS hanno un compilatore integrato molto popolare, chiamato compilatore GCC (o GNU Compiler Collection).

Nel resto di questa sezione, vedremo alcuni esempi relativi a questo compilatore. Ho basato questi esempi su sistemi Unix o simili, quindi se hai un sistema Windows, assicurati di abilitare il sottosistema Windows per Linux.

Prima di tutto, assicurati di avere il compilatore GCC installato. Puoi verificarlo aprendo il terminale e scrivendo gcc --version nel prompt, tipicamente dopo il carattere $.

Se stai usando MacOS e non hai installato gli strumenti per sviluppatori da riga di comando, visualizzerai una finestra di dialogo che ti chiederà di installarli – quindi se la vedi, prosegui pure.

Una volta aver proceduto con l'installazione, apri un nuovo terminale e riscrivi il comando gcc --version. Se hai già installato gli strumenti da riga di comando, dovresti ottenere l'output qui sotto:

Il solo termine compilazione è un'astrazione e una semplificazione, dato che in realtà ci sono molti step che avvengono in dietro le quinte. Sono i dettagli di basso livello più sottili che avvengono tra il momento in cui scriviamo, la compilazione e l'esecuzione del programma in C, la cui maggior parte, avviene automaticamente senza che ce ne rendiamo conto.

Come scrivere il codice sorgente C

Per sviluppare dei programmi in C, abbiamo bisogno di un qualche tipo di editor di testo. Un editor di testo è un programma che usiamo per scrivere il nostro codice (chiamato codice sorgente) in un file di testo.

Per questo, abbiamo bisogno di un editor di testo da riga di comando come nano o Vim.

Puoi anche utilizzare un IDE (Integrated Development Environment) o un editor di testo con caratteristiche di IDE (un terminale integrato, la possibilità di scrivere, fare debug, eseguire i nostri programmi in solo posto senza lasciare l'editor, e molto altro).

Visual Studio Code è un editor con queste caratteristiche, e ha un'estensione C/C++. Per tutto il resto di questo tutorial useremo VSCode.

Tornando al nostro terminale, prosegui e scrivi i comandi qui sotto per creare un file in cui il nostro codice C prenderà vita.

`cd` # Ci porta alla directory principale, se non ci siamo già
`mkdir cprogram` # Crea una directory chiamata cprogram 
`cd cprogram` # Ci porta alla directory cprogram appena creata
`touch hello.c` # Crea un file chiamato hello
`code .` # Apre VSCODE nella directory attuale

Abbiamo appena creato un semplice file di testo, hello.c. Questo file conterrà il codice scritto in linguaggio C, ovvero sarà un programma in C, come indicato dall'estensione convenzionale .c.

Al suo interno possiamo scrivere qualsiasi programma in C desideriamo, partendo da uno estremamente semplice che dà come output 'Hello world'.

Per vedere cosa fa effettivamente il nostro codice, dobbiamo eseguire il programma che abbiamo appena scritto. Prima di farlo, però, dobbiamo compilarlo, scrivendo il comando nel terminale.

Possiamo continuare a usare la riga di comando sul nostro computer oppure possiamo usare il terminale integrato di VSCode (premendo insieme i tasti control ~ si aprirà una nuova finestra terminale).

Possiamo vedere che sul pannello di sinistra c'è solo un file nella cartella cprogram, hello.c, che contiene il nostro codice C.

La "compilazione del codice C" non avviene in un solo passaggio e include alcune azioni minori che si verificano automaticamente.

Quando ci riferiamo alla compilazione, intendiamo tipicamente che il compilatore prende il codebase come input (il codice che abbiamo scritto in C, che ha una sintassi simile all'inglese) e lo traduce per produrre delle istruzioni in linguaggio macchina come output.

Questo codice macchina corrisponde direttamente alle istruzioni del nostro codice sorgente, ma è scritto in un modo comprensibile dalla CPU, così che questa possa prendere le istruzioni ed eseguirle.

Come il codice sorgente in C viene trasformato in binario

Abbiamo descritto l'idea generale – ma nel processo sono coinvolti 4 passaggi minori. Quando compiliamo il nostro codice, in realtà lo stiamo precompilando, compilando, assemblando e collegando.

Questi step iniziano ad accadere quando scriviamo nel terminale il comando gcc hello.c, contenente il nome del compilatore e del file con il codice sorgente, rispettivamente.

Volendo, avremmo potuto personalizzare il comando scrivendone uno più specifico come gcc -o hello hello.c, dove:

• -o sta per 'output'
• hello è il nome che specifichiamo per il file eseguibile del programma di cui vogliamo che sia creato l'output
• hello.c è il file che il compilatore gcc prenderà come input (il file che contiene il nostro codice sorgente e che vogliamo compilare).

Un altro programma che è parte del compilatore svolge questo primo step – il preprocessore. Il preprocessore fa molte cose – ad esempio, agisce come uno strumento "trova e sostituisci", scansionando il codice sorgente in cerca di istruzioni particolari e righe che iniziano con #.

Le righe che iniziano con un #, come #include, vengono chiamate direttive di precompilazione. Ogni riga che inizia con un # indica al preprocessore che va fatto qualcosa. In particolare, comunica che la riga dovrebbe essere automaticamente sostituita con qualcos'altro. Non vediamo questo processo, ma accade dietro le quinte.

Ad esempio, quando il preprocessore trova la riga #include <stdio.h> nel programma hello world, #include dice letteralmente al preprocessore di inserire, con un copia e incolla, tutto il codice del file di intestazione (che è una libreria esterna, stdio.h) al posto di questa istruzione nel nostro codice sorgente. Quindi sostituisce la riga #include <stdio.h> con il contenuto del file stdio.h.

Nella libreria stdio.h ci sono prototipi di funzioni e definizioni o suggerimenti. In questo modo, tutte le funzioni sono definite in modo che il computer le riconosca durante il tempo di compilazione e che noi possiamo usarle nel nostro programma.

Ad esempio, all'interno di <stdio.h>, la funzione printf(); è definita come int printf(const char *format,…);. Gli stessi passaggi si verificano per gli altri file di intestazione (i file con l'estensione .h).

Durante la precompilazione, i commenti nel nostro codice vengono rimossi e le macro vengono espanse e rimpiazzate dai loro valori. Una macro è un frammento di codice a cui è stato dato un nome.

In questo stadio, se non ci sono errori nel nostro codice, non dovrebbe esserci un output nel terminale, il che è un buon segno.

Non vediamo nessun output, ma è stato creato un nuovo file con l'estensione .i, che è ancora in codice sorgente C. Questo file include l'output della precompilazione, quindi viene chiamato codice sorgente precompilato. In questo caso, è stato generato un nuovo file hello.i, ma non sarà visibile nel nostro editor.

Se eseguiamo il comando gcc -E hello.c:

Saremo in grado di vedere tutto il contenuto di questo file (che è piuttosto grande), la cui fine dovrebbe essere simile a:

Se ci sono degli errori che inficiano la correttezza del nostro codice o non stiamo seguendo la semantica del linguaggio, vedremo dei messaggi di errore e la compilazione si bloccherà. Dovremo correggere gli errori e far ripartire il processo dall'inizio.

La compilazione in C

Dopo la precompilazione, che produce il codice sorgente C precompilato, avviene la compilazione. Questo processo consiste nel prendere il codice (che è ancora codice sorgente in C) e modificarlo in un'altra forma intermedia. Questo passaggio viene svolto da un compilatore.

Per rinfrescarci la memoria, un compilatore è un programma che prende il codice sorgente come input e lo traduce in una forma più vicina al linguaggio nativo dei computer.

Riferendoci alla compilazione, possiamo intendere sia l'intero processo di traduzione del codice sorgente in un codice oggetto (codice macchina) o soltanto uno step specifico dell'intero processo di compilazione.

Il passaggio di cui stiamo discutendo adesso riguarda la conversione, da parte del compilatore, di ogni istruzione del codice sorgente C preprocessato in un linguaggio più familiare e più vicino al binario, il linguaggio che un computer può capire direttamente.

Questo linguaggio intermedio è codice assembly, un linguaggio di programmazione di basso livello usato per controllare la CPU e manipolarla per svolgere operazioni specifiche e avere accesso alla memoria del computer. Ricordi il codice assembly di cui abbiamo parlato nella sezione sulla storia di C?

Ogni CPU – il cervello del computer – ha le proprie istruzioni. Il codice assembly sfrutta delle istruzioni e dei comandi direttamente correlati con le istruzioni e le operazioni di basso livello che vengono svolte da una CPU.

In questo step del processo di compilazione, ogni istruzione del codice sorgente C preprocessato nel file hello.i è tradotta dal compilatore nell'istruzione equivalente in linguaggio assembly, a un livello più basso.

L'output di quest'azione crea un file con estensione .s (nel nostro caso hello.s) che contiene le istruzioni in assembly.

Con il comando gcc -S hello.c possiamo vedere il contenuto e i comandi in assembly piuttosto incomprensibili del file hello.s, creato dal compilatore (ma non visibile scrivendo semplicemente gcc hello.c).

Guardando con attenzione, vedremo un paio di parole chiave e istruzioni familiari, usate nel nostro codice sorgente C. Ad esempio, main e printf:

L'assemblaggio in C

L'assemblaggio consiste nel prendere come input il file hello.s contenente il codice assembly e, con l'aiuto di un altro programma che viene eseguito automaticamente nel processo di compilazione, assemblarlo in istruzioni in codice macchina. Questo vuol dire avere un output di istruzioni in formato binario, composto di una serie di 0 e 1.

Questo passaggio avviene in background e genera le istruzioni nel linguaggio finale, tradotte a partire dal nostro codice sorgente. Adesso il computer è finalmente in grado di capire le istruzioni.

Ogni comando che abbiamo scritto nel codice sorgente C è stato trasformato in istruzioni in linguaggio assembly e, infine, nelle istruzioni equivalenti in binario. Tutto ciò è accaduto con il comando gcc. Wow!

Il codice che abbiamo adesso è detto codice oggetto e può essere compreso da una specifica CPU. Il linguaggio è incomprensibile per noi umani.

Le persone programmavano in linguaggio macchina, ma era un procedimento tedioso. È difficile raccapezzarsi con tutti i simboli che non fanno parte del codice macchina (cioè tutto ciò che non è 0 o 1). Programmare in questo modo rende estremamente facile commettere degli errori.

In questo stadio, viene creato un altro file con un'estensione .o (che sta per oggetto) – hello.o nel nostro caso.

Possiamo vedere il contenuto del file oggetto contenente le istruzioni al livello macchina con il comando gcc -c hello.c. Se lo facciamo, in hello.o vedremo del contenuto non comprensibile da una persona:

Il collegamento in C

Nell'immagine qui sopra, potresti aver notato un file a.out nella nostra cartella.

Il file viene creato durante uno step di default quando digitiamo il comando del compilatore e il nome del file, gcc hello.c nel nostro caso.

Se usiamo il comando precedentemente menzionato gcc -o hello hello.c, vedremo un programma eseguibile con il nome personalizzato hello al posto di a.out.

a.out sta per assembly output. Se scriviamo ls sul terminale per vedere l'elenco dei file nella nostra cartella, vedremo che a.out ha anche un aspetto diverso dagli altri:

Il collegamento è il passaggio finale del processo di compilazione in cui il file finale in binario hello.o viene collegato con l'altro codice oggetto nel nostro progetto.

Quindi se ci sono altri file contenenti codice sorgente C (come file inclusi nel nostro programma che implementano librerie C già processate e compilate, o un altro file che abbiamo scritto oltre a hello.c, chiamato, ad esempio, nomefile.c), questo è il momento in cui il file oggetto nomefile.o verrà combinato con hello.o e gli altri codici oggetto, e risulteranno collegati tutti insieme.

Il risultato è un grande file eseguibile con il codice macchina combinato, a.out o hello, che rappresenta il nostro programma.

Dato che abbiamo finalmente terminato il processo di compilazione, il programma è nella sua forma finale e possiamo eseguire il file sulla nostra macchina scrivendo ./a.out. Questo vuol dire 'eseguire il file a.out che è nella cartella di lavoro attuale', dato che ./ rappresenta la cartella in cui ci troviamo. Poi vedremo l'output del nostro programma sul terminale:

Ogni volta che apportiamo dei cambiamenti al nostro file con il codice sorgente, dobbiamo ripetere il processo di compilazione dall'inizio per poter vedere le modifiche quando eseguiamo di nuovo il codice.

Come scrivere Hello World in C

Hello world è un programma estremamente semplice, ma scriverlo è una tradizione quando stai imparando a programmare in un nuovo linguaggio.

Se esegui con successo il tuo programma Hello world, sai che il tuo sistema è configurato correttamente.

Un programma Hello world contiene la sintassi di base del linguaggio:

#include<stdio.h>

int main(void)
{
    // stampa hello world sullo schermo
	printf("Hello world\n");
}

Nelle prossime sezioni analizzeremo le varie parti che lo compongono.

I File di intestazione in C

I file di intestazione sono librerie esterne, ovvero del codice già scritto da sviluppatori ad uso di altri sviluppatori.

Forniscono funzionalità che non sono incluse nel nucleo del linguaggio C. Aggiungendo i file di intestazione al codice, otteniamo funzionalità aggiuntive da utilizzare nei nostri programmi.

I file di intestazione come include <stdio.h> terminano con l'estensione .h. In particolare, un file di intestazione come stdio.h è già integrato nel compilatore.

La riga include <stdio.h> è un'istruzione per le funzioni contenute nella libreria stdio.h,  che dice al computer di accedervi e includerle nel nostro programma.

stdio.h ci dà le funzionalità standard input e standard output, grazie alle quali saremo in grado di ottenere input e fornire output agli utenti. Quindi, dovremmo imparare a usare funzioni di input/output come printf.

Se non includi il file stdio.h all'inizio del codice, il computer non comprenderà cos'è la funzione printf.

Il programma main in C

Ecco il codice:

int main(void)
{
}

Questa è la funzione principale di partenza in C. Le parentesi graffe ({}) sono il corpo che contiene tutto il codice che dovrebbe essere nel nostro programma.

Questa riga agisce come modello e punto di partenza per tutti i programmi in C. Fa sapere al computer dove iniziare a leggere il codice durante l'esecuzione dei programmi.

Commenti in C

Tutto ciò che scriviamo dopo // non influenzerà l'esecuzione del nostro codice e non sarà preso in considerazione dal computer durante il tempo di compilazione ed esecuzione.

Le due sbarre indicano la presenza di un commento, ovvero una nota per noi e i nostri collaboratori. I commenti possono aiutarci a ricordare cosa fa una specifica riga di codice o perché si trova in quella posizione. Ci ricorda anche lo scopo preciso di una parte di codice quando torniamo a lavorarci su dopo un giorno o addirittura dopo alcuni mesi.

Ottenere un output sulla console in C

printf("Hello world/n"); stampa la frase 'Hello world' sulla console. Utilizziamo printf quando vogliamo scrivere qualcosa e vedere un output sullo schermo. I caratteri che fanno parte dell'output devono essere compresi tra virgolette doppie "" e parentesi ().

/n è un carattere di escape, che crea una nuova riga e comunica al cursore di muoversi a capo quando viene incontrato.

; indica la fine della frase e la fine della riga di codice.

Variabili in C

Ecco come definiamo una variabile in C:

Un elemento di dati che può assumere uno o più valori durante il runtime di un programma.

In termini più semplici, puoi pensare a una variabile come una scatola con un nome. Una scatola che agisce come posto per immagazzinare diverse informazioni e il cui contenuto può variare.

Ogni scatola ha un nome unico, che ha la funzione di etichetta identificativa che ci informa sul contenuto della scatola. Il contenuto è il valore della variabile.

Le variabili contengono e puntano a un valore, a qualche dato utile. Agiscono come riferimento o astrazione per dati letterali. Questi dati sono conservati nella memoria del computer e occupano un certo spazio. Si trovano lì, così che possiamo recuperarli per usarli quando ne abbiamo bisogno più avanti nei nostri programmi.

Come suggerisce il nome, ciò a cui fa riferimento una variabile può variare. Le variabili sono in grado di assumere valori diversi nel tempo, in base alle informazioni che cambiano durante la vita del programma.

Assegnazione delle variabili in C

Il processo di dare un nome a una variabile si chiama assegnazione. Ciò avviene tramite l'uso dell'operatore di assegnazione =, impostando un valore specifico per un nome specifico, rispettivamente alla destra e alla sinistra dell'operatore.

Come già detto, puoi cambiare il valore della variabile, quindi puoi assegnare e riassegnare variabili. Quando riassegni un valore, il nuovo valore punta al nome della variabile. Quindi, il valore può cambiare, ma il nome della variabile resta invariato.

Come dichiarare e inizializzare una variabile in C

A differenza di molti altri moderni linguaggi di programmazione, l'assegnazione dei tipi delle variabili in C segue una tipizzazione statica forte.

Nei linguaggi tipizzati staticamente, devi dichiarare esplicitamente il tipo di dato di una variabile. In questo modo, durante il tempo di compilazione, il compilatore conosce se una variabile è in grado di eseguire l'azione stabilita e richiesta.

Nei linguaggi tipizzati dinamicamente, una variabile può passare tra differenti tipi di dati senza bisogno di una definizione esplicita del tipo di dato.

Dunque, quando dichiariamo una nuova variabile in C, dobbiamo definire e specificare il tipo della variabile, ovvero il tipo del valore che contiene.

In questo modo, il programma e poi il compilatore conoscono la natura dell'informazione memorizzata.

Per dichiarare una variabile, devi specificare il tipo di dato e dare un nome alla variabile. Uno step opzionale è impostare un valore iniziale. Non dimenticare il punto e virgola alla fine, per terminare l'istruzione!

#include <stdio.h>
 
int main(void)
{
  int n = 27;
  // int è il tipo di dato
  // n è il nome 
  // n può contenere valori interi
  // numeri interi positivi/negativi o 0
  // = è l'operatore di assegnazione
  // 27 è il valore
}

Qual è la differenza tra inizializzare e dichiarare una variabile?

In sostanza:

int n; // dichiarazione: crea una variabile chiamata n in grado di contenere valori interi
int n = 27; // inizializzazione: crea una variabile chiamata n e assegna un valore, memorizzando il numero nella variabile

int n; è la dichiarazione della variabile. Dichiarare vuol dire definire un nome per la variabile e specificarne il tipo.

Non dobbiamo necessariamente specificare un valore per la variabile, basta questo. Infatti, la dichiarazione comunica al computer che vogliamo che la variabile esista e abbiamo bisogno di assegnarle dello spazio in memoria. Il valore sarà immagazzinato in un secondo momento.

In seguito, quando assegniamo il valore alla variabile, non c'è bisogno di specificare di nuovo il tipo di dato. Possiamo anche dichiarare più variabili in un colpo solo.

int nome, età;

Se dichiariamo una variabile e le assegniamo contemporaneamente un valore, stiamo inizializzando la variabile.

int n = 27; è l'inizializzazione della variabile. Vuol dire assegnare un valore iniziale che in seguito può essere cambiato.

Se il nuovo valore è dello stesso tipo di dato, non dobbiamo specificarlo. Se invece il tipo di dato è differente, otterremo un errore.

#include<stdio.h>

int main(void)
{
  int age = 27;
  age = 37;
  // il nuovo valore di age è 37
}

Nomenclatura delle variabili in C

• I nomi delle variabili devono iniziare con una lettera o con un trattino basso. Ad esempio age e _age sono dei nomi validi.
• Il nome di una variabile può contenere lettere (maiuscole o minuscole), numeri o un trattino basso.
• Non possono esserci altri caratteri speciali oltre il trattino basso.
• I nomi delle variabili sono case sensitive, quindi age è diverso Age.

Visibilità di una variabile in C

La visibilità (scope) di una variabile fa riferimento a dove è possibile avere accesso alla variabile. È essenzialmente lo spazio in cui la variabile si trova ed è valida, e il modo in cui è vista dal resto del programma.

Visibilità locale

Se una variabile viene dichiarata all'interno di un set di parentesi graffe, {}, come una specifica funzione, avrà una visibilità locale (local scope) e non sarà possibile avere accesso alla variabile nel resto del programma al di fuori delle parentesi. Il resto del programma non saprà che esiste.

Perciò, può non essere una buona idea dichiarare variabili in questo modo, in quanto la visibilità e l'utilizzo limitati possono generare degli errori.

Visibilità globale

Se le variabili vengono dichiarate al di fuori delle funzioni, hanno una visibilità globale (global scope). Avere una visibilità globale vuol dire che vi si può accedere da ogni parte del programma.

Ma tieni a mente che può essere difficile tenerne traccia. Ogni cambiamento che facciamo strada facendo può confondere, dato che può avvenire in qualsiasi parte del programma.

Tipi di dati in C

I tipi di dati specificano in che forma possiamo rappresentare e immagazzinare un'informazione nel nostro programma in C. Ci permettono di conoscere come potrà essere utilizzata quell'informazione e le operazione che vi potranno essere eseguite.

I tipi di dati determinano anche quale può essere il contenuto di una variabile, dato che ogni variabile in C ha bisogno di una dichiarazione esplicita del tipo di dato.

Ci sono 6 tipi di dati integrati nel linguaggio, ma è possibile convertire tipi diversi. Ciò fa sì che il linguaggio non sia così fortemente tipizzato.

Ogni tipo di dato richiede una diversa assegnazione di memoria e può avere degli intervalli di valori validi differenti.

Aggiungere parole chiave prima del nome di un tipo di dato lo modifica. Queste parole chiave possono essere unsigned o signed.

La parola chiave unsigned sta a significare che il tipo può essere soltanto positivo e non negativo, mentre signed permette di avere un numero negativo o positivo.

Diamo un'occhiata più dettagliata a questi tipi di dati.

Il tipo di dato char in C

Il tipo di dato più semplice in C è char. Si utilizza per caratteri singoli come quelli della tabella ASCII come 'a', 'Z', o '!" (nota l'uso delle virgolette singole per circondare il carattere – non puoi utilizzare le virgolette doppie in questo caso).

char ti permette anche di memorizzare i numeri da -128 a 127 e in entrambi i casi utilizza 1 byte di memoria.

Un unsigned char può assumere i valori da 0 a 255.

Il tipo di dato int in C

int è un numero intero che può contenere un valore positivo o negativo o 0 senza decimali.

È un valore con un numero di bit limitato. Quando dichiari un int, il computer gli assegna 4 byte di memoria (più specificamente utilizza almeno 2 byte, ma di solito ne usa 4). 4 byte di memoria equivalgono a 32 bit (dato che 1 byte = 8 bit). Quindi un int ha 2³² possibili valori – più di 4 miliardi di interi possibili.

L'intervallo va da -2³¹ a 2³¹-1, più precisamente da -2,147,483,648 a 2,147,483,647.

• Un unsigned int ha ancora la stessa dimensione in memoria di un intero (4 bytes) ma non include i numeri negativi nell'intervallo dei valori possibili, che quindi va da 0 a 2³²-1, più precisamente da 0 a 4,294,969,295
• Uno short int ha un valore più piccolo di un int e occupa 2 byte di memoria. È compreso nell'intervallo da -32,768 a 32,767
• Un unsigned short int occupa 2 byte di memoria e è compreso tra 0 e 65,535
• Un long int è destinato a numeri grandi. Occupa almeno 4 byte di memoria, ma solitamente occupa 8 byte ed è compreso tra -2,147,483,648 e 2,147,483,647
• Un unsigned long int occupa almeno 4 byte di memoria ed è compreso tra 0 e 4,294,967,295
• Un long long int è un intero con più bit che è in grado di contenere numeri più grandi di un int o un long int. Occupa 8 byte (64 bit) invece di 4. Questo permette un intervallo più ampio, da -2⁶³ a 2⁶³-1, più precisamente da -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807
• Un unsigned long long utilizza 8 bytes e va da 0 a 18,446,744,073,709,551,615

Il tipo di dato float in C

I float sono numeri con una parte decimale (anche detti numeri reali), con precisione singola, e occupano 4 byte di memoria.

Il tipo di dato double in C

Un double è un numero decimale con un valore maggiore di un float. Occupa più memoria rispetto a un float – 8 bytes – e ha precisione doppia.

• Un long double è di dimensione maggiore in confronto a un float e un double e occupa almeno 10 byte di memoria, fino a un massimo di 12 o 16 byte.

Infine, il tipo di dato void significa essenzialmente nessun valore.

Specificatori di formato in C

Gli specificatori di formato vengono utilizzati per gli input e gli output in C.

Sono un modo per comunicare al compilatore che tipo di dato accetta una variabile come input e quale tipo di dato produce come output utilizzando la funzione printf(). La f in printf() sta per formattato.

Agiscono come un segnaposto per un formato di codice e sostituiscono le variabili. Fanno sapere in anticipo al compilatore di che tipo sono quando il valore dell'output standard (ovvero ciò che vogliamo stampare) non è ancora conosciuto.

La sintassi che usiamo è % specificatore di formato per il tipo di dato:

#include<stdio.h>
int main(void)
{
	int age = 27;
	printf("My age is %i/n", age)
	// stampa 27
// age è la variabile che vogliamo usare 
// %i è lo specificatore di formato, un segnaposto per un valore intero
// separiamo ogni argomento con una virgola
// nell'output %i  viene sostituito con il valore di age
}

Ci sono diversi specificatori di formato per ogni tipo di dato di cui abbiamo parlato precedentemente. Eccone alcuni:

Operatori in C

Operatori aritmetici in C

Gli operatori aritmetici sono operatori matematici che eseguono funzioni matematiche su dei numeri. Le operazioni includono l'addizione, la sottrazione, la moltiplicazione e la divisione.

Gli operatori utilizzati più di frequente sono:

• + per l'addizione
• - per la sottrazione
• * per la moltiplicazione
• / per la divisione
• % per la divisione con modulo (restituisce il resto della divisione)

Operatore di assegnazione in C

L'operatore di assegnazione = assegna un valore a una variabile. In altre parole, imposta qualsiasi cosa si trovi sul lato destro di = come valore della variabile sul lato sinistro di =.

Esistono specifici operatori di assegnazione per aggiornare una variabile modificandone il valore.

In C, ci sono diversi modi per aggiornare il valore delle variabili. Ad esempio, se vogliamo incrementare il valore della variabile di 1, abbiamo tre modi possibili per farlo.

Prima di tutto, vale la pena precisare che incrementare vuol dire prendere il valore attuale della variabile, qualsiasi valore sia sulla destra, e aggiungervi  1. Il nuovo valore viene memorizzato nella variabile e aggiornato automaticamente.

Consideriamo di voler incrementare o aggiornare una variabile chiamata x con un valore iniziale di 5:

x=5.

Per aggiungere 1 alla variabile x, scriviamo  x = x + 1 che vuol dire x = 5 + 1.

Il nuovo valore di x adesso è 6, x=6.

Esiste una scorciatoia per questa operazione, utilizzando una sintassi particolare che incrementa le variabili.

Invece di scrivere x = x +1 scriviamo x += 1.

Un modo ancora più corto è utilizzare l'operatore di incremento, che segue la sintassi nome_variabile ++, quindi nel nostro caso x ++.

La stessa cosa vale per diminuire, ovvero decrementare, una variabile di 1.

I tre modi per farlo sono rispettivamente:

x = x-1, x -= 1, x -- (usando l'operatore di decremento).

Questi sono i modi per incrementare e decrementare una variabile di 1 in C. Siamo in grado di aggiornare una variabile prendendo il suo valore e aggiungendo, sottraendo, moltiplicando e dividendo quel valore per un altro numero, e poi impostando il risultato dell'operazione come nuovo valore. Queste operazioni sono rispettivamente +=, -=, *= e /=.

Quindi con x = x * 5 oppure con la scorciatoia x *= 5 il valore della variabile x sarà moltiplicato per 5 e poi memorizzato in x.

Operatori logici in C

In C, utilizziamo gli operatori logici per prendere decisioni. Il risultato di questo tipo di operazioni può essere vero (true) o falso (false).

L'operatore logico && (and) necessita che gli operandi posti sia al lato sinistro che al destro di && siano veri affinché la condizione sia verificata.

L'operatore logico || (or) necessita che almeno uno degli operandi sul lato destro e sinistro di || sia vero affinché la condizione sia verificata.

Infine, l'operatore logico ! (not) inverte il valore dell'operando. Se un operando è true, allora l'operatore ! rende la condizione false e vice versa.

Operatori di confronto in C

Gli operatori di confronto sono:

• Maggiore di >
• Maggiore di o uguale a >=
• Minore di <
• Minore di o uguale a =<

Esiste anche l'operatore di uguaglianza, ==, da non confondere con =, l'operatore di assegnazione.

Usiamo == per confrontare due valori e testare che siano uguali oppure no. Questo operatore pone la domanda 'Questi due elementi sono uguali?', mentre = assegna un valore a una variabile.

Utilizzando l'operatore di uguaglianza (che pone la domanda qui sopra) c'è sempre un valore di ritorno che può essere true o false. Questi ultimi sono conosciuti nel mondo della programmazione come valori booleani.

Infine, abbiamo l'operatore di disuguaglianza, !=, utilizzato per verificare se due valori non sono uguali.

Funzioni in C

Le funzioni sono parti di codice che svolgono piccole azioni. Eseguono un compito specifico.

Incorporano una parte di un processo che è pensato per essere ripetuto più volte. Lo scopo delle funzioni è di avere un certo procedimento scritto soltanto una volta, così da poterlo riutilizzare all'occorrenza, più volte e in posti differenti all'interno di un programma. In questo modo, il codice diventa più semplice e meglio organizzato.

Le funzioni hanno uno scopo particolare, esistono per eseguire un compito ed essere riutilizzate, accettando degli input per restituire degli output.

Argomenti di funzioni in C

Gli input che una funzione accetta sono detti argomenti. Una funzione può avere uno o più argomenti.

Una funzione comune nel linguaggio C è printf();, che stampa qualcosa sullo schermo. È una funzione usata per dire qualcosa.

Le parentesi () accolgono l'input della funzione. Al loro interno vanno gli argomenti – ovvero, ciò che vogliamo effettivamente dire e stampare sullo schermo, quindi quello che si trova tra le parentesi viene stampato.

In printf("Hello world!");, Hello world! è l'input della funzione printf. Qui, stiamo chiamando la funzione chiamata printf e le stiamo dando come argomento una stringa, dicendo specificatamente di stampare sullo schermo 'Hello world!'.

Output di funzioni in C

Esistono due tipi di output di funzioni:

• I primi sono output visuali, con un effetto immediato, qualcosa che viene stampato velocemente sullo schermo.
  Non puoi fare altro con questi output in seguito al loro effetto. Come nel caso di printf("Hello world!");, la stringa di output "Hello world!" viene stampata sullo schermo, e fine. Non puoi usare quella stringa in un altro modo, perché printf non ha un valore di ritorno.
  Questi tipi di funzioni sono conosciuti come effetti collaterali, nel senso che hanno un effetto osservabile immediato senza restituire un valore.
  Inoltre, una funzione come printf è un'invocazione di funzione e nella libreria stdio è definita come int printf(const char *format,...);.
• I secondi sono riutilizzabili, in quanto sono dei valori di ritorno. Un valore di ritorno è un valore restituito al programmatore e conservato in una variabile per essere utilizzato in un secondo momento.
  In questo caso, l'effetto non è immediato – non viene stampato nulla sullo schermo. L'output ci viene restituito, conservato come informazione e salvato in una variabile.

Come definire un metodo in C

Ci sono tre cose che hai bisogno di avere nella prima riga, la riga di dichiarazione, quando definisci una funzione.

1. Il tipo del valore di ritorno
   Questa è la prima parola chiave utilizzata e appena la funzione inizia indica il valore di ritorno.
   Ad esempio, in una funzione come void say_something(void), il primo void vuol dire che la funzione non ha valore di ritorno.
   In un altro esempio con una funzione diversa, int main(void), specifichiamo e definiamo il tipo del valore di ritorno come int. L'output della funzione sarà un dato di tipo int e sarà restituito quando la funzione è invocata.
2. Il nome della funzione
   Il nome può essere qualsiasi cosa, tuttavia è una buona pratica chiamare i metodi con dei nomi pertinenti alle azioni che svolgono.
3. Nessuno, uno o più argomenti
   Sono gli input della funzione e il tipo di dati degli input.
   In void say_something(void), il void tra parentesi è una parola chiave per l'argomento e un segnaposto per "niente". Significa che la funzione non accetta input. In casi come questo, l'argomento è anche detto parametro.
   I parametri sono essenzialmente variabili dichiarate nella funzione, all'interno delle parentesi come la parola chiave void. Agiscono come segnaposto per accedere ai dati di input della funzione, gli argomenti.
   I parametri fanno riferimento al valore che viene passato al metodo. Ciò vuol dire che quando chiamiamo la funzione in un secondo momento, le passiamo il valore reale, ovvero l'argomento.

Come chiamare una funzione in C

Possiamo chiamare una funzione come:

void say_hi(void)
{
	printf("hello");
}

scrivendo il nome della funzione seguito dagli argomenti tra parentesi e un punto e virgola, come say_hi();. La funzione say_hi non accetta input e non ha un valore di ritorno. La invochiamo solo per stampare 'hello' sullo schermo.

Un'altra funzione come:

int square(int n)
{
	return n * n
}

viene chiamata nello stesso modo dell'esempio precedente. In questo caso, la funzione square accetta un input e ha un valore di ritorno (sono entrambi int). L'input che prende è il parametro chiamato n, che restituisce un int quando la funzione è invocata.

La parola return specifica quello che sarà restituito, l'input n moltiplicato per sé stesso.

Ad esempio, quando la funzione è chiamata con square(3);, n agisce come una variabile che punta al parametro che è stato passato alla funzione, cioè 3. È come se avessimo impostato n = 3, e il valore restituito è 9.

Le funzioni sono pensate per essere riutilizzate, quindi la possiamo usare ogni volta che vogliamo il quadrato di un numero:

#include <stdio.h>

  int square(int x)
  {
    return x * x;
  }
 
  int main(void)
  {
   printf("%i\n", square(2));
   printf("%i\n", square(4));
   printf("%i\n", square(8));
 }

Come usare le espressioni booleane in C

Un'espressione booleana è un'espressione il cui valore può essere true o false. Queste espressioni prendono il loro nome dal matematico, filosofo e logico George Boole.

Usiamo le espressioni booleane per confrontare due valori, e sono particolarmente utili nelle strutture di controllo.

Ogni valore diverso da 0 è true e 0 è false.

Possiamo combinare espressioni booleane con l'uso di operatori logici differenti, come && (and), || (or) e ! (not) di cui abbiamo parlato precedentemente.

Combinazioni differenti di valori e operatori portano a diversi risultati di output, che possono essere riassunti in una tabella della verità, una tabella matematica usata per rappresentare equazioni logiche il cui risultato è 1 o 0, o il loro equivalente true o false.

Quando confrontiamo due valori booleani usando l'operatore && (and), entrambi i valori devono essere veri affinché lo sia anche l'espressione combinata.

Ad esempio, se qualcuno ci chiede "Vuoi una pizza e dell'insalata?", l'unico modo per cui l'espressione sia vera è che noi vogliamo entrambi i cibi (quindi che la nostra risposta sia sì per tutti e due). Se la risposta per uno dei due non è valutata come true, allora l'espressione combinata è false.

Tabella della verità per &&

A differenza di &&, l'operatore || non è esclusivo e l'espressione combinata viene valutata come vera se una o entrambe le espressioni sono vere.

Considerando la precedente domanda di esempio "Vuoi una pizza e dell'insalata?", se cambiamo l'operatore AND con OR, non significa che vogliamo entrambi i cibi. Possiamo volerne uno o l'altro e non necessariamente entrambi.

Tabella della verità per ||

Infine, l'operatore ! (not) viene usato per le negazioni. Ciò vuol dire che cambia true in false e false in true.

!true is false
!false is true

Come usare le istruzioni condizionali in C

Le istruzioni condizionali svolgono un'azione specifica in base al risultato di un'operazione di confronto. Sono dette strutture di controllo, poiché sono dei costrutti che governano il flusso di esecuzione, definendo lo svolgimento di un'azione nel caso una condizione sia vera, ed eventualmente un'azione differente nel caso sia falsa.

Alcune parti di un programma possono non essere eseguite a seconda di un risultato o di un certo input dell'utente. L'utente può percorrere diverse strade con varie biforcazioni durante la vita del programma.

I programmi con istruzioni condizionali sfruttano principalmente dei blocchi if. I blocchi if usano espressioni booleane che possono essere true o false, e "prendono decisioni" a seconda dei valori risultanti. Denotiamo il blocco di un'istruzione if usando le parentesi graffe, {}, e indentando il codice come segue.

#include <stdio.h>
int main(void)
{
int x = 2;
int y = 3;

if (x < y)
 
// x < y è un'espressione booleana, può essere solo true o false.
// Se tutto ciò che è nelle parentesi è true 
// -in questo caso x è effettivamente minore di y-
// viene eseguito il seguente codice
{
	printf("x è minore di y"); 

// Poiché x < y è true, la frase verrà stampata sulla console
}

}

Un'istruzione if da sola non è particolarmente utile, soprattutto se il programma cresce sempre di più. In questo caso, l'istruzione if è accompagnata dall'istruzione else.

Il codice qui sotto si comporta in questo modo: se la condizione di if è true viene eseguito il blocco corrispondente, altrimenti viene eseguito il blocco else. La parola chiave else è la soluzione per il caso in cui la condizione di if è falsa e quindi il codice correlato non viene eseguito.

int main(void)
{ 
int  x = 1;
int  y = 2;

if ( x > y)
{
  printf("x è maggiore di y");
}

else 

{  
  printf("x è minore di y");
// Poiché  x > y è false ,
// Questo blocco di codice viene eseguito
// e viene stampata sullo schermo la frase del ramo else
}

}

Se desideriamo scegliere tra più di due opzioni e vogliamo una varietà maggiore di istruzioni e azioni, possiamo introdurre una condizione else if.

Il codice qui sotto si comporta in questo modo: se la condizione è true viene eseguito il primo corrispondente, in caso contrario viene valutata la condizione del blocco else if. Se è true il blocco viene eseguito, altrimenti viene eseguito il blocco else.

#include <stdio.h>
int main(void)
{
  int x = 2;
  int y = 2;

  if(x < y)
   // Se la condizione è true esegui questo blocco
  {
    printf("x è minore di y");
  }
 else if(x > y)
  // Se invece questa condizione è true esegui questo blocco
 { 
    printf("x è maggiore di y");
 } 
 else  
   // Se questo blocco di codice viene eseguito  
   // è perché x < y è false 
  // e anche x > y è false
  // il che vuol dire che x == y
 {
    printf("x è uguale a y");
 }
}

Come usare i loop in C

Un loop è un insieme specifico di istruzioni che sono ripetute un certo numero di volte, fino a che una certa condizione viene raggiunta. Si tratta di una stessa azione, uno stesso codice ripetuto ancora e ancora.

Loop while in C

Prima di eseguire qualsiasi codice, i loop while devono valutare una condizione. Se la condizione è verificata, il codice viene eseguito. In caso contrario, il codice non partecipa all'azione. Quindi, l'esecuzione del codice non è garantita neanche una volta se la condizione non si verifica.

Esistono diversi tipi di loop while, e uno di questi è il loop infinito.

#include <stdio.h> 
int main(void)
{

	while(true)
	{
		printf("Hello world");
	}
}

La parola chiave while è usata insieme all'espressione booleana, in questo caso true (che resta sempre true).

Dopo aver stampato la riga di codice all'interno delle parentesi graffe, la condizione viene rivalutata per sapere se eseguire ancora il corpo del loop. La risposta è sempre sì (dato che la condizione resta true ogni volta), così che l'esecuzione del loop continua indefinitamente.

In quest'esempio, l'unico modo per fermare il programma e uscire da questo loop senza fine è con il comando Ctrl + C dal terminale.

Se invece la condizione fosse stata false, il codice all'interno delle parentesi graffe non sarebbe mai stato eseguito.

Un altro loop, è quello che ripete qualcosa un certo numero di volte.

#include <stdio.h>
int main(void)
{
	int i = 0;

	while(i < 10)
	{
	// Quando i è minore di 10 esegui questo codice
		printf("Hello world");
	// e poi incrementa i
		i++
	// valuta la condizione ogni volta
  // una volta eseguito il codice tra le parentesi graffe, valuta se i è ancora minore di 10.
  // In questo caso esegui il codice, incrementa e poi valuta ancora
	// Il loop terminerà quando i eguaglia 10
	}
}

Loop do-while

#include <stdio.h>
 
int main(void)
 {
   int i = 10;
   do {
      printf("the value of i: %i\n", i);
      i++;
   }
  while( i < 20 );
}

In confronto a un loop while, l'esecuzione di un loop do- while è garantita almeno una volta.

Compie prima un'azione e poi valuta la condizione. Può essere utile se vogliamo ripetere qualcosa per un certo numero di volte, e almeno una volta.

Nel nostro esempio, il codice viene eseguito almeno una volta e la frase viene stampata almeno una volta. Poi, il valore viene incrementato e viene valutato che sia minore di 20. In tal caso, il codice è eseguito nuovamente. Il loop termina una volta che il valore incrementato ogni volta non è più minore di 20.

Conclusione

Siamo arrivati alla fine di questa introduzione al linguaggio di programmazione C! Spero di averti dato l'infarinatura necessaria a comprendere i fondamenti di C e per iniziare a scrivere dei programmi di base in questo linguaggio.

Grazie per aver letto questo articolo.
Buona programmazione!

Se hai bisogno di ripetere un blocco di codice più volte, puoi utilizzare dei loop.

Queste ripetizioni dello stesso blocco di codice, per un certo numero di volte, sono dette iterazioni e il numero delle iterazioni viene determinato dalla condizione del loop.

I loop for e while sono ampiamente utilizzati in quasi tutti i linguaggi di programmazione.

In questo tutorial, parleremo dei loop for in C. In particolare, imparerai:

• la sintassi per usare i loop for
• come funzionano i loop for in C
• l'eventualità di creare loop for infiniti

Iniziamo!

Sintassi e funzionamento dei loop for in C

In questa sezione, imparerai la sintassi di base dei loop for in C.

La sintassi generale per usare un loop for è mostrata di seguito:

for(initialize; check_condition; update)
    {
        //esegui questo
    }

Nel blocco qui sopra:

• initialize è l'istruzione di inizializzazione – qui viene inizializzata la variabile di controllo del loop.
• check_condition è la condizione che determina se il loop deve continuare.

Finché check_condition risulta vera, il corpo del loop viene eseguito.

• L'istruzione update aggiorna la variabile di controllo del loop dopo l'esecuzione delle istruzioni nel corpo del loop.

Struttura di controllo dei loop for in C

La struttura di controllo è la seguente:

1. Inizializzazione del conteggio – l'istruzione initialize viene eseguita. Questo accade solo una volta, all'inizio del loop.
2. Verifica della condizione del loop – viene valutata l'espressione check_condition. Se la condizione è true, si passa allo step 3. Se è false, si esce dal loop.
3. Esecuzione delle istruzioni nel corpo del loop.
4. Aggiornamento del conteggio – viene eseguita l'istruzione update.
5. Si torna allo step 2.

Tutto ciò è illustrato qui sotto:

Ora che hai un'idea di come funziona un loop for, prendiamo un esempio semplice per vedere un loop for in azione.

Esempio di loop for in C

Scriviamo un semplice loop for per contare fino a 10 e stampare il valore del conto durante ogni passaggio attraverso il loop.

#include <stdio.h>

int main() 
{
   for(int count = 0; count <= 10; count++)
   {
       printf("%d\n",count);
   }
   return 0;
}

Nel blocco di codice qui sopra:

• count è la variabile contatore ed è inizializzata a 0.
• La condizione del loop è count <= 10. Dunque, count può essere al massimo 10 affinché il loop continui.
• Nel corpo del loop, viene stampato il valore di count.
• E il valore di count viene aumentato di 1.
• Il controllo poi raggiunge la condizione count <= 10 e le iterazioni proseguono finché la condizione risulta verificata.
• In quest'esempio, la condizione del loop count < = 10 diventa false quando il valore di count è 11 – e il loop termina.

Ed ecco l'output:

//Output
0
1
2
3
4
5
6
7
8
9
10

Dovresti sempre fare attenzione che il tuo loop termini effettivamente ad un certo punto.

Sai che il loop continua finché la condizione check_condition è true, mentre si ferma quando check_condition diventa false. Ma cosa accade se la condizione del loop è sempre true?

Bene, questo è ciò che accade se ti imbatti in un loop infinito. Il loop prosegue per sempre, finché il programma non va in crash o il tuo sistema si spegne.😢

Imparerai di più sui loop infiniti nella prossima sezione.

Loop for infiniti

Se il tuo loop non si ferma e continua ad oltranza, allora, hai un loop infinito. Facciamo qualche esempio per capire meglio.

▶ Nella costruzione del loop for, se non specifichi la condizione del loop (check_condition), viene assunta come true di default.

Come risultato, la condizione non diventa mai falsa e il loop continua a iterare indefinitamente fino a che non interrompi forzatamente il programma.

Ecco un loop infinito nello snippet di codice qui sotto:

#include <stdio.h>

int main()
{
    
    for(int i = 0; ; i++) //la condizione di test non è indicata
    {
        printf("%d ",i);
    }
    
    return 0;
}

▶ Vediamo un altro esempio.

Inizializzi la variabile contatore i a 10. Aumenti i di 1 dopo ogni iterazione.

Nota che la condizione di test è i > 0, ma il valore di i sarà sempre maggiore di 0.

Quindi, otterrai un loop infinito:

#include <stdio.h>

int main()
{
    
    for(int i = 10; i > 0 ; i++) //la condizione di test è sempre TRUE
    {
        printf("%d ",i);
    }
    
    return 0;
}

▶ In quest'esempio, la variabile contatore i è inizializzata a 0, ma decresce di 1 a ogni iterazione.

Di conseguenza, i sarà sempre minore di 10,  la condizione i < 10 risulterà sempre true e il loop sarà infinito.

#include <stdio.h>

int main()
{
    
    for(int i = 0; i < 10 ; i--) //la condizione di test è sempre TRUE
    {
        printf("%d",i);
    }
    
    return 0;
}

Per evitare di eseguire loop infiniti, dovresti definire correttamente la condizione del loop.

Se sei un principiante, porti queste domande potrebbe aiutarti:

Cosa voglio che faccia questo loop?
Quante volte voglio che il loop venga eseguito?
Quando dovrebbe fermarsi?

Poi, puoi proseguire e costruire il tuo loop di conseguenza. 🙂

Conclusione

Spero che questo tutorial ti sia stato d'aiuto.

Per ricapitolare, abbiamo imparato la sintassi e il funzionamento dei loop for. Abbiamo anche anticipato la possibilità di definire dei loop for infiniti e parlato di come evitarli, definendo la condizione di loop con attenzione.

Ci vediamo presto per un altro tutorial. Fino ad allora, buona programmazione!

I programmatori usano l'operatore ternario per prendere decisioni al posto delle più lunghe espressioni condizionali if ed else.

L'operatore ternario accetta tre argomenti:

1. Il primo è l'argomento di comparazione
2. Il secondo è il risultato per una comparazione vera
3. Il terzo è il risultato per una comparazione falsa

Potresti pensare all'operatore ternario come a un modo breve per scrivere una espressione if-else. Ecco un piccolo esempio decisionale usando if e else:

int a = 10, b = 20, c;

if (a < b) {
    c = a;
}
else {
    c = b;
}

printf("%d", c);

Questo esempio occupa più di 10 righe, ma non è necessario che sia così lungo. Puoi scrivere questo programmino in tre righe di codice usando un operatore ternario.

Sintassi

condizione ? valore_se_vero : valore_se_falso

L'espressione diventa valore_se_vero se condizione è vera, e valore_se_falso altrimenti.

Ecco l'esempio sopra riscritto usando l'operatore ternario:

int a = 10, b = 20, c;

c = (a < b) ? a : b;

printf("%d", c);

L'output dell'esempio sarà:

10

c prende il valore di a, perché la condizione a < b è vera.

Ricorda che gli argomenti valore_se_vero e valore_se_falso devono essere dello stesso tipo e possono essere solo espressioni semplici.

Gli operatori ternari possono essere annidati proprio come le espressioni if-else. Considera il seguente codice:

int a = 1, b = 2, ans;
if (a == 1) {
    if (b == 2) {
        ans = 3;
    } else {
        ans = 5;
    }
} else {
    ans = 0;
}
printf ("%d\n", ans);

Ecco il codice sopra riscritto usando un operatore ternario annidato:

int a = 1, b = 2, ans;
ans = (a == 1 ? (b == 2 ? 3 : 5) : 0);
printf ("%d\n", ans);

L'output di entrambi i codici qui sopra è:

3

Gli identificatori di formato definiscono il tipo di dati da stampare sull'output standard. È necessario utilizzare gli identificatori di formato sia che si stampi l'output formattato con printf() e sia che si accetti l'input con scanf().

Alcuni degli identificatori % che puoi utilizzare in ANSI C sono i seguenti:

Esempi:

Identificatore di formato a carattere singolo %c:

#include <stdio.h> 

int main() { 
  char first_ch = 'f'; 
  printf("%c\n", first_ch); 
  return 0; 
} 

Output:

f

Identificatore di formato stringa %s:

#include <stdio.h> 

int main() { 
  char str[] = "freeCodeCamp"; 
  printf("%s\n", str); 
  return 0; 
} 

Output:

freeCodeCamp

Immissione di caratteri con l'identificatore di formato %c:

#include <stdio.h> 

int main() { 
  char user_ch; 
  scanf("%c", &user_ch); // l'utente inserisce Y
  printf("%c\n", user_ch); 
  return 0; 
} 

Output:

Y

Input stringa con l'identificatore di formato %s:

#include <stdio.h> 

int main() { 
  char user_str[20]; 
  scanf("%s", user_str); // l'utente inserisce fCC
  printf("%s\n", user_str); 
  return 0; 
} 

Output:

fCC

Identificatori di formato intero decimale %d e %i:

#include <stdio.h> 

int main() { 
  int found = 2015, curr = 2020; 
  printf("%d\n", found); 
  printf("%i\n", curr); 
  return 0; 
} 

Output:

2015
2020

Identificatori di formato dei numeri in virgola mobile %f e %e:

#include <stdio.h>

int main() { 
  float num = 19.99; 
  printf("%f\n", num); 
  printf("%e\n", num); 
  return 0; 
}

Output:

19.990000
1.999000e+01

Identificatore di formato intero ottale %o:

#include <stdio.h> 

int main() { 
  int num = 31; 
  printf("%o\n", num); 
  return 0; 
}

Output:

37

Identificatore di formato intero esadecimale %x :

#include <stdio.h> 

int main() { 
  int c = 28; 
  printf("%x\n", c); 
  return 0; 
} 

Output:

1c

Se in precedenza hai già scritto il programma C helloworld, conosci già le basi dell'I/O dei file in C:

/* Un semplice hello world in C. */
#include <stdlib.h>

// Importa funzioni I/O.
#include <stdio.h>

int main() {
    // Questo printf è dove avviene tutta la magia IO del file!
    // Che emozione!
    printf("Hello, world!\n");
    return EXIT_SUCCESS;
}

La gestione dei file è una delle parti più importanti della programmazione. In C, utilizziamo un puntatore a una struttura di tipo file per dichiarare un file:

FILE *fp;

C fornisce una serie di funzioni integrate per eseguire operazioni di base sui file:

• fopen()- crea un nuovo file o apri un file esistente
• fclose()- chiude un file
• getc()- legge un carattere da un file
• putc()- scrive un carattere in un file
• fscanf()- legge un insieme di dati da un file
• fprintf()- scrive un insieme di dati in un file
• getw()- legge un numero intero da un file
• putw()- scrive un numero intero in un file
• fseek()- imposta la posizione sul punto desiderato
• ftell()- fornisce la posizione corrente nel file
• rewind()- imposta la posizione al punto iniziale

Apertura di un file

La funzione fopen() viene utilizzata per creare un file o aprire un file esistente:

fp = fopen(const char nomefile,const char modalità);

Ci sono molte modalità per aprire un file:

• r - aprire un file in modalità lettura
• w - apre o crea un file di testo in modalità scrittura
• a - apre un file in modalità "aggiungi"
• r+ - apre un file sia in lettura che in scrittura
• a+ - apre un file sia in lettura che in scrittura
• w+ - apre un file sia in lettura che in scrittura

Ecco un esempio di lettura di dati da un file e di scrittura su di esso:

#include<stdio.h>
#include<conio.h>
main()
{
FILE *fp;
char ch;
fp = fopen("hello.txt", "w");
printf("Inserisci il dato: ");
while( (ch = getchar()) != EOF) {
  putc(ch,fp);
}
fclose(fp);
fp = fopen("hello.txt", "r");

while( (ch = getc(fp)! = EOF)
  printf("%c",ch);
  
fclose(fp);
}

Ora potresti pensare: "Questo stampa solo il testo sullo schermo. Come fa a essere IO su file?"

La risposta non è così ovvia all'inizio e richiede una certa comprensione del sistema UNIX. In un sistema UNIX, tutto viene trattato come un file, il che vuol dire che puoi leggere e scrivere su di esso.

Quindi anche il tuo printer può essere astratto ad un file poiché quello che fai con un printer è scrivere con esso. È anche utile pensare a questi file come flussi, poiché come vedrai in seguito, puoi reindirizzarli con la shell.

Quindi, come si collega questo a helloworld e all'IO sui file?

Quando si chiama printf, in realtà si sta semplicemente scrivendo su un file speciale chiamato stdout, abbreviazione di standard output . stdout rappresenta l'output standard come deciso dalla tua shell, che di solito è il terminale. Questo spiega perché è stato stampato sullo schermo.

Ci sono altri due flussi (es. file) che sono disponibili per te con un certo impegno, stdin e stderr. stdin rappresenta lo standard input, che la tua shell di solito collega alla tastiera. stderr rappresenta l'output di errore standard , che la tua shell di solito lega al terminale.

IO rudimentale su File

Basta teoria, mettiamoci al lavoro scrivendo del codice! Il modo più semplice per scrivere su un file è reindirizzare il flusso di output utilizzando lo strumento di reindirizzamento dell'output, >.

Se vuoi effettuare una aggiunta alla fine del file, puoi usare >>:

# Questo stamperà sullo schermo...
./helloworld
# ...ma questo scriverà nel file!
./helloworld > hello.txt

Il contenuto di hello.txt, non a caso, sarà

Hello, world!

Supponiamo di avere un altro programma chiamato greet, simile a helloworld, che ti saluta con un dato name:

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

int main() {
    // Inizializza un array per contenre il nome.
    char nome[20];
    // Leggi la stringa e salvala in nome.
    scanf("%s", nome);
    // Print the greeting.
    printf("Ciao, %s!", nome);
    return EXIT_SUCCESS;
}

Invece di leggere dalla tastiera, possiamo reindirizzare stdin alla lettura da un file utilizzando lo strumento <:

# Scrivi un file contenente un nome.
echo Kamala > name.txt
# Questo leggerà il nome dal file e stamperà il saluto sullo schermo.
./greet < name.txt
# ==> Ciao, Kamala!
# Se vuoi anche scrivere il saluto su un file, puoi farlo usando ">".

Nota: questi operatori di reindirizzamento sono simili in bash e shell.

Il vero affare

I metodi di cui sopra funzionano solo per i casi più elementari. Se vuoi fare cose più complicate e fatte meglio, probabilmente dovrai lavorare con i file all'interno di C invece che attraverso la shell.

Per fare ciò, utilizzerai una funzione chiamata fopen. Questa funzione accetta due parametri stringa, il primo è il nome del file e il secondo è la modalità.

Le modalità sono fondamentalmente delle autorizzazioni, quindi r per leggere, w scrivere, a aggiungere. Puoi anche combinarli, quindi rw significa che potresti leggere e scrivere sul file. Ci sono più modalità, ma queste sono quelle più comunemente usate.

Dopo aver ottenuto un puntatore FILE, puoi utilizzare praticamente gli stessi comandi IO che hai già usato, tranne per il fatto che devi anteporre loro una f e il primo argomento sarà il puntatore del file. Ad esempio, la versione per i file di printf è fprintf.

Ecco un programma chiamato greetings che legge dati da un file contenente un elenco di nomi e scrive i saluti in un altro file:

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

int main() {
    // Crea i puntatori ai file.
    FILE *names = fopen("names.txt", "r");
    FILE *greet = fopen("greet.txt", "w");

    // Controlla che tutto sia OK.
    if (!names || !greet) {
        fprintf(stderr, "Apertura del file fallita!\n");
        return EXIT_FAILURE;
    }

    // Tempo di saluti!
    char nome[20];
    // Fondamentalmente continua a leggere finché non rimane più niente.
    while (fscanf(names, "%s\n", nome) > 0) {
        fprintf(greet, "Ciao, %s!\n", nome);
    }

    // Una volta raggiunta la fine, stampa un messaggio sul terminale per informare l'utente.
    if (feof(names)) {
        printf("I saluti sono terminati!\n");
    }

    return EXIT_SUCCESS;
}

Supponiamo che names.txt contenga quanto segue:

Kamala
Logan
Carol

Quindi dopo aver eseguito greetings il file greet.txt conterrà:

Ciao, Kamala!
Ciao, Logan!
Ciao, Carol!