Anteprima
Vedrai una selezione di 5 pagine su 16
Informatica - Polimi - Prof. Campi Pag. 1 Informatica - Polimi - Prof. Campi Pag. 2
Anteprima di 5 pagg. su 16.
Scarica il documento per vederlo tutto.
Informatica - Polimi - Prof. Campi Pag. 6
Anteprima di 5 pagg. su 16.
Scarica il documento per vederlo tutto.
Informatica - Polimi - Prof. Campi Pag. 11
Anteprima di 5 pagg. su 16.
Scarica il documento per vederlo tutto.
Informatica - Polimi - Prof. Campi Pag. 16
1 su 16
D/illustrazione/soddisfatti o rimborsati
Disdici quando
vuoi
Acquista con carta
o PayPal
Scarica i documenti
tutte le volte che vuoi
Estratto del documento

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;

Dettagli
Publisher
A.A. 2017-2018
16 pagine
SSD Scienze matematiche e informatiche INF/01 Informatica

I contenuti di questa pagina costituiscono rielaborazioni personali del Publisher saratita di informazioni apprese con la frequenza delle lezioni di Informatica e studio autonomo di eventuali libri di riferimento in preparazione dell'esame finale o della tesi. Non devono intendersi come materiale ufficiale dell'università Politecnico di Milano o del prof Campi Alessandro.