[C]Problemi di visibilità(credo)

[braian]

Sto sviluppando un progetto che devo consegnare per martedì, quindi sono un po' alle strette.
Il progetto consiste nel creare un allocatore che utilizza il meccanismo degli handle.
Ho implementato le varie funzioni della api che mi era stata richiesta ed ora sto facendo il programma di test, in realtà un po' intricato.

In pratica chiedo dei dati all' utente da inserire nelle strutture. C'è un problema che credo di visibilità quando eseguo la scelta num.1 del menu principale: ovvero chiedo il nome da dare allo heap, e con una strcpy lo copio nella variabile interna alla struttura heapTest. Quando però finisco le operazioni della scelta 1 di test.c(secondo blocco di codice postato), il nome nella variabile della struttura heapTest dell' array heaps non è più quello che le avevo assegnato...prima di ristampare il menu si, dopo no.

Sembra quasi che la prima printf che vado a rieseguire quando ricomincio il while scriva sopra alla variabile.

Per favore aiutatemi...
ecco il codice dello header di test:

file: test.c
header per le funzioni del programma di test dell' allocatore

*/
#ifndef TEST_H_
#define TEST_H_

#include "tipiAllocatore.h"

#define MAXSTR 20

typedef struct struttura
{
	int datoIntero;
	double datoDouble;
}struttura;

typedef union dato
{
	int** intero;
	double** doppio;
	char** stringa;
	struttura** strut;
}dato;

typedef struct tipoDato
{
	char nome[MAXSTR];
	int selezione;
	dato dt;
}tipoDato;

typedef struct heapTest
{
	heap* h;
	char nomeHeap[MAXSTR];
	tipoDato* dati[100];
	int datiLiberi;
}heapTest;


static void creaHeap();

static void cancellaHeap();

static void allocaSpazio();

static void liberaSpazio();

static void visualizzaSpazioLibero();

static void compatta();

static void assegnaValore();

static void visualizzaValore();

static boolean nomeHeapDisponibile(char* nome);

static void stampaErrore(int numeroErrore);

#endif /* TEST_H_ */

ecco il file c del testo:

/*
file: test.c
programma di test dell' allocatore

*/

#include "allocatore.h"
#include "test.h"
#include "tipiAllocatore.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>

heapTest* heaps[10];
int heapLiberi;
int i;

int main()
{
	for (i=0;i<10;i++)
	{
		heaps[i]=NULL;
	}
	heapLiberi=10;
	int menu=0;
	// stampa del menu
	while(menu!=9)
	{
		printf("\n\n\n\n\nProgramma di test dell' allocatore di memoria;\n\n");
		printf("Digita il numero relativo alla operazione da effettuare e premi invio;\n\n");
		printf("(1) Crea un nuovo heap\n");
		printf("(2) Cancella uno heap esistente\n");
		printf("(3) Crea variabile e alloca spazio per un dato\n");
		printf("(4) Libera lo spazio relativo ad un dato e cancella la rispettiva variabile\n");
		printf("(5) Visualizza lo spazio libero nello heap\n");
		printf("(6) Forza una compattazione dello heap\n");
		printf("(7) Assegna un valore a una variabile\n");
		printf("(8) Visualizza il valore di una variabile\n");
		printf("(9) Esci\n");
		scanf("%d",&menu);


		switch(menu)
		{
			case 1: creaHeap(); break;
			case 2: cancellaHeap(); break;
			case 3: allocaSpazio(); break;
			case 4: liberaSpazio(); break;
			case 5: visualizzaSpazioLibero(); break;
			case 6: compatta(); break;
			case 7: assegnaValore(); break;
			case 8: visualizzaValore(); break;
			case 9: return 0;
			default: printf("Errore: seleziona nuovamente il numero relativo all'operazione da effettuare\n"); break;
		}
	}
}


static void creaHeap()
{
	int j;
	if(heapLiberi<1)
	{
		printf("E' stato superato il numero massimo di heap, cancellare uno heap prima di ripetere questa operazione\n");
		return;
	}
	char nome[MAXSTR];
	int dimensione,numeroHandle;
	printf("Inserisci il nome del nuovo heap e premi invio\n");
	scanf("%s",nome);
	printf("Inserisci la dimensione in byte dello heap\n");
	scanf("%d",&dimensione);
	printf("Inserisci il numero massimo di handle per questo heap\n");
	scanf("%d",&numeroHandle);
	if (nomeHeapDisponibile(nome)==FALSE)
	{
		printf("Esiste gia uno heap con questo nome, creare uno heap con nome diverso\n");
		return;
	}
	for (i=0;i<10;i++)
	{
		if (heaps[i]==NULL)
		{
			heapTest* ht = (heapTest*)malloc(sizeof(heapTest));
			ht->h=createH(numeroHandle,dimensione);
			if  (getErrore()!=ERROR_NESSUNERRORE)
			{
				stampaErrore(getErrore());
				printf("operazione non effettuata\n");
				return;
			}
			heaps[i]=ht;
			strcpy(heaps[i]->nomeHeap,nome);
			heapLiberi--;
			heaps[i]->datiLiberi=100;
			for(j=0;j<100;j++)
			{
				heaps[i]->dati[j]=NULL;
			}
			printf("Heap %s creato correttamente\n",nome);
			return;
		}
	}
}

static void cancellaHeap()
{
	int j;
	if (heapLiberi==10)
	{
		printf("Nessuno heap allocato\n");
		return;
	}
	char nome[MAXSTR];
	printf("Inserisci il nome dello heap da cancellare e premi invio\n");
	scanf("%s",nome);
	for (i=0;i<10;i++)
	{
		if (heaps[i]!=NULL)
		{
			if(strcmp(heaps[i]->nomeHeap,nome)==0)
			{
				destroyH(heaps[i]->h);
				if  (getErrore()!=ERROR_NESSUNERRORE)
				{
					stampaErrore(getErrore());
					printf("operazione non effettuata\n");
					return;
				}
				heaps[i]=NULL;
				for(j=0;j<100;j++)
				{
					if(heaps[i]->dati[j]!=NULL)
					{
						free(heaps[i]->dati[j]);
					}
				}
				printf("Heap %s distrutto correttamente\n",nome);
				return;
			}
		}
	}
	printf("Non esiste nessun heap con questo nome\n");
	return;
}

static void allocaSpazio()
{
	int j;
	boolean trovato=FALSE;
	int numHeap;
	int numeroDati;
	char nome[MAXSTR];
	printf("Inserisci il nome dello heap su cui allocare spazio\n");
	scanf("%s",nome);
	for (i=0;i<10;i++)
	{
		if (heaps[i]!=NULL)
		{
			if(strcmp(heaps[i]->nomeHeap,nome)==0)
			{
				if(heaps[i]->datiLiberi==0)
				{
					printf("E' stato raggiunto il numero massimo di dati allocabili su questo heap\n");
					return;
				}
				numHeap=i;
				i=10;
				trovato=TRUE;
			}
		}
	}
	if(trovato==FALSE)
	{
		printf("Non esiste nessun heap con questo nome\n");
		return;
	}
	int menu2;
	printf("Digita il numero relativo al tipo di dato da allocare e premi invio;\n\n");
	printf("(1) Alloca un intero\n");
	printf("(2) Alloca un double\n");
	printf("(3) Alloca un carattere o una stringa\n");
	printf("(4) Alloca una struttura con un intero e un double\n");
	scanf("%d",&menu2);

	switch(menu2)
	{
		case 1:
			{
				char* nomeVar;
				printf("Inserisci il nome della variabile per cui allocare spazio\n");
				scanf("%s",nomeVar);
				for(j=0;j<100;j++)
				{
					if(heaps[numHeap]->dati[j]==NULL)
					{
						heaps[numHeap]->dati[j]->dt.intero=(int**)allocH(heaps[numHeap]->h,sizeof(int));
						numeroDati=j;
						j=100;
					}
				}
				if  (getErrore()!=ERROR_NESSUNERRORE)
				{
					stampaErrore(getErrore());
					printf("operazione non effettuata\n");
					return;
				}
				heaps[numHeap]->dati[numeroDati]->nome=nomeVar;
				heaps[numHeap]->datiLiberi--;
				heaps[numHeap]->dati[numeroDati]->selezione=1;
				printf("Spazio allocato con successo\n");
				return;
			}
			break;
		case 2:
			{
				char* nomeVar;
				printf("Inserisci il nome della variabile per cui allocare spazio\n");
				scanf("%s",nomeVar);
				for(j=0;j<100;j++)
				{
					if(heaps[numHeap]->dati[j]==NULL)
					{
						heaps[numHeap]->dati[j]->dt.doppio=(double**)allocH(heaps[numHeap]->h,sizeof(double));
						numeroDati=j;
						j=100;
					}
				}
				if  (getErrore()!=ERROR_NESSUNERRORE)
				{
					stampaErrore(getErrore());
					printf("operazione non effettuata\n");
					return;
				}
				heaps[numHeap]->dati[numeroDati]->nome=nomeVar;
				heaps[numHeap]->datiLiberi--;
				heaps[numHeap]->dati[numeroDati]->selezione=2;
				printf("Spazio allocato con successo\n");
				return;

			}
			break;
		case 3:
			{
				char* nomeVar;
				int numCaratteri;
				printf("Inserisci il nome della variabile per cui allocare spazio\n");
				scanf("%s",nomeVar);
				printf("Inserisci il numero di caratteri\n");
				scanf("%d",&numCaratteri);
				for(j=0;j<100;j++)
				{
					if(heaps[numHeap]->dati[j]==NULL)
					{
						heaps[numHeap]->dati[j]->dt.stringa=(char**)allocH(heaps[numHeap]->h,sizeof(char)*numCaratteri);
						numeroDati=j;
						j=100;
					}
				}
				if  (getErrore()!=ERROR_NESSUNERRORE)
				{
					stampaErrore(getErrore());
					printf("operazione non effettuata\n");
					return;
				}
				heaps[numHeap]->dati[numeroDati]->nome=nomeVar;
				heaps[numHeap]->datiLiberi--;
				heaps[numHeap]->dati[numeroDati]->selezione=3;
				printf("Spazio allocato con successo\n");
				return;

			}
			break;
		case 4:
			{
				char* nomeVar;
				printf("Inserisci il nome della variabile per cui allocare spazio\n");
				scanf("%s",nomeVar);
				for(j=0;j<100;j++)
				{
					if(heaps[numHeap]->dati[j]==NULL)
					{
						heaps[numHeap]->dati[j]->dt.strut=(struttura**)allocH(heaps[numHeap]->h,sizeof(struttura));
						numeroDati=j;
						j=100;
					}
				}
				if  (getErrore()!=ERROR_NESSUNERRORE)
				{
					stampaErrore(getErrore());
					printf("operazione non effettuata\n");
					return;
				}
				heaps[numHeap]->dati[numeroDati]->nome=nomeVar;
				heaps[numHeap]->datiLiberi--;
				heaps[numHeap]->dati[numeroDati]->selezione=4;
				printf("Spazio allocato con successo\n");
				return;
			}
			break;
		default: printf("Errore: numero non corrispondente a una scelta di menu\n"); break;
	}
}

static void liberaSpazio()
{
	int j;
	char nomeH[MAXSTR];
	char nomeV[MAXSTR];
	printf("Inserisci il nome dello heap in cui è allocata la variabile\n");
	scanf("%s",nomeH);
	for (i=0;i<10;i++)
	{
		if (heaps[i]!=NULL)
		{
			if(strcmp(heaps[i]->nomeHeap,nomeH)==0)
			{
				printf("Inserisci il nome della variabile\n");
				scanf("%s",nomeV);
				for(j=0;j<100;j++)
				{
					if(heaps[i]->dati[j]!=NULL)
					{
						if(strcmp(heaps[i]->dati[j]->nome,nomeV)==0)
						{
							if(heaps[i]->dati[j]->selezione=1) {freeH(heaps[i]->h,heaps[i]->dati[j]->dt.intero);}
							else if (heaps[i]->dati[j]->selezione=2) {freeH(heaps[i]->h,heaps[i]->dati[j]->dt.doppio);}
							else if (heaps[i]->dati[j]->selezione=3) {freeH(heaps[i]->h,heaps[i]->dati[j]->dt.stringa);}
							else if (heaps[i]->dati[j]->selezione=3) {freeH(heaps[i]->h,heaps[i]->dati[j]->dt.strut);}
							if  (getErrore()!=ERROR_NESSUNERRORE)
							{
								stampaErrore(getErrore());
								printf("operazione non effettuata\n");
								return;
							}
							heaps[i]->datiLiberi++;
							heaps[i]->dati[j]=NULL;
							printf("Deallocazione e cancellazione variabile avvenuta con successo\n");
							return;
						}
					}
				}
				printf("Non esiste nessuna variabile con questo nome in questo heap\n");
				return;
			}
		}
	}
	printf("Non esiste nessun heap con questo nome\n");
	return;
}

static void visualizzaSpazioLibero()
{
	char nome[MAXSTR];
	int spazio;
	printf("Inserisci il nome dello heap di cui visualizzare lo spazio libero\n");
	scanf("%s",nome);
	for (i=0;i<10;i++)
	{
		if (heaps[i]!=NULL)
		{
			if(strcmp(heaps[i]->nomeHeap,nome)==0)
			{
				spazio=availH(heaps[i]->h);
				if  (getErrore()!=ERROR_NESSUNERRORE)
				{
					stampaErrore(getErrore());
					printf("operazione non effettuata\n");
					return;
				}
				printf("Lo spazio disponibile nello heap %s è di %d byte",nome,spazio);
				return;
			}
		}
	}
	printf("Non esiste nessun heap con questo nome\n");
	return;

}

static void compatta()
{
	char nome[MAXSTR];
	printf("Inserisci il nome dello heap di cui forzare la compattazione\n");
	scanf("%s",nome);
	for (i=0;i<10;i++)
	{
		if (heaps[i]!=NULL)
		{
			if(strcmp(heaps[i]->nomeHeap,nome)==0)
			{
				compactH(heaps[i]->h);
				if  (getErrore()!=ERROR_NESSUNERRORE)
				{
					stampaErrore(getErrore());
					printf("operazione non effettuata\n");
					return;
				}
				printf("Lo heap %s è stato compattato con successo",nome);
				return;
			}
		}
	}
	printf("Non esiste nessun heap con questo nome\n");
	return;
}


void assegnaValore()
{
	char str[MAXSTR];
	int j,val;
	double dub;
	char nomeH[MAXSTR];
	char nomeV[MAXSTR];
	printf("Inserisci il nome dello heap su cui è allocata la variabile\n");
	scanf("%s",nomeH);
	for (i=0;i<10;i++)
	{
		if (heaps[i]!=NULL)
		{
			if(strcmp(heaps[i]->nomeHeap,nomeH)==0)
			{
				printf("Inserisci il nome della variabile\n");
				scanf("%s",nomeV);
				for (j=0;j<100;j++)
				{
					if(heaps[i]->dati[j]!=NULL)
					{
						if(strcmp(heaps[i]->dati[j]->nome,nomeV)==0)
						{
							if(heaps[i]->dati[j]->selezione==1)
							{
								printf("Inserisci il valore\n");
								scanf("%d",&val);
								**(heaps[i]->dati[j]->dt.intero)=val;
								printf("Assegnamento effettuato\n");
								return;
							}
							else if(heaps[i]->dati[j]->selezione==2)
							{
								printf("Inserisci il valore\n");
								scanf("%g",&dub);
								**(heaps[i]->dati[j]->dt.doppio)=dub;
								printf("Assegnamento effettuato\n");
								return;
							}
							else if(heaps[i]->dati[j]->selezione==3)
							{
								printf("Inserisci il valore\n");
								scanf("%s",str);
								strcpy(*(heaps[i]->dati[j]->dt.stringa),str);
								printf("Assegnamento effettuato\n");
								return;
							}
							else if(heaps[i]->dati[j]->selezione==3)
							{
								/*
								printf("Inserisci il valore dell'intero\n");
								scanf("%d",&val);
								**(heaps[i]->dati[j]->dt.strut->datoIntero)=val;
								printf("Inserisci il valore del double\n");
								scanf("%g",&dub);
								**(heaps[i]->dati[j]->dt.strut->datoDouble)=dub;
								printf("Assegnamento effettuato\n");
								return;
								*/
							}

						}
					}
				}

			}
		}
	}
	printf("Non esiste nessun heap con questo nome\n");
	return;

}


void visualizzaValore()
{
	char* nome;
	printf("Inserisci il nome dello heap di cui forzare la compattazione\n");
	scanf("%s",nome);
	for (i=0;i<10;i++)
	{
	}
	return;

}


static boolean nomeHeapDisponibile(char* nome)
{
	int j;
	for (j=0;j<10;j++)
	{
		if (heaps[j]!=NULL)
		{
			if(strcmp(heaps[j]->nomeHeap,nome)==0)
			{
				return FALSE;
			}
		}
	}
	return TRUE;
}


static void stampaErrore(int numeroErrore)
{
	switch(numeroErrore)
	{
		case ERROR_MALLOC : 		printf("Errore durante una malloc\n"); break;
		case ERROR_NUMEROHANDLE	:	printf("Errore, superato il numero massimo di handle per questo heap\n"); break;
		case ERROR_SPAZIOLIBERO	:	printf("Errore, spazio libero non sufficente in questo heap per allocare il dato\n"); break;
		case ERROR_ZEROVAL		:	printf("Errore, parametro con valore zero non ammesso nella funzione\n"); break;
		case ERROR_NULLVAL		:	printf("Errore, parametro con valore nullo non ammesso nella funzione\n"); break;
		case ERROR_POSIZIONE	:	printf("Errore, superato il numero massimo di handle per questo heap\n"); break;
		case ERROR_FREEH		:	printf("Errore, handle inesistente\n"); break;
	}
}

e questo è lo header (api) dell' allocatore:

/*
file: allocatore.h
Header con le API dell'allocatore di memoria.

*/


#ifndef ALLOCATORE_H_
#define ALLOCATORE_H_

#include "tipiAllocatore.h"

static int codiceErrore;
/*
crea un nuovo heap, capace di gestire al più nhandles handle, e con uno spazio per i dati di size bytes.
*/
heap *createH(int nhandles, int size);

/*
alloca size bytes nello heap h, restituisce il puntatore a un handle (o NULL in caso di errore). Se c'è sufficiente spazio disponibile, ma non contiguo, effettua una ricompattazione e poi alloca il blocco.
*/
void **allocH(heap *h, int size);

/*
libera la memoria allocata dall'handle handle nello heap h. L'handle deve essere stato ottenuto da una precedente chiamata a allocH().
*/
void freeH(heap *h, void **handle);

/*
restituisce la quantità di spazio libero nello heap h (ovvero, la somma della dimensione di tutti gli eventuali frammenti liberi), -1 in caso di errore.
*/
int availH(heap *h);

/*
forza una ricompattazione dello heap h.
*/
void compactH(heap *h);

/*
distrugge lo heap h; dopo questa operazione, tutti gli handle ottenuti da allocH() su quello heap sono invalidi.
*/
void destroyH(heap *h);


#endif /* ALLOCATORE_H_ */

[braian]

Ho risolto...sono un po' di furia ma appena posso spiego come