-------------------------------------------------------------
-------------------------------------------------------------
-------------------------------------------------------------

PRIMO ESERCIZIO

struct Nodo {
	char* str;
	int len;
};

la struttura dati qui sopra definita
viene utilizzata per mantenere le informazioni
riguardanti l'indirizzo e la dimensione di una
area di memoria allocata dinamicamente mediante
la fnzione malloc.
In particolare, il campo str contiene 
l'indirizzo d'inizio dell'area di memoria allocata
ed il campo len mantiene la dimensione in bytes
dell'area di memoria puntata da str.

Si consideri il seguente programma main.c, 

/* file main.c */

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

struct Nodo {
	char* str;
	int len;
};


int copia(     DECIDETE VOI I PARAMETRI FORMALI     ) {
	
	IMPLEMENTATE VOI LA FUNZIONE copia

}


int main(void) {
	struct Nodo a;
	struct Nodo *b=NULL;
	int ris;

	/* alloco un'area di memoria e memorizzo
           indirizzo e dimensione in a */
	a.str=(struct Nodo*) malloc(10);
	if(a.str==NULL) return(1);
	a.len=10;
	a.str[2]='w';

	/* chiamola funzione copia per creare e memorizzare
           una copia dell'area di memoria puntata da a */
	
	ris= copia(    METTETE VOI I PARAMETRI GIUSTI     );
	if(ris==0) return(1);

	printf(" %c \n", (*b)->str[2] );

	return(0);
}



Nel programma compaiono due variabili locali del main
a di tipo struct Nodo
b di tipo puntatore a struct Nodo

Si scriva una funzione  copia
i cui parametri li decidete voi.

La funzione copia deve modificare la variabile b
in modo che al termine della esecuzione 
della funzione copia
si abbia la seguente situazione in memoria:
1) la variabile b punti ad una struttura struct Nodo 
allocata dinamicamente.
2) tale struttura puntata da b 
memorizzi indirizzo e dimensione 
di un'altra area di memoria  allocata dinamicamente.
che abbia le STESSE DIMENSIONI e lo STESSO CONTENUTO
dell'area di memoria puntata da a.str 
4) la funzione restituisce 1 se riesce a svolgere 
il proprio compito, restituisce 0 se l'allocazione 
dinamica fallisce.

5) dire che cosa stampa a video il programma.


SOLUZIONE DEL PRIMO ESERCIZIO:

la chiamata alla funzione copia deve essere scritta cosi':
	ris=copia( a , &b );

l'implementazione della funzione copia e' cosi':

int copia( struct Nodo a1, struct Nodo* *b1) {

	*b1=(struct Nodo*)malloc( sizeof( struct Nodo) );
	if( *b1==NULL ) return(0);
	if( a1.len==0 ) {
		(*b1)->len=0;
		(*b1)->str=NULL;
		return(1);
	}
	else {
		(*b1)->str= (char*) malloc( a1.len );
		if( (*b1)->str==NULL ) {
			free( *b1 );
			return(0);
		}
		else {
			int i=0

			(*b1)->len=a1.len;

			for( i=0; i<a1.len; i++ )
				(*b1)->str[i]=a1.str[i];

			return(1);
		}
	}
}


-------------------------------------------------------------
-------------------------------------------------------------
-------------------------------------------------------------


SECONDO ESERCIZIO

si consideri il seguente programma, costituito da due files, 
denominati rispettivamente a.c e main.c
Si vuole sapere se:
1) il compilatore gcc riesce a compilare a.c
   oppure produce un errore in compilazione.
2) il compilatore gcc riesce a compilare main.c
   oppure produce un errore in compilazione.
3) il compilatore gcc riesce a linkare assieme a.o e main.o
   oppure produce un errore.
4) eseguendo il programma, 
   cosa viene stampato a video?
----------------
/* file a.c */

int a=10;

int f(int a) {
	a++;
	return(a);
}

----------------

/* file a.c */

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

int main(void) {
	static int a=1000;
	
	a=f(a);

	a=f(a);

	printf(" %d \n", a   );

	return(0);
}
----------------


SOLUZIONE DEL SECONDO ESERCIZIO:

nessun errore in compilazione di a.c e main.c
nessun errore in linking,
viene stampato 1002

-------------------------------------------------------------
-------------------------------------------------------------
-------------------------------------------------------------