vuoi
o PayPal
tutte le volte che vuoi
N
default: istr U; break;
}
break; Consente di uscire dal corpo di un ciclo o da uno switch
Interrompe l’iterazione corrente di un ciclo e dà inizio all’iterazione successiva dopo aver
continue; eseguito l’incremento
Gruppo di celle consecutive con elementi dello stesso tipo. Il primo elemento ha indice 0
Per eccedere ad un elemento nomearray [posizione]
e riempirlo nomearray [posizione] = valore
Per creare un array tipo nomearray [numeroelementi];
tipo nomearray [numeroelementi]
e riempirlo = {elem1, .., elemN};
for (i = 0; i < numeroelementi; i++) {
o riempirlo da terminale printf ("Scrivi un intero: ");
scanf ("%d", &nomearray[i]);}
int array1[dimensione], array2[dimensione], i;
Ricopiare array1 in array2 for (i = 0; i<dimensione; i++) {
array array2[i] = array1[i]; }
Int dato, risultato = - 1, n;
int array[size];
for (n = 0; n < size; n++) {
Ricerca di un elemento if (array[n]==dato) {
risultato = n;
break;
}}
for (j = 0; j < size - 1; j++) {
for (i = 0; i < size – 1; i++) {
if (vet[i] > vet[i+1]) {
Ordinare un array con bubblesort aux = vet[i];
vet [i] = vet [i+1]
vet [i+1] = aux
}}}
Array di caratteri che termina con \0.
Le funzioni sono contenute nella libreria string.h
char nomestringa[] = “parola”;
char nomestringa = {‘p’, ‘a’, ‘r’, ‘o’, ‘l’,
Inizializzazione ‘a’, ‘\0’} ;
strcpy (nomestringa, “parola”);
Copia stringa1 in stringa2 strcpy (stringa2, stringa1);
Copia n caratteri di stringa1 in stringa2 strncpy (dtringa2, stringa1, n)
Stringa Lunghezza x = strlen (nomestringa);
Riempire stringa da terminale scanf (“%s”, nomestringa);
Confrontare due stringhe
Se restituisce 0 sono uguali
Se restituisce un numero < 0 stringa1 è più strcmp (stringa1, stringa2)
corta
Se restituisce un numero > 0 stringa1 è più
lunga
Consente di concatenare stringa2 a stringa1 strcat (stringa1, stringa2)
Array a più dimensioni.
Le righe orizzontali sono chiamate righe, mentre quelle verticali sono le colonne
for(i = 0; i < DIM; i++) {
for(j = 0; j <DIM; j++) {
Riempire una matrice da terminale printf("Dammi elemento (%d,%d)\n",i,j);
Matrici scanf("%d", &M[i][j]); }}
for(i = 0; i < DIM; i++) {
for(j = 0; j < DIM; j++) {
e visualizzarla printf("%4d", M[i][j]); }
printf("\n"); }
Memorizza aggregazioni di dati di diversa natura.
Ogni dato è chiamato campo
char strcpy (nome.campo,“stringa”);
Assegnamento ai campi int nome.campo)=numero
char scanf (“%s”, nome.campo);
Da terminale int scanf (“%d”, &nome.campo);
Struct Assegnare una struct ad un’altra identica struct1 = struct2
if (strcmp(nome.campochar,
Confrontare due struct nome.campochar2) ==0 && nome.campoint
==nome.campoint2))
typedef struct {
tipo campo1
Creare un tipo di dato tipo campo2
…
} nomestruct;
Variabili che hanno come valore l’indirizzo di un’altra variabile
%p printf (“indirizzo di x: %p”, &x);
Typedef tipo * tiporef;
tiporef p = &x;
Dichiarazione Int * p;
p = &x
Si impone che il puntatore p punti alla
p = q stessa variabile a cui punta q
Si assegna il valore della variabile puntata
*p = *q da q al valore della variabile puntata da p
if ( p==NULL )
Test di nullità if ( !p )
Puntatori if ( p != NULL )
Test di non nullità if (p)
p→primocampo
Nelle struct o
(*p).primocampo
Un array v è una costante di tipo puntatore
che punta all’indirizzo della prima cella
v = &v[0]
v [i] è equivalente a *(v + i)
Negli array Se p e q puntano a due diversi elementi di
uno stesso array, la differenza p – q dà la
distanza nell’array tra gli elementi puntati
Una funzione è una sequenza di comandi che ha un nome, può essere invocata, può
ricevere dei parametri che ne influenzano l’esecuzione e produce un valore risultato.
Il valore non può essere un array, ma può essere una funct che contiene un array o un
puntatore a un array.
Se non restituisce nessun valore è di tipo void.
Premettendo static ad una dichiarazione di variabile in una funzione si rende la variabile
di tipo statico Tiporestituito nomefunct (tipo
Dichiarazione di funzione lista_argomenti);
lista argomenti facoltativa, ci dev’essere il tipo
Tiporestituito nomefunct (tipo
Funzioni lista_argomenti) {
Definizione di funzione variabili locali;
corpo della funzione;
Invocazione nel main Nomefunzione (lista_argomenti)
Le variabili passate come parametri ad una funzione non cambiano valore nell’ambiente
del chiamante.
Se si vuole che una funzione agisca sulle variabili dell’ambiente chiamante, occorre
passare l’indirizzo di tali variabili attraverso i puntatori: nella chiamata & e
nella definizione *.
Per passare un array nella chiamata si mette il nome e nella definizione *nome
Composta da uno o più casi base, che rappresentano sottoproblemi facilmente risolvibili,
e un passo induttivo che per ogni applicazione ci avvicina al caso base, fino a raggiungerlo
void ordina(int a[],int N) {
mergesort(a,0,N-1);}
void mergesort(int a[],int low,int high) {
int mid;
if(low<high) {
mid=(low+high)/2;
mergesort(a,low,mid);
mergesort(a,mid+1,high);
merge(a,low,high,mid);}}
void merge(int a[], int low, int high, int
mid) {
Ricorsione int i=low, j=mid+1, k=low, c[50];
while((i<=mid)&&(j<=high)) {
Mergesort if(a[i]<a[j]) {
c[k]=a[i];
k++; i++;}
else {
c[k]=a[j];
k++; j++;}}
while(i<=mid) {
c[k]=a[i];
k++; i++;}
while(j<=high) {
c[k]=a[j];
k++; j++;}
for(i=low;i<k;i++)
a[i]=c[i];}
Sono strutture dati persistenti: tramite essi i
dati possono sopravvivere al termine dell’esecuzione del programma.
Sono strutture dati sequenziali
Un file binario è una sequenza di byte che Un file di testo è una sequenza di
non è interpretata in alcun modo caratteri interpretata
FILE * fopen
(char * nomefile,
char * modalità)
File nome= fopen (
“nomefile”,
“modalità” );
Un file per essere usato deve essere prima apertura “r” Lettura
aperto e dopo l’uso va chiuso Scrittura
“w” a inizio
file
Scrittura
“a” a fine
file
Per un file binario
si usa “rb”, “wb”
e “ab”
chiusura fclose (nome)
Il descrittore memorizza: la modalità
L’apertura di un file restituisce un puntatore a d’uso (read, write); la posizione
un descrittore: FILE * nome corrente all’interno del file; l’indicatore
(dichiarazione) di eventuale errore; l’indicatore di eof
(end of file)
Cancellare file int remove (char * nomefile)
Restituisce 0 se va a buon fine, !=0 altrimenti
Cambiare nome al file int rename (char * oldname, char
Restituisce 0 se va a buon fine, !=0 altrimenti *newname)
Fp diventa NULL int close (FILE * fp)
Restituisce 0 se va a buon fine, EOF altrimenti
Errori
int ferror (FILE * fp) Restituisce =!0 se c’è errore
int feof (FILE * fp) Restituisce falso se non si è alla fine
Riporta al valore normale gli indicatori
void clearerr (FILE * fp) di errore ed eof
int fprintf ( FILE * fp, str_di_controllo,
fprintf e fscanf si usano come printf e scanf. elementi )
Restituiscono il numero di elementi int fscanf ( FILE * fp, str_di_controllo,
effettivamente letti/scritti, o zero se errore indirizzo_elementi )
Legge un carattere dal file descritto da
int fgetc (FILE * fp) * fp
Scrive un carattere sul file descritto da
int fputc (int c, FILE * fp) * fp
long int ftell (FILE * fp) Restituisce posizione corrente
void rewind (FILE * fp) La posizione corrente torna all’inizio
Le variabili dinamiche sono allocate e deallocate esplicitamente dal programmatore nello
Heap e sono accessibili tramite puntatori
Apposite funzioni definite nella standard library <stdlib.h> si occupano della gestione della
memoria dinamica
Memoria dinamica Allocazione.
Riceve come parametro il numero di byte da
Allocare. malloc (sizeof(tipodato))
Restituisce un puntatore di tipo void * che può
essere assegnato aa qualsiasi altro puntatore
per usare la nuova variabile
Deallocazione free (nomepuntatore)
char *ptr;
ptr = (char *) malloc( sizeof(char) );
*ptr = 'a';
printf("Carattere: %c\n", *ptr);
free( ptr ); Puntatore nullo, non punta ad alcuna
NULL area significativa di memoria
int main() { int n, *v, lung_max, i=0;
lung_max=DIM_INIZIALE;
v = (int *)
malloc(lung_max*sizeof(int));
scanf("%d", &n);
while( n != SENTINELLA ) {
v[i] = n;
i++;
if( i == lung_max ) {
v = replace( v,
lung_max, INCREMENTO );
lung_max +=
INCREMENTO; } scanf("%d“, &n); }
Esempio di array riempito con allocazione printReverse(v, i-1);
dinamica free(v);
e poi stampato all’incontrario return 0; }
int * replace( int * v, int l_max, int inc ) {
int * vet, i;
vet = (int *) malloc(
sizeof(int)*(l_max+inc) );
for( i=0; i<l_max; i++ )
vet[i] = v[i];
free( v );
return vet;}
void printReverse( int v[], int len ) {
while( i>0 )
printf("%d", v[i--]); }
Composta da elementi allocati dinamicamente. Ogni elemento contiene un puntatore al
prossimo elemento della lista. L’ultimo elemento della lista contiene un puntatore che
punta a NULL. Ogni elemento prende il nome di nodo.
Si usano al posto degli array quando il numero di elementi non è noto a priori e/o la lista
deve essere mantenuta ordinata typedef struct EL {
Lista TipoElemento info;
Definizione del nodo struct EL * prox;
} ElemLista;
E del tipo di puntatore Typedef ElemLista * ListaDiElem;
typedef struct Nd {
int dato;
struct Nd * next;
} Nodo;
typedef Nodo * ptrNodo;
Creazione di un nodo ptrNodo ptr;
ptr = malloc(sizeof(Nodo));
ptr->dato = 10;
ptr->next = NULL;
ptrNodo Lista;
ptrNodo ptr;
Lista = malloc(sizeof(Nodo));
Lista->dato = 10;
ptr = malloc(sizeof(Nodo));
ptr->dato = 20;
Lista->next = ptr
Creazione lista di due nodi ptr->next = NULL;
ptrNodo Lista;
Lista = malloc(sizeof(Nodo));
Lista->dato = 10;
Lista->next = malloc(sizeof(Nodo);
Lista->next->dato = 20;
Lista->next->next = NULL;
ptrNodo ptr;
- Risolvere un problema di matematica
- Riassumere un testo
- Tradurre una frase
- E molto altro ancora...
Per termini, condizioni e privacy, visita la relativa pagina.