Liste in c++

[Mezzetti0903]

Beh...dopo un bel po' di astinenza mi sono ridato al C++ e in particolare sto "realizzando" una lista copiandola paro paro da un libro.

#include <stdlib.h>

typedef int tipoelemento;
struct cella {
	tipoelemento elemento;
	struct cella *precedente,*successivo;
};
typedef struct cella *lista,*posizione;

void CreaLista(lista *L) {
	(*L)=(lista)malloc(sizeof(struct cella));
	(*(*L)).precedente = *L;
	(*(*L)).successivo = *L;
}

bene.... e fin qui tutto mi torna....ma la domanda è... se io volessi creare questa benedetta lista nel Main richiamando la funzione CreaLista che dovrei metterci(come parametro intendo)??
Mi fate un esempio??

Grazie...infinite....

[VegetaSSJ5]

main{
.
.
.
.
lista xyz;
CreaLista(xyz);
.
}

io sto facenndo il c ma vedo che almeno questo è uguale al c++.

[Mezzetti0903]

Ti dirò in realtà avevo provato

lista *li;
CreaLista(li);

perchè in fondo quella funzione accetta un puntatore ad un puntatore....quindi così dovrebbe essere corretto.

in realtà in run-time mi da un bel "Access Violation" nella riga
"(*L)=(lista)malloc(sizeof(struct cella));"




ho provato anche come dici te ma
lista li;
CreaLista(li) da errore in compilazione "error C2664: 'CreaLista' : cannot convert parameter 1 from 'struct cella *' to 'struct cella **"



Come risolvo l'Access Violation?? oppure...dove sbaglio??

[VegetaSSJ5]

nell'intestazione di CreaLista, nel parametro io non metterei un puntatore a un "tipo" lista ma seplicemente un elemento di "tipo" lista visto che comunque ogni elemento di "tipo" lista è (per definizione nella struct cella) un puntatore ad una struttura cella.

[VegetaSSJ5]

insomma modificherei CreaLista in questo modo:

void CreaLista(lista L) {
	L=(lista)malloc(sizeof(struct cella));
	L->precedente = NULL;
	L->successivo = NULL;
}

[Mezzetti0903]

Beh....ora funziona....grazie!

ma perchè prima c'era quell'access violation??
non gli vanno giù i puntatori di puntatori??

grazie ancora!

[cionci]

void CreaLista(lista L) {
	L=(lista)malloc(sizeof(struct cella));
	L->precedente = NULL;
	L->successivo = NULL;
}

Questo non va bene...
Metti che venga allocato un solo elemento:

lista li = NULL;
CreaLista(li);

li ha ancora valore NULL anche dopo la chiamata a CreaLista!!!

Era giusto il codice iniziale:

typedef int tipoelemento;
struct cella {
	tipoelemento elemento;
	struct cella *precedente,*successivo;
};
typedef struct cella *lista,*posizione;

void CreaLista(lista *L) {
	(*L)=(lista)malloc(sizeof(struct cella));
	(*(*L)).precedente = *L;
	(*(*L)).successivo = *L;
}

lista li;
CreaLista(&li);

In questo modo passi l'indirizzo di li a CreaLista...

L è l'indirizzo di li...*L è li... Quindi andando a modificare *L si va a modificare li !!!

Con il codice postato prima invece il valore iniziale di li veniva copiato in L, ma il valore ottenuto con malloc veniva copiato in L che aveva lo stesso valore di li, ma non vai a modificare li...

Comunque questo non è C++...è puro C !!!

In C++ molte cose si potrebbero fare in maniera diversa... L'uso di new e il passaggio dei dati per riferimento avrebbe dato una mano !!!

In C++:

typedef int tipoelemento;
struct cella {
	tipoelemento elemento;
	cella *precedente,*successivo;
};
typedef cella *lista,*posizione;

void CreaLista(lista &L) {
	L = new cella;
	(*L).precedente = L;
	(*L).successivo = L;
}

lista li;
CreaLista(li);

Questo ovviamente sempre rispettando la struttura iniziale...

[Mezzetti0903]

Grazie cionci.

Sono passato alla versione in C++ che mi piace di più, è più pulita!

però....

#include <stdlib.h>

typedef int tipoelemento;
struct cella {
	tipoelemento elemento;
	cella *precedente,*successivo;
};
typedef cella *lista,*posizione;

void CreaLista(lista &L) {
	L = new cella;
	(*L).precedente = L;
	(*L).successivo = L;
	
}


char ListaVuota(lista L) {
	return ((*L).successivo==L);
}
posizione PrimoLista(lista L) {
	return ( (*L).successivo);
}
posizione UltimoLista(lista L) {
	return ( (*L).precedente);
}
posizione SuccLista(posizione p){
	return ((*p).successivo);
}
posizione PrecLista(posizione p){
	return ( (*p).precedente);
}
char FineLista(posizione p,lista L) {
	return (p==L);
}
tipoelemento LeggiLista(posizione p, lista L){
	return( (*p).elemento);
}
void ScriviLista(tipoelemento a, posizione p, lista L) {
	(*p).elemento=a;
}
void InsLista (tipoelemento a, posizione &p, lista L) {
	struct cella *temp;
	temp=(struct cella *)malloc(sizeof(struct cella));
	(*temp).precedente=(*p).precedente;
	(*temp).successivo=p;
	(*((*temp).precedente)).successivo=temp;
	(*p).precedente=temp;
	(*temp).elemento=a;
	p=temp;
}


void main() {
	lista li;
	CreaLista(li);
	posizione po=PrimoLista(li);
	InsLista(10,po,li);
}

beh...così funziona ma se volessi riassumere

	posizione po=PrimoLista(li);
	InsLista(10,po,li);

in un qualcosa tipo
InsLista(10,PrimoLista(li),li);

come posso fare?? lo posso fare?? così non funziona...

sì...è vero...scusate ... sono un po' niubbo...ma migliorerò GIURO!!

[cionci]

Perchè hai passato per riferimento p: posizione &p