Programmazione C, Informatica

Ingegneria meccanica: linguaggio C

Indice per argomenti

• Concetti base ..................................................................................................................................................... 3
• Operatori ........................................................................................................................................................... 5
• Operazioni ..................................................................................................................................................... 6
• Variabili .............................................................................................................................................................. 7
• Errori comuni ................................................................................................................................................. 9
• Printf ................................................................................................................................................................ 10
• Scanf ................................................................................................................................................................ 12
• If ....................................................................................................................................................................... 13
• Array ................................................................................................................................................................ 14
• For .................................................................................................................................................................... 17
• While e Do-While............................................................................................................................................. 18
• Matrici ............................................................................................................................................................. 21
• Strutture .......................................................................................................................................................... 22
• Esercizi ............................................................................................................................................................. 24

Concetti base

Un programma è una serie di istruzioni scritte in un linguaggio artificiale da un programmatore che sono comprensibili da un elaboratore e gli permettono di eseguire determinate operazioni. La sequenza di operazioni da svolgere è definita in un algoritmo rigoroso e completo, che non permette ambiguità di interpretazione, in quanto la macchina (elaboratore) non ha capacità simili a quelle dell’uomo in ambito decisionale.

Il linguaggio è composto da sequenze di codice che sfruttano una serie di funzioni contenute principalmente in librerie predefinite, ma che possono comunque essere create in base alle necessità dal programmatore; useremo:

• #include<stdio.h> standard input/output
• #include<string.h>
• #include<iostream> input/output stream

Il programma è costituito da almeno una funzione, il main, la funzione principale, senza la quale il programma non potrebbe funzionare.

Struttura di un programma:

#include<nome libreria>

• Librerie
• Altre Funzioni
• Funzioni aggiuntive
• Main int main(){corpo del main}

Il corpo del main contiene istruzioni e richiami per le funzioni scritte al di fuori del main (quelle messe in “funzioni aggiuntive”) o comunque a quelle disponibili nelle librerie caricate. Davanti a main dovremmo mettere void, ma il compilatore può dare problemi quindi si usa scrivere int. Subito dopo main notiamo due parentesi tonde: identificano il main come funzione e al loro interno possiamo scrivere delle variabili dichiarate all’esterno della funzione stessa.

Cosa significa ciò che viene scritto prima di una funzione (main)? Verrà spiegato più avanti, ma indica il tipo di variabile restituita dalla funzione, e visto che il main non deve restituire valori, usiamo scrivere void.

I tipi di istruzioni che possono essere costruite sono:

• Assegnamento (assegnare valori)
• Controllo (verificare determinate condizioni)
• Input/Output (richiesta e acquisizione di valori ad un utente)

Attenzione! Al termine di ogni istruzione semplice va messo “;” altrimenti il compilatore segnalerà un errore. Non va messo invece per blocchi di istruzioni, identificabili facilmente perché racchiusi tra due parentesi graffe “{“ e “}”.

Esempio:

#include<stdio.h> 
void main () { 
    int a=0,b; 
    b=a+5; 
}

Attenzione! Gli #include<> non vengono identificati come istruzioni semplici, quindi non vogliono il “;”. Ogni singola istruzione (terza e quarta riga) è un’istruzione semplice, mentre il main racchiude una serie di istruzioni (nota che sono racchiuse tra “{“ e “}”) definendo così un blocco, al termine del quale non va messo il “;”.

È buona norma che il programma sia commentato, che serve a chi programma per la fase di controllo, quella in cui si va alla ricerca dei problemi e si ripercorre il programma prima di mandarlo in esecuzione.

Esistono due modi diversi di commentare:

• Commento su un’unica riga: //Commento
• Commento su più righe: /* Commento. Si può andare a capo quante volte si vuole */

Scrivendo un programma è regola comune fare in modo che il codice possa respirare, ed è possibile ottenere ciò indentandolo, ovvero tabulandolo, facendo che il livello di ogni parte sia più “spostato” a destra (tabulato, indentato).

Operatori

Esistono tre tipi di operatori:

• Operatore di assegnamento: è il più semplice, ma il più utilizzato, è il simbolo “=”. Serve a copiare il contenuto della variabile o il risultato di un’espressione (matematica o di una funzione) posto alla sua destra nella variabile posta alla sua sinistra.
  • VariabileDoveCopiare = VariabileDaCopiare;
  • VariabileDoveCopiare = Espressione/Funzione;
  L’espressione matematica è possibile realizzarla con le classiche operazioni (+, -, *, /), ricordando che per effettuare la potenza viene utilizzata la notazione Base^(esponente), in cui le parentesi vanno messe obbligatoriamente se l’esponente non è un numero, mentre per la radice quadrata si usa la notazione sqrt(), dove il numero di cui ottenere la radice va posto all’interno delle parentesi tonde. Attenzione! Se in VariabileDoveCopiare è già presente un valore, dopo l’operazione assegnamento questo verrà sovrascritto. Esempio:

          int a=2, b=3; 
          a=b; 
          a=b+3; 
          b=a; 
          

• Operatori logici: corrispondono agli operatori AND, OR e NOT. Vengono utilizzati in istruzioni di controllo per indicare rispettivamente che le condizioni si debbano verificare contemporaneamente, che se ne debba verificare almeno una oppure che non si debbano verificare. Restituiscono il valore 1 se la condizione è verificata, 0 altrimenti (molto importante saperlo per le condizioni dei cicli iterativi o dei blocchi di selezione binaria).
  • AND &&
  • OR ||
  • NOT !
  Attenzione! Il programma riconosce automaticamente delle priorità di scrittura per verificare le condizioni (in ordine di priorità: !, &&, ||), ma per evitare ogni forma di problema basta usare in modo adeguato le parentesi tonde.
• Operatori relazionali: corrispondono a >, <, >=, <=, ==, !=; questi vengono usati appunto per relazionare variabili e loro valori all’interno di istruzioni di controllo (una tra le quali è “se, allora, altrimenti”, che vedremo più avanti).

Operazioni

Attenzione! Le operazioni di somma, sottrazione, prodotto e quoziente hanno una loro precedenza per il calcolatore: se non scritte in modo opportuno con l’utilizzo di parentesi tonde, vengono eseguite prima prodotto e quoziente, e successivamente somma e sottrazione.

Oltre al consueto modo di scrivere espressioni matematiche, esistono delle procedure inconsuete ma molto utilizzate in C per semplificare la scrittura. Prendiamo a puro esempio una variabile che contiene valori interi e supponiamo che sia già stato inserito un valore per questa variabile (che chiamiamo “n”), allora:

Attenzione! Scrivere n++ e ++n è concesso ma non è la stessa cosa; lo si capirà al meglio quando si avrà visto la stampa di valori all’interno del printf(). Nel primo caso (n++) prima la variabile viene letta e poi incrementata (quindi, se per caso n=3, stampa 3 e poi la modifica sostituendo a 3 il valore 4), mentre per ++n prima viene incrementata e poi letta (quindi se n=3 prima viene portato il valore a 4, e successivamente viene stampato il valore 4).

Nella risoluzione dei problemi risulta molto importante la conoscenza dell’operazione modulo, la quale permette di calcolare il resto della divisione tra il valore contenuto in una variabile e uno dato.

Operazione modulo: NomeVariabile%NumeroCheDivide

Esempio:

int resto; 
resto=n%3; 

Calcola il resto della divisione del valore contenuto in “n” con 3 e lo assegna alla variabile “resto”.

Variabili

Una variabile è come un contenitore nel quale è possibile inserire informazioni, che possono essere (uno o più) valori numerici oppure caratteri o stringhe di caratteri.

Attenzione! Nel C non esistono variabili booleane.

Per ogni variabile ne è definito anticipatamente il tipo, che indica il tipo di dato che può essere immesso; esistono, come già accennato, diversi tipi di variabili, e i più comuni sono:

• int Intero: 4 byte in memoria; da -2³¹ a 2³¹-1
• float Decimale a virgola mobile: 4 byte in memoria
• char Carattere: 1 byte in memoria; da 0 a 255 o da -128 a 127
• double Decimale a virgola mobile (doppia precisione): 8 byte in memoria

Se ad un numero (int, float o double) precediamo la scritta const, allora il valore non sarà modificabile all’interno del programma: se ciò dovesse anche per caso succedere il compilatore segnalerà un apposito messaggio di errore.

Esempio:

const float pi=3.14; 
pi=3.0; 

Il programma segnalerà un errore nel quale evidenzia il fatto che non si può modificare il valore della variabile.

Dichiarazione di una variabile: TipoVariabile NomeVariabile;

Esempi:

int a;

È possibile separare, nel caso in cui si dovessero dichiarare diverse variabili dello stesso tipo, usando una virgola:

int a, b, c;