Scarica Corso Completo Programmazione in C e più Appunti in PDF di Programmazione C solo su Docsity!
INTRODUZIONE ALLA PROGRAMMAZIONE :
CONCETTI GENERALI
Commenti: Utilizzare i simboli /* */ oppure se di una sola riga // Nomi: Un nome DEVE INIZIARE NECESSARIAMENTE CON UNA LETTERA e poi proseguire con numeri, lettere e simbolo di sottolineatura. NON può superare i 32 caratteri. Struttura a blocchi:
- Utilizzare l’indentazione
- Scrivere un’istruzione per riga.
- Per essere valida ogni istruzione deve essere seguita dal; Inizio del programma: main(){ … /* Programma*/… } VARIABILI: Può cambiare il suo valore durante l’esecuzione del programma mediante assegnazioni successive. Creazione delle variabili:
- Dichiarazione: Per poter essere utilizzate le variabili devono essere dichiarate: Tipo Variabile_1, Variabile_2; /Variabile_1 e Variabile_ sono dello stesso tipo / Tipo Variabile_3; /Variabile_3 e Variabile_4 sono di tipi diversi/ Tipo Variabile_4;
- Inizializzazione, Assegnazione e Definizione: Assegnazione : Assegna un valore inziale alla variabile subito dopo la dichiarazione. Essendo una variabile il suo valore può essere modificato nel corso del programma. Nome_Variabile = quantità; Definizione: Stabilire il tipo, il nome e il valore inziale da assegnare alla variabile. Tipo Nome_Variabile=quantità; COSTANTE: Il suo valore rimane lo stesso fino alla fine del programma. Un tentativo di modifica porta un errore in compilazione. Creazione di costanti: DUE MODI:
- Tramite il const → const tipo Nome_Variabile=Valore(non modificabile); E’ un’assegnazione e va messa insieme alla dichiarazione delle variabili.
- Tramite #define : #define nome valore Non è un’assegnazione va messa fuori dal main con le librerie. ESEMPIO: int variabile_A; /Dichiarazione/ variabile_A=20; /Assegnazione/ int variabile_A=20; /Definizione/ TIPO:
- char : caratteri. In fase di assegnazione includere il carattere tra ‘’; es: char A; A=’G’;
- int : interi
- float : virgola mobile.Si utilizza il. come separatore tra parte intera e decimale.
- double : virgola mobile (più preciso rispetto al float) Direttive del preprocessore Non hanno bisogno del ; Vanno messe fuori dal main. #include (LIBRERIE→#include<stdio.h> #include<math.h> #include<stdlib.h> ) #define (per le costanti )
ATTENZIONE ALLA SCRITTURA DEI NUMERI IN VIRGOLA MOBILE.
Viene utilizzato il punto non la virgola e in presenza di esponenziale il numero deve essere in forma razionale. Es: 3.e2 (equivale a 3e^2 ) oppure 4.2e-0.5 (equivale a 4.2e(-1/2)) Operatori
- Aritmetici binari: Permettono di eseguire le operazioni elementari tra due operandi + /* Somma*/ - /* Differenza*/ ***** /Prodotto/ / /Differenza/
- Aritmetici binari+Assegnazione: Permettono di eseguire le operazioni elementari e di assegnare il risultato alla prima variabile += - = = /= Operatore MODULO % Restituisce il resto della divisione tra interi. Nel caso in cui non siano interi i membri della divisione restituisce la parte intera del risultato. Operatori speciali Post incremento Nome_variabile++; _/Prima assegna e poi incrementa/ Nome_variabile--; /Prima assegna e poi decrementa/_ Pre incremento _++Nome_variabile; /Prima incrementa poi assegna/ --Nome_Variabile; /Prima decrementa poi assegna*/_ Operatore di negazione e assegnazione
- /* assegna alla variabile il valore opposto/ = /Assegna il risultato di un’operazione o di un’espressione/ ATTENZIONE ALLE PRECEDENZE: Le parentesi hanno precedenza su tutto e se gli operatori presenti hanno la stessa precedenza si valutano da sinistra verso destra. int a=4; int b=2; int c; c=a+b; _/c=6/_ c=a-b; _/c=2/_ c=ab; /c=8/ c=a/b; /c=2/ a+=b; /a=a+b=6/ a-=b; /a=a-b=2/ a=b; _/a=ab=8/_ a/=b; /a=a/b=2/ c=a%b; /a=0/ int d=3; c=a%d; /* c=1/ c=a++; _/c=a; a=a+1 c=5/_ c=--b; _/b=b-1 c=b c=1/_ ATTENZIONE ALLA DIVISONE! / →indica la divisione tra interi nel caso in cui la divisione non sia precisa restituisce la parte intera del risultato
IMPUT E OUTPUT
UTILIZZO DELLA FUNZIONE PRINTF
La funzione printf permette di stampare su schermo. Serve per rendere più chiaro le informazioni da inserire una volta che viene compilato il programma e per stampare i risultati. Descrittore : Serve a descrivere il formato della variabile ed informa il compilatore sul tipo di variabile che verrà inserita in modo da stamparla correttamente. Esso nel printf viene sempre seguito dal nome della variabile a cui fa riferimento. “Il descrittore stampa il valore della variabile associato alla locazione di memoria che segue la virgola.Se presenti più descrittori ognuno di essi deve essere seguito dalla virgola.”
- printf(“stringa di caratteri”); /Viene stampata la stringa di caratteri sullo schermo/
- Es :printf(“%descrittore F = %descrittore C”,tf,tc); /*In un programma che converte da C a F una volta assegnato il valore a tc viene calcolato tf stampato mediante quest’espressione il risultato nella forma Gradi F = Gradi C */ UTILIZZO DI SCANF La funzione scanf serve per leggere il valore di una o più variabili da imput. NON POSSONO COMPARIRE MESSAGGI MA SOLTANTO DESCRITTORI SEGUITI DALL’INDIRIZZO DELLA LOCAZIONE DI MEMORIA A CUI FANNO RIFERIMENTO.
scanf(“%f,%d”,&variabile_1,&variabile_2);
/Stampa due valori inseriti da tastiera e li assegna esattamente il primo alla variabile_1 che sarà di tipo float e il secondo sarà assegnato alla variabile_ che sarà di tipo intero/ %f /float/ %d /int/ %c /char/ %s /string/
CONTROLLO DEL FLUSSO
Cicli iterativi
- Sequenza: Un programma viene eseguito in sequenza cioè eseguendo un’istruzione dopo l’altra nell’ordine in cui sono state scritte a patto che non ci siano delle selezioni o delle ripetizioni che modificano il flusso di esecuzione.
- Selezione : Sceglie un’azione da eseguire da una lista di una o più azioni in seguito ad un controllo.
- Ripetizione : Ripete un blocco di istruzioni finchè non si verifica una condizione di uscita. SELEZIONE: Permette di scegliere le azioni da eseguire in seguito alla verifica di una condizione. STRUTTURA DI UN CICLO:
- Inizializzazione: Assegnazione di un valore iniziale a tutte le variabili che vengono lette durante il ciclo(sia nel corpo che nella condizione)
- Condizione di ripetizione: Espressa mediante gli operatori logici e relazionali (,!==,!=,<,>=,>,<=). La veridicità di tale condizione indirizza il flusso di esecuzione da un lato piuttosto che dall’altro. Condizione di solito inizialmente vera che al termine del ciclo diventerà falsa. Dipende dalle variabili che vengono modificate all’interno del ciclo.
- Corpo del ciclo: Sono le istruzioni da ripetere. Al suo interno si possono modificare le variabili inzializzate.
- Aggiornamento: Modifica delle variabili che sono in grado di modificare la veridicità della condizione di ripetizione. COSTRUTTO IF-ELSE SELEZIONE SEMPLICE SENZA ALTERNATIVA: Esegue un’azione se e solo se la condizione è verificata. if (condition) { statements; /Eseguita solo se condition è vera/ } Prossima istruzione; /* Sempre eseguita, eseguita subito se condition è falsa/ SELEZIONE SEMPLICE CON ALTERNATIVA: Esegue un blocco di istruzioni piuttosto che un altro a seconda della veridicità della condizione. if(condition) { statements_1; } else { statements_2; } Prossima istruzione; /Sempre eseguita/ Esempi di verifica !espressione /E’ vera se l’espressione è falsa/ Espressione1 && Espressione /E’ vera solo se sono vere Espressione1 ed Espressione2/ Espressione1 || Espressione / E’ vera se almeno una tra Espressione1 ed Espressione2 è vera*/
CICLO FOR: Si utilizza quando è noto a priori il numero delle volte che il ciclo viene iterato. for(inizializzazione;condizione;incremento) { Istruzione1; istruzione2; . . . Istruzione_n; }
- Inizializzazione: E’ un’istruzione che imposta il valore iniziale della variabile di controllo del ciclo. Essa funziona da variabile contatore.
- Espressione: E’ una condizione che determina il proseguimento del ciclo o la sua conclusione (se falsa).
- Incremento: E’ l’incremento della variabile di controllo del ciclo. Essa modifica il suo valore ogni volta che il ciclo viene iterato. CICLO WHILE: E’ una struttura che effettua il controllo prima dell’esecuzione del corpo del ciclo che viene perciò eseguito finché tale condizione rimane vera. E’ equivalente ad un ciclo for senza inizializzazione o meglio con inizializzazione fuori dal costrutto while. While(condizione) { Istruzioni; /* Soltanto finché condizione è vera si esegue il blocco istruzioni */ } Il ciclo while può essere utilizzato
- per controllare i dati inseriti dall’utente tramite tastiera
Es: scanf(“%f”, &dato)
while(dato!=datospeciale) /*Finchè non viene inserito il datospeciale stampa il
messaggio di errore*/
printf(“Errore! Inserisci il dato corretto”);
scanf(“%f”,&dato)
- Conteggiare le iterazioni Es: conta=0;/FLAG/ while(condizione) { Istruzioni; conta++; }
- Contare quante volte si verifica una condizione_particolare Es: conta=0; while(condizione) { Istruzioni; if(condizione_particolare) { conta++;
/FLAG/
Serve per effettuare una ricerca. Il flag viene di solito inizializzato a 0 (se la condizione è falsa) a 1 (se la condizione è vera).Può essere utilizzato anche per uscire dal ciclo una volta che si verifica una condizione. Es. trovato=0; for(i=0;i<N;i++) { Blocco di istruzioni; if (condizione_particolare) { Trovato=1; } } If (trovato==1) printf(“TROVATO”); else printf(“NON TROVATO”);
CICLO DO-WHILE: Il ciclo Do-While viene sempre eseguito almeno una volta perché il controllo della condizione avviene alla fine. Si utilizza di solito per verificare dati inseriti da tastiera. La condizione di uscita è la stessa che si trova nell’if. Es: /Conversione da C-F o F-C/ do { printf("Inserisci 1 se vuoi convertire da Fahrenheit a Celsius\n Inserisci 2 se vuoi convertire da Celsius a Fahrenheit\n"); scanf("%d",&option); if ((option!=1)&&(option!=2)) { printf("Digizazione errata.\n Riprova\n "); } } while((option!=1)&&(option!=2));
INIZIALIZZAZIONE DI UN ARRAY UNIDIMENSIONALE
Un array può essere inizializzato essenzialmente il tre modi.
1. In fase di dichiarazione Tipo nome_array[]={“elementi dell’array”} ;/Elementi separati dalla virgola/ ES:int pari[]={ 2 , 4 , 6 , 8 , 10 } 2. Tramite indicizzazione diretta quando occorre int pari[5]; … pari[0]=2; pari[1]=4; pari[2]=6; pari[3]=8; pari[4]=10; 3. Riempimento tramite ciclo for. Lo stesso metodo va utilizzato se si intende assegnare gli elementi di un array ad un altro. for(i=0;i<=N;i++) { pari[i]=2*i; } for(i=0;i<=N;i++) { a[i]=b[i]; }
ARRAY DI CARATTERI
Si definisce stringa un array di tipo char. La lunghezza di una stringa, come succedeva per gli array, può essere definita in modo esplicito durante la definizione o in maniera implicita nel momento in cui inizializzazione e definizione avvengono contemporaneamente. In questo secondo caso la lunghezza della stringa viene “dedotta” dal compilatore ed è uguale al numero di caratteri compresi tra doppi apici inclusi gli spazi bianchi. /ATTENZIONE/ Una stringa termina sempre con un carattere speciale(/0) che non appare esplicitamente ma che serve a terminare la stringa e che viene aggiunto dal compilatore. INIZIALIZZAZIONE DI UNA STRINGA RICORDA!
- Per assegnare una lettera ad una variabile di tipo char si utilizza la seguente nomenclatura char a; a= ‘A’; La sintassi che viene utilizzata per le stringhe assume la seguente forma, molto più veloce e snella rispetto a quella utilizzata per gli array. char nome_stringa[]= “stringa” char line[]= “L’amor che muove il sole e le altre stelle”; /Consente di assegnare molti valori ad una stringa in una sola volta/ Oppure si può assegnare singolarmente ogni lettera ad ogni elemento dell’array scrivendo nel seguente modo Line[0]=L; line[1]=’; line[2]=a; line[3]=m; line[4]=o; line[5]=r; line[6]=e;
ARRAY MULTIDIMENSIONALI
Un array di dimensione M è un insieme di variabili tutte dello stesso tipo a cui si fa riferimento usando lo stesso nome e alle quali si accede mediante M indici. Consideriamo il caso bidimensionale. INIZIALIZZAZIONE: L’inizializzazione di un array bidimensionale (più in generale a più dimensioni) avviene allo stesso modo in cui avviene l’inizializzazione di un array unidimensionale. Anche in questo caso è di fondamentale importanza inserire il numero delle righe ed il numero delle colonne oppure stabilire in fase di dichiarazione quali sono gli elementi della matrice. In ogni caso il compilatore deve sapere quanto spazio dedicare alla matrice.
- In fase di dichiarazione: tipo nome_array [numerorighe][numerocolonne]
- Tramite due cicli for che fissano una riga e riempiono una colonna alla volta. Il ciclo più esterno tiene fissa la riga mentre scorre l’indice più interno che incrementa la colonna Supponiamo di avere una matrice di M righe e N colonne. Il riempimento avviene nel seguente modo: for(i=0;i<M;i++) { for(j=0;j<N;j++) { … } } Attenzione alla terminologia! int quadrati [4][2]; /Dichiarazione: sto dichiaranto un array bidimensionale chiamato quadrati di 4 righe e due colonne/ quadrato[4][2]; /Accede all’elemento di posto [4,2] all’interno dell’array quadrati/ OPERAZIONI ELEMENTARI CON LE MATRICI
- Stampa per righe
- Stampa per colonne
- Lettura matrice
- Copia matrice 1 in matrice 2 Inizializzazioni corrette equivalenti
- main(){ Int quadrati[4][2]={1,1,2,4,3,9,4,16}; } Equivalente a
- main(){ int quadrati[4][2]={{1,1},{2,4},{3,9},{4,16}}; }
- printf(“Matrice %d righe e %d colonne”,M,N);
for(i=0;i<M;i++)
for(j=0;j<N;j++)
printf(“%f”, mat[i][j]);
printf(“/n”);
- printf(“Matrice %d righe e %d colonne”,M,N);
for(j=0;j<N;j++)
for(i=0;i<M;i++)
printf(“%f”, mat[i][j]);
printf(“/n”);
- printf(“Immetti matrice:”);
for(i=0;i<M;i++)
printf(“Riga %d=” i+1);
for(j=0;j<N;j++)
printf(“Elemento (%d ,%d)=” i+1,j+1);
scanf(“%f”,&mat[i][j]);
for(j=0;j<N;j++)
Mat2[i][j]=Mat1[i][j];
OPERATORE DI INDIREZIONE(*)
L’operatore di indirezione restituisce il valore contenuto nella locazione di memoria puntata dal puntatore. Essa consente di accedere e modificare il valore della variabile puntata. In questo secondo caso il puntatore pd si trova a sinistra dell’operatore di assegnazione. ANCORA SULL’INIZIALIZZAZIONE Un puntatore per poter essere utilizzato deve essere innanzitutto dichiarato e poi inizializzato. INIZIALIZZARE UN PUNTATORE SIGNIFICA FARLO PUNTARE A QUALCOSA. Nel caso in cui mancasse l’inizializzazione e si facesse un accesso al contenuto della variabile puntata dal puntatore facendo magari anche modifiche di fatto si potrebbe verificare un cash del sistema nel senso che poiché il puntatore non punta a nulla la locazione di memoria che si va a modificare potrebbe trovarsi anche dove è memorizzato il sistema operativo. Es: int p; /Dichiarazione di un puntatore p ad intero/ int a; p=&a; p=2;/L’istruzione sappiamo che significa”poni il contenuto della locazione di memoria puntata da p =2/ Tuttavia p non è stato inzializzato perciò DI FATTO NON PUNTA A NULLA. /ISTRUZIONE ILLEGALE/ Aggiungendo le due righe di codice sottolineate… si ha che p punta ad a perciò in p è memorizzato l’indirizzo di a e di conseguenza l’istruzione p=2 significa di fatto poni a= SERIE DI ESEMPI La scrittura b=*pd serve per assegnare a b il valore contenuto in a ossia 3.14. L’assegnazione alla terza riga poteva essere fatta tramite puntatore. *pd=3. La schermata di esecuzione rimane la stessa. Gli operatori di indirezione indirizzamento sono complementari tra loro. Definiamo un puntatore p ad una variabile **var. double p, var; p=&var; Allora p e &var riguardano l’indirizzo di var cioè il contenuto di p. p e var riguardano il contenuto della variabile
PRINTF e SCANF con i puntatori
In generale abbiamo visto che la funzione scanf legge da tastiera caratteri o numeri e li scrive nelle locazioni di memoria associate a tali variabili. Per poter fare ciò ha bisogno degli indirizzi e quindi dei puntatori a tali variabili. La funzione printf stampa i valori assunti dalle variabili che compaiono nella lista degli argomenti per questo non ha bisogno di accedere alle locazioni di memoria. PRINTF Per poter stampare l’indirizzo di una variabile puntata, ossia il contenuto del puntatore che punta a quella variabile si utilizza il descrittore %p. Le ultime due istruzioni stampano rispettivamente il puntatore e il valore della variabile cioè nel primo caso visualizzeremo sullo schermo l’indirizzo della locazione di memoria a. Nel secondo caso avremo a=30 perché dalla terza riga di codice abbiamo che il contenuto della variabile puntata a p deve essere pari a 30
ESEMPI CON I PUNTATORI CORRETTI E SBAGLIATI
INCOERENZA TRA PUNTATORE E VARIABILE PUNTATA Errore in compilazione: la variabile a è di tipo intero mentre la variabile pd è un double nonché un puntatore. VERSIONE CORRETTA CONVERSIONE NON CORRETTA Errore in compilazione: Impossibile convertire double in *double. RICORDA che &b riguarda l’indirizzo di b mentre *pd riguarda il contenuto della variabile puntata. UNA VERSIONE CORRETTA Stampa… c=3.14; Esercizio : definire una variabile alpha di tipo intero; dichiarare un puntatore p_alpha che punta alla variabile alpha; assegnare il valore 100 alla variabile alpha mediante puntatore; stampare il valore del puntatore e della variabile a cui punta.
PUNTATORI ED ARRAY
Il nome di un array nel linguaggio C costituisce un puntatore alla locazione di memoria che contiene il primo elemento dell’array. Il puntatore alla locazione di memoria che contiene il primo elemento si può definire allo stesso modo in cui si definisce un puntatore ad una variabile. Nelle seguenti righe di codice viene dichiarato un array di nome data[] contenente 10 elementi e un puntatore pd. Il puntatore pd punta al primo elemento dell’array data[10] e contiene esattamente l’indirizzo della locazione di memoria dove è contenuto il primo elemento dell’array. Allo stesso modo l’espressione *pd equivale a data[0] inteso come contenuto della locazione data[0]. I due programmi sono esattamente identici.
Quindi pd=&data[10]
Equivale a
pd=data;
Poiché pd è un puntatore al primo elemento dell’array e poiché in memoria gli elementi di un array sono memorizzati in spazi contigui la scrittura pd+1 esprime l’indirizzo dell’elemento data[1] pd+2 esprime l’indirizzo dell’elemento data[2] . . . pd+9 esprime l’indirizzo dell’elemento data[9] Allo stesso modo per accedere gli elementi data[1],data[2]…data[9] si utilizza l’operatore di indirezione: *(pd+1) accede al contenuto della locazione data[1] (pd+2) accede al contenuto della locazione data[2] . . . (pd+9) accede al contenuto della locazione data[9] le tre scritture presenti all’interno dell’istruzione printf consentono di esprimere gli indirizzi delle locazioni di memoria degli elementi dell’array. Perciò per esprimere un indirizzo si possono sfruttare le seguenti scritture: supponiamo di dichiarare un array chiamato Array e un puntatore P_ARRAY. Per accedere agli indirizzi: _P_array &ArraY[Elemento al quale si vuole accedere] Array+i /i=Indice di incremento/_ Ricorda! Un array è un vettore di elementi tutti dello stesso tipo a cui si fa riferimento con lo stesso nome. Durante la fase di dichiarazione deve essere nota al compilatore la quantità di memoria da riservare per memorizzare tale array.
Per accedere al contenuto le scritture che possono essere usate sono le seguenti: Array[i] *(P_array+i) *(Array+i)
OPERAZIONI CON I PUNTATORI
Array e puntatori sono interscambiabili?
Abbiamo detto che il nome di un array può essere utilizzato come puntatore nel senso che il nome dell’array è un puntatore al primo elemento dell’array stesso. Si potrebbe pensare perciò che Array e Puntatori siano la stessa cosa o meglio che siano interscambiabili.
QUESTO NON E’VERO
Puntatori ed array sono interscambiabili se il risultato di un’operazione non modifica il puntatore. Es. Incrementare un array intendendolo come puntatore è un’istruzione sbagliata. Se si vuole riempire un array con i valore i=1,2,3… Fare ben attenzione alla differenza tra ARRAY e PUNTATORI. Quando vengono utilizzati insieme per riempire un array conviene sempre dichiarare un puntatore con un nome diverso rispetto a quello dell’array. In questo modo il puntatore in quanto variabile può essere soggetto alle operazioni di incremento, decremento. Mentre un array non essendo una variabile non può essere incrementato o decrementato. Si ha un errore in compilazione.
