Pile dinamiche (C++)

[::::Dani83::::]

Ciao a tutti, mi sono "un attimo" arenato con una cosetta..... detta molto in breve se date uno sguardo a questo codice (funzionante) scoprirete che la sua funzione è semplicemente quella di aggiungere/togliere/visualizzare gli elementi da una pila dinamica. Il problema è che a me servirebbe capire come riuscire a salvare più di un valore in quella struttura ovvero: Ora nella struttura c'è soltanto la variabile "valore" io vorrei aggiungere una variabile "valore2" in modo che quando andrò a fare una stampa della mia pila avrò un risultato di questo tipo:

STAMPA VALORI DELLA PILA:
posizione1 -> valore:45 valore2:56
posizione2 -> valore:34 valore2:67

Spero di essermi spiegato, se volete qualche informazione in più chiedete pure..nn so più che provare... :(

-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-

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


struct cella
{
int valore;
struct cella *next;
};

struct cella* pop(struct cella **t);
void push(struct cella **t, int num);
void stampaPila(struct cella **t);
void resetPila(struct cella **t);

int main()
{
char opzione;
int count, numero, numero2, num1;
struct cella *testa;
testa = NULL;

while (1)
{
system("cls");
printf("\n\n Seleziona l\'operazione:\n");
printf("\n 1 - Inserisci nuovo elemento");
printf("\n 2 - Stampa elenco elementi");
printf("\n 3 - Azzera la Pila");
printf("\n 4 - Esci");
printf("\n\n > ");
fflush(stdin);
opzione = getch();
switch(opzione)
{
case '1':
system("cls");
printf("\n\n INSERIMENTO");
printf("\n\n Inserisci il valore intero da inserire nella pila: ");
fflush(stdin);
scanf("%d",&numero);
push(&testa,numero);
printf("\n\n Nuovo elemento creato correttamente!\n ");
system("pause");
break;
case '2': //stampa degli elementi in pila
system("cls");
printf("\n\n STAMPA VALORI IN PILA\n\n");
stampaPila(&testa);
printf("\n\n La pila e\' stata svuotata!\n ");
system("pause");
break;
case '3': //azzera pila
system("cls");
if (testa == NULL)
printf("\n\n PILA VUOTA!\n\n ");
else
{
resetPila(&testa);
printf("\n\n PILA AZZERATA!\n\n ");
}
system("pause");
break;
case '4': //Esci dal programma
exit(0);
break;
}

}

return 0;
}


void resetPila(struct cella **t)
{
struct cella *temp;

while (*t != NULL)
{
temp = pop(t);
if (temp != NULL)
free(temp);
}
}

void stampaPila(struct cella **t)
{
struct cella *temp;

printf("\n");
if (t == NULL)
{
printf(" La pila e\' vuota!\n");
return;
}

do
{
temp = pop(t);
printf(" valore: %d\n",temp->valore);
free(temp);
} while(*t != NULL);
}

void push(struct cella **t, int num)
{
struct cella *nuovoElemento;

nuovoElemento = (struct cella*)malloc(sizeof(struct cella));
if (nuovoElemento == NULL)
{
printf("\n\n Errore nell\'allocazione della memoria.\n Il programma verra\' chiuso!\n ");
system("pause");
exit(1);
}
nuovoElemento->valore = num;
nuovoElemento->next = *t;
*t = nuovoElemento;
}

struct cella * pop(struct cella **t)
{
struct cella *temp;

if (*t == NULL)
return NULL;
temp = *t;
*t = (*t)->next;
temp->next = NULL;
return temp;
}

-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-

[andbin]

Ciao a tutti, mi sono "un attimo" arenato con una cosetta..... detta molto in breve se date uno sguardo a questo codice (funzionante) scoprirete che la sua funzione è semplicemente quella di aggiungere/togliere/visualizzare gli elementi da una pila dinamica. Il problema è che a me servirebbe capire come riuscire a salvare più di un valore in quella struttura ovvero: Ora nella struttura c'è soltanto la variabile "valore" io vorrei aggiungere una variabile "valore2" in modo che quando andrò a fare una stampa della mia pila avrò un risultato di questo tipo:

STAMPA VALORI DELLA PILA:
posizione1 -> valore:45 valore2:56
posizione2 -> valore:34 valore2:67
Ciao, non ho analizzato per intero il sorgente ma è abbastanza semplice fare quello che chiedi:
1) Aggiungi alla struttura cella un "int valore2;"
2) Modifichi la funzione stampaPila() in modo da fare il print anche di valore2.
3) Modifichi la funzione push() aggiungendogli un nuovo parametro num2 (che poi metterai in nuovoElemento->valore2).
4) Modifichi il case per l'opzione 1 (inserimento) in modo da richiedere anche un secondo valore da passare poi alla push().


P.S.: Quando posti del codice particolarmente lungo/complesso, per cortesia mettilo tra i tag CODE. A quest'ora della sera mi si incrociano gli occhi a leggere codice non indentato. ;)

[-Ivan-]

Ciao a tutti, mi sono "un attimo" arenato con una cosetta..... detta molto in breve se date uno sguardo a questo codice (funzionante) scoprirete che la sua funzione è semplicemente quella di aggiungere/togliere/visualizzare gli elementi da una pila dinamica. Il problema è che a me servirebbe capire come riuscire a salvare più di un valore in quella struttura ovvero: Ora nella struttura c'è soltanto la variabile "valore" io vorrei aggiungere una variabile "valore2" in modo che quando andrò a fare una stampa della mia pila avrò un risultato di questo tipo:

STAMPA VALORI DELLA PILA:
posizione1 -> valore:45 valore2:56
posizione2 -> valore:34 valore2:67

Spero di essermi spiegato, se volete qualche informazione in più chiedete pure..nn so più che provare... :(

-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-

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


struct cella
{
int valore;
int valore2;
struct cella *next;
};

struct cella* pop(struct cella **t);
void push(struct cella **t, int num);
void stampaPila(struct cella **t);
void resetPila(struct cella **t);

int main()
{
char opzione;
int count, numero, numero2, num1;
struct cella *testa;
testa = NULL;

while (1)
{
system("cls");
printf("\n\n Seleziona l\'operazione:\n");
printf("\n 1 - Inserisci nuovo elemento");
printf("\n 2 - Stampa elenco elementi");
printf("\n 3 - Azzera la Pila");
printf("\n 4 - Esci");
printf("\n\n > ");
fflush(stdin);
opzione = getch();
switch(opzione)
{
case '1':
system("cls");
printf("\n\n INSERIMENTO");
printf("\n\n Inserisci il valore intero da inserire nella pila: ");
fflush(stdin);
scanf("%d",&numero);
push(&testa,numero);
printf("\n\n Nuovo elemento creato correttamente!\n ");
system("pause");
break;
case '2': //stampa degli elementi in pila
system("cls");
printf("\n\n STAMPA VALORI IN PILA\n\n");
stampaPila(&testa);
printf("\n\n La pila e\' stata svuotata!\n ");
system("pause");
break;
case '3': //azzera pila
system("cls");
if (testa == NULL)
printf("\n\n PILA VUOTA!\n\n ");
else
{
resetPila(&testa);
printf("\n\n PILA AZZERATA!\n\n ");
}
system("pause");
break;
case '4': //Esci dal programma
exit(0);
break;
}

}

return 0;
}


void resetPila(struct cella **t)
{
struct cella *temp;

while (*t != NULL)
{
temp = pop(t);
if (temp != NULL)
free(temp);
}
}

void stampaPila(struct cella **t)
{
struct cella *temp;

printf("\n");
if (t == NULL)
{
printf(" La pila e\' vuota!\n");
return;
}

do
{
temp = pop(t);
printf(" valore: %d\n",temp->valore);
printf(" valore 2: %d\n",temp->valore2);
free(temp);
} while(*t != NULL);
}

void push(struct cella **t, int num)
{
struct cella *nuovoElemento;

nuovoElemento = (struct cella*)malloc(sizeof(struct cella));
if (nuovoElemento == NULL)
{
printf("\n\n Errore nell\'allocazione della memoria.\n Il programma verra\' chiuso!\n ");
system("pause");
exit(1);
}
nuovoElemento->valore = num;
nuovoElemento->valore2= bo fai te;
nuovoElemento->next = *t;
*t = nuovoElemento;
}

struct cella * pop(struct cella **t)
{
struct cella *temp;

if (*t == NULL)
return NULL;
temp = *t;
*t = (*t)->next;
temp->next = NULL;
return temp;
}

-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-

Come ho scritto io dovrebbe bastare.

[::::Dani83::::]

grazie mille ad entrambi, effettivamente mi ero perso in un bicchier d'acqua :mc:

p.s scusate per il tag :p

[Fenomeno85]

ma scusa diventa molto più bella l'implementazione della pila sotto classi alla fine questo è c.

~§~ Sempre E Solo Lei ~§~

[::::Dani83::::]

devo seguire delle linee guida quindi anche se per risolvere alcuni problemi ci sono vie più "eleganti" devo cmq attenermi ad esse....ora mi sono arenato in un altro bicchier d'acqua.... Stampando le strutture tramite "Pop" esse vengono estratte e quindi cancellate, per evitare che esse vengano cancellate avevo pensato di visualizzare le strutture in questo modo ma devo aver sbagliato qualcosa nel ciclo do-while in fondo al codice... :mc: :

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


struct cella
{
int valore;
int valore2;
struct cella *next;

};

struct cella* pop(struct cella **t);
void push(struct cella **t, int num, int num2);
void stampaPila(struct cella **t);


int main()
{
char opzione;
int count, numero, numero2, num1;
struct cella *testa;
testa = NULL;

while (1)
{
system("cls");
printf("\n\n Seleziona l\'operazione:\n");
printf("\n 1 - Inserisci nuovo elemento");
printf("\n 2 - Stampa elenco elementi");
printf("\n 3 - Azzera la Pila");
printf("\n 4 - Esci");
printf("\n\n > ");
fflush(stdin);
opzione = getch();
switch(opzione)
{
case '1':
system("cls");
printf("\n\n INSERIMENTO");
printf("\n\n Inserisci il valore intero da inserire nella pila: ");
fflush(stdin);
scanf("%d",&numero);
printf("\n\n Inserisci il valore intero da inserire nella pila 2: ");
scanf("%d",&numero2);
push(&testa,numero,numero2);
printf("\n\n Nuovo elemento creato correttamente!\n ");
system("pause");
break;
case '2': //stampa degli elementi in pila
system("cls");
printf("\n\n STAMPA VALORI IN PILA\n\n");
stampaPila(&testa);
printf("\n\n La pila e\' stata svuotata!\n ");
system("pause");
break;

case '4': //Esci dal programma
exit(0);
break;
}

}

return 0;
}


void stampaPila(struct cella **t)
{
struct cella *temp;

printf("\n");
if (t == NULL)
{
printf(" La pila e\' vuota!\n");
return;
}

do
{
temp=*t;
printf(" valore: %d\n",temp->valore);
printf(" valore2:%d\n",temp->valore2);
temp = temp->next;
} while(temp != NULL);
}

void push(struct cella **t, int num, int num2)
{
struct cella *nuovoElemento;

nuovoElemento = (struct cella*)malloc(sizeof(struct cella));
if (nuovoElemento == NULL)
{
printf("\n\n Errore nell\'allocazione della memoria.\n Il programma verra\' chiuso!\n ");
system("pause");
exit(1);
}
nuovoElemento->valore = num;
nuovoElemento->valore2 = num2;
nuovoElemento->next = *t;
*t = nuovoElemento;
}

[andbin]

devo seguire delle linee guida quindi anche se per risolvere alcuni problemi ci sono vie più "eleganti" devo cmq attenermi ad esse....ora mi sono arenato in un altro bicchier d'acqua.... Stampando le strutture tramite "Pop" esse vengono estratte e quindi cancellate, per evitare che esse vengano cancellate avevo pensato di visualizzare le strutture in questo modo ma devo aver sbagliato qualcosa nel ciclo do-while in fondo al codice... :mc: :
La funzione stampaPila() non deve alterare il puntatore alla testa e quindi è inutile passargli l'indirizzo del puntatore alla testa. Si potrebbe riscrivere la funzione così:
void stampaPila(struct cella *t);

...
stampaPila(testa);
...

void stampaPila(struct cella *t)
{
printf("\n");
if (t == NULL)
{
printf(" La pila e\' vuota!\n");
return;
}

do
{
printf(" valore: %d\n",t->valore);
printf(" valore2:%d\n",t->valore2);
t = t->next;
} while(t != NULL);
}

[::::Dani83::::]

La funzione stampaPila() non deve alterare il puntatore alla testa e quindi è inutile passargli l'indirizzo del puntatore alla testa. Si potrebbe riscrivere la funzione così:
cut...

Già....così come hai detto tu funziona benissimo infatti... ora devo applicarlo al programma vero e proprio..speriamo bene :p
Grazie mille ancora una volta :)

[::::Dani83::::]

ahmm.... come si passa una matrice ad una struttura? scusate se stresso ma ho cercato su google e sul manuale che ho ma nn ho trovato nulla :(
se la passo così:
nuovoElemento->Piano1S = Piano1;

mi dice:
error C2440: '=' : cannot convert from 'int [][16]' to 'int [16][16]'
devo passargliela tramite un doppio puntatore? :fagiano:

vi posto il codice ma sono quasi 700righe... mi basterebbe sapere la teoria...credo :D
(l'errore è nelle righe rosse in fondo al codice..)
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

struct cella
{
char sceltaRigaColonna;
char sceltaRigaS;
char sceltaLatoS;
char sceltaColonnaS;
char sceltaVersoS;
int counterS;
int Piano1S[16][16];
int Piano2S[16][16];
struct cella *next;
};

//struct cella* pop(struct cella **t);
void salvataggioMosse(struct cella **t, char scelta1,char sceltaRiga1,char sceltaLato1,char sceltaColonna1,char sceltaVerso1,int counter1,int Piano1[16][16],int Piano2[16][16]);
void stampaMosse(struct cella *t);

void annullaMossa(struct cella **t);
int mossa=0;

//** Partita guidata **//
//Riga 1, 1 volta a sinistra
//Riga 3, 1 volta a destra
//Colonna 4, 1 volta in alto
//Colonna 3, 1 volta in alto

//struct cella
//{
// double secondi;
// struct cella *next;
//};

void guida(); //guida
void gioca(); //gioca
void menu(); //menù inziale
void palline();
void inserireNomiGiocatori(char giocatori[2][10]);
void inizioGioco();
void stampaTavoloDaGioco(int Tavolo1[16][16],int *pallinerosse1,int *pallineblu1);
void controlloVittoria(int pallinerosse1, int pallineblu1, char giocatori[2][10],int *gioca1);
void puliziaTavolo(int Tavolo1[16][16]);
void stampaLista();
void spostaRiga(int Piano1[16][16], int counter_Righe1[16],int *sceltaRiga,int *sceltaLato);
void spostaColonna(int Piano2[16][16], int counter_Colonne1[16],int *sceltaColonna,int *sceltaVerso);
void controlloBuchi(int Piano1[16][16], int Piano2[16][16], int Tavolo1[16][16]);
/* Variabili di controllo menù */
//int controllomenu = 1;
//int controllomenu2= 1;
int stampalista = 0;

int i,j=0;

int main ()
{
char m; // switch menù iniziale

do
{
system("cls");
printf("+------------------------------------------------------------------------------+");
printf("| |");
printf("| TENDI LA TRAPPOLA |");
printf("| |");
printf("+------------------------------------------------------------------------------+\n\n\n\n");
printf(" +---------------------------------------------------------+\n");
printf(" | Per la Guida premi \"G\" |\n");
printf(" +---------------------------------------------------------+\n");
printf(" | Per Iniziare una partita premi \"I\" |\n");
printf(" +---------------------------------------------------------+\n");
printf(" | Per Uscire premi \"E\" |\n");
printf(" +---------------------------------------------------------+\n\n\n");
printf(" Cosa vuoi fare? ");
fflush(stdin);
//m = getch(); mah...
scanf("%1c",&m);
switch (m) //switch per scegliere le opzioni del menù
{
case 'g':
case 'G':
fflush(stdin);
guida();
break;
case 'i':
case 'I':
inizioGioco();
break;
case 'e':
case 'E':
system("cls");
printf("Grazie di aver giocato con noi\n\n\n");
exit(0);
default:
printf("\nHai sbagliato a digitare, presta maggiore attenzione alle scritte \n\n\n");
system("pause");
system("cls");
}

} //fine do
while(1);

}

void inizioGioco()
{
char player[2][10];
int pallinerosse=0;
int pallineblu=0;
int Piano_1[16][16]={
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0},
{0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0},
{0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0},
{0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0},
{0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0},
{0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0},
{0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0},
{0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
int Piano_2[16][16] = {
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0},
{0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0},
{0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0},
{0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0},
{0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
int Tavolo[16][16] = {
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,3,1,1,1,1,1,1,1,0,0,0,0},
{0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0},
{0,0,0,0,1,5,1,3,1,1,1,1,0,0,0,0},
{0,0,0,0,1,1,1,1,5,1,1,1,0,0,0,0},
{0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0},
{0,0,0,0,1,1,3,1,5,1,1,1,0,0,0,0},
{0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0},
{0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
};




struct cella *testa;
testa = NULL;
int rigaScelta=0;
int latoScelto=0;
int colonnaScelta=0;
int versoScelto=0;
int counter=0; //serve per decidere il giocatore,e tiene il conto delle mosse vere e proprie

/***** Counter # mosse sx(--), dx(++), up(++), dw(--) *****/
int counter_Righe[16] ={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int counter_Colonne[16] ={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int scelta=0;
int gioca=1;
inserireNomiGiocatori(player);
//credo debba iniziare il ciclo
while(gioca)
{
rigaScelta=0;
latoScelto=0;
colonnaScelta=0;
versoScelto=0;
mossa=0;
pallinerosse=0;
pallineblu=0;
stampaTavoloDaGioco(Tavolo, &pallinerosse, &pallineblu);
controlloVittoria(pallinerosse, pallineblu, player, &gioca);
if (gioca==0) //ho dovuto aggiungere altrimenti andava avanti
return;
puliziaTavolo(Tavolo);
if (stampalista == 1)
stampaLista();
/* INIZIO DEL GIOCO */
printf("\n\t\t\tTurno di ");
if (counter % 2!=0) printf("%s",player[1]);
else printf("%s", player[0]);
//time(&start);
fflush(stdin);
printf("\n\npremi \"E\" per uscire, \"G\" per la guida, \"A\" per annullare e \"L\" per la legenda.");
printf("\nVuoi spostare una riga o una colonna? ");
printf("\nPer spostare una riga premi \"R\"\n");
printf("Per spostare una colonna premi \"C\"\n");
printf("Scelta: ");
scanf("%1c",&scelta);
switch(scelta)
{
case 'R':
case 'r':
spostaRiga(Piano_1, counter_Righe, &rigaScelta, &latoScelto);
break;
case 'C':
case 'c':
spostaColonna(Piano_2, counter_Colonne, &colonnaScelta, &versoScelto);
break;
case 'e':
case 'E':
system("cls");
printf("Grazie di aver giocato con noi\n\n\n");
exit(0);
break;
case 'l':
case 'L':
system("cls");
printf("\t\tLEGENDA\n");
printf("B sono le palline blù del giocatore 1\n");
printf("R sono le palline rosse del giocatore 2\n");
printf("@ sono i buchi in cui le palline possono cadere\n\n");
system("pause");
break;
case 'g':
case 'G':
fflush(stdin);
guida();
break;
case 'a':
case 'A':
annullaMossa(&testa);
counter--;
break;
default:
printf("Attenzione, errore di battitura\n\n");
system("pause");
break;
}
//time(&finish);
//duration = difftime(finish, start);
/*for (i=0;i<l;i++)
{
printf("%d %d %d %d\n",i,senso[i],numerolistello[i],direzione[i]);
}
nuovoElemento = (struct cella*)malloc(sizeof(struct cella));
if (nuovoElemento == NULL)
{
printf("\n\n Errore nell\'allocazione della memoria.\n Il programma verra\' chiuso!\n ");
system("pause");
exit(1);
}
nuovoElemento->secondi = duration;
nuovoElemento->next = testa;
testa = nuovoElemento;
tot++;*/
if (mossa) //solo se è stata eseguita una mossa vera e propria viene aumentato il counter e fatto il salvataggioMosse
{
counter++;
salvataggioMosse(&testa,scelta,rigaScelta,latoScelto,colonnaScelta,versoScelto,counter,Piano_1,Piano_2);
stampaMosse(testa);
}
system("pause");
controlloBuchi(Piano_1, Piano_2, Tavolo);

}
system("pause");
return;
}

void inserireNomiGiocatori(char giocatori[2][10]) //ok
{
system("cls");
printf("Inizio Gioco");
for (i = 0; i < 2; i++)
{
printf("\nInserire il nome del giocatore %d: ",i+1);
fflush(stdin);
scanf("%s",giocatori[i]);
}
system("cls");
printf("\n\n%s giochera\' contro %s\n\n\n",giocatori[0],giocatori[1]);
system("pause");
return;
}

void guida() //ok
{
system("cls");
printf("\t\tGUIDA\n\n");
printf("Gioco per due giocatori\n");
printf("Obbiettivo: Lo scopo del gioco e\' far cadere tutte le palline dell'avversario intrappola.\n");
printf("E' un gioco a turni che si svolge su di una griglia 8*8.\n");
printf("Ogni giocatore avrà 10 palline e ad ogni turno deve spostare un listello,\norizzontale o verticale, a sua scelta di una posizione.\n");
printf("Ogni listello presenta dei buchi sulla sua superficie.\n");
printf("Se due buchi si trovano uno sopra l'altro generano una cavità e la pallina che si trova sopra la griglia cade.\n");
printf("Per fare iniziare i due giocatori in condizioni di equita\' all'inizio del gioco non potra\' esserci gia\' un buco\n");
printf("Vince chi per primo riesce a far cadere in trappola le palline avversarie.\n\n");
system("pause");
system("cls");
return;
}

void stampaTavoloDaGioco(int Tavolo1[16][16],int *pallinerosse1,int *pallineblu1) //ok
{
/***** STAMPA DEL TAVOLO DA GIOCO e conteggio palline *****/
printf("+------------------------------------------------------------------------------+");
printf("| |");
printf("| TENDI LA TRAPPOLA |");
printf("| |");
printf("+------------------------------------------------------------------------------+");
printf("\t\t\t\t 1-2-3-4-5-6-7-8\n");
printf("\t\t\t\t+---------------+\n");
for (i=4; i<12; i++)
{
printf("\t\t\t\t|");
for (j=4; j<12; j++)
{
if (Tavolo1[i][j]!=1)
{
if (Tavolo1[i][j]==5)
{
printf("R|",Tavolo1[i][j]);
*pallinerosse1 +=1;
}
else
{
if (Tavolo1[i][j]==3)
{
printf("B|",Tavolo1[i][j]);
*pallineblu1 +=1;
}
else
printf("@|",Tavolo1[i][j]);
}
}
else printf("%d|",Tavolo1[i][j]);
}
printf("\n");
}
printf("\t\t\t\t+---------------+\n");
return;
}

void controlloVittoria(int pallinerosse1,int pallineblu1,char giocatori[2][10],int *gioca1) //ok
{
/* Calcolo palline rimanenti ai player */
printf("%s ha %d pallin",giocatori[0],pallineblu1);
if (pallineblu1==1)
printf("a\n");
else
printf("e\n");
printf("%s ha %d pallin",giocatori[1],pallinerosse1);
if (pallinerosse1==1)
printf("a\n");
else printf("e\n");
/* Controllo condizioni di vittoria */
if (pallineblu1==0 || pallinerosse1==0)
{
printf("\n\n\t\t\t\tPARTITA CONCLUSA");
if (pallineblu1==0 && pallinerosse1!=0)
{
printf("\n\n\n\t\t\t\t VINCE %s\n\n",giocatori[0]);
stampalista=1;
*gioca1=0;
system("pause");
}
if (pallinerosse1==0 && pallineblu1!=0 )
{
printf("\n\n\n\t\t\t\t VINCE %s\n\n",giocatori[1]);
stampalista=1;
*gioca1=0;
system("pause");
}
if (pallinerosse1==0 && pallineblu1==0)
{
printf("\n\n\n\t\t\t\t PAREGGIO\n\n");
stampalista=1;
*gioca1=0;
system("pause");
}
}
//*gioca1=0;
}

void puliziaTavolo(int Tavolo1[16][16]) //da controllare
{
int i,j=0;
for (i=0; i<16; i++)
{
for (j=0; j<16; j++)
{
if (Tavolo1[i][j] == 8)
{
Tavolo1[i][j]=1;
}
}
}
}


void stampaLista() //mancano ancora dei dati che vengono utilizzati dalla funzione
{
printf("stampa lista");
/*system("cls");
printf("\n\n STAMPA ELENCO MOSSE\n\n");
tem = testa;
l--;
while (tem != NULL)
{
if (tot % 2!=0) printf("%s",player[0]);
else printf("%s", player[1]);
printf(" ha mosso la");
printf(" %d ^ ",numerolistello[l]);
if(senso[l]==1) printf(" righa ");
else
{
if (senso[l]==2) printf(" colonna ");
else
printf("%d",senso[l]);
}
printf("verso ");
if (senso[l] == 1 && direzione[l] == 1) printf("sinistra");
else
if (senso[l] == 1 && direzione[l] == 2) printf("destra");
if (senso[l] == 2 && direzione[l] == 1) printf("l'alto");
if (senso[l] == 2 && direzione[l] == 2) printf("il basso");
printf(" ed ha effettuato la %d^ mossa in %f secondi \n",(tot),tem->secondi);
tem = tem->next;
tot--;
count++;
--l;
}
printf("\n\nStampate %d mosse\n ",count);
system("pause");
return;*/
}

void spostaRiga(int Piano1[16][16], int counter_Righe1[16],int *sceltaRiga,int *sceltaLato)
{
int errore1=1;
int errore2=1;
//int sceltaRiga=0;
//int sceltaLato=0;
int temp=0;
//senso[l]=1;
while (errore1)
{
/* Sposta riga orizzontalmente (piano 1) */
printf("Inserisci la riga da spostare(1-2-3-4-5-6-7-8): ");
scanf("%1d",&*sceltaRiga);
if (*sceltaRiga>0 && *sceltaRiga<9)
{
errore1 = 0;
//numerolistello[l]=b;
}
else
printf("Hai sbagliato a digitare, riprova!\n");
}
*sceltaRiga = *sceltaRiga+4;
while (errore2)
{
printf("Vuoi spostare a sinistra (premi '1') o a destra (premi '2')? ");
scanf("%d",&*sceltaLato);
if (*sceltaLato == 1 || *sceltaLato == 2)
{
errore2 = 0;
//direzione[l]=sceltaLato;
//l++;
}
else
printf("Hai sbagliato a digitare, riprova!\n");
}
fflush(stdin);
if (*sceltaLato == 1)
{
counter_Righe1[*sceltaRiga-1]--;
if (counter_Righe1[*sceltaRiga-1]==-4)
{
printf("\nE\' l'ultima volta che puoi spostare a sinistra questa bacchetta");
system("pause");
}
for (i=0,temp = Piano1[*sceltaRiga-1][i]; i<15; i++)
{
Piano1[*sceltaRiga-1][i] = Piano1[*sceltaRiga-1][i+1]; //sposta la riga a sinistra
}
Piano1[*sceltaRiga-1][i]= temp;
}
if (*sceltaLato == 2)
{
counter_Righe1[*sceltaRiga-1]++;
if (counter_Righe1[*sceltaRiga-1]==4)
{
printf("\nE\' l'ultima volta che puoi spostare a destra questa bacchetta");
system("pause");
}
for (i=15,temp = Piano1[*sceltaRiga-1][i]; i>0; i--)
{
Piano1[*sceltaRiga-1][i] = Piano1[*sceltaRiga-1][i-1]; //sposta la riga a destra
}
Piano1[*sceltaRiga-1][i]= temp;
}

mossa=1;
}

void spostaColonna(int Piano2[16][16], int counter_Colonne1[16],int *sceltaColonna,int *sceltaVerso)
{
/****** Sposta colonna verticalmente (piano 2) ******/
int errore1=1;
int errore2=1;
//int sceltaColonna=0;
//int sceltaVerso=0;
int temp=0;
//senso[l]=2;
while (errore1)
{
printf("Inserisci la colonna da spostare(1-2-3-4-5-6-7-8): ");
scanf("%1d",&*sceltaColonna);
if (*sceltaColonna>0 && *sceltaColonna<9)
{
errore1 = 0;
//numerolistello[l]=sceltaColonna;
}
else
printf("Hai sbagliato a digitare, riprova! \n");
}
*sceltaColonna = *sceltaColonna+4;
while (errore2)
{
printf("Vuoi spostare in alto (premi '1') o in basso (premi '2')? ");
scanf("%d",&*sceltaVerso);
if (*sceltaVerso == 1 || *sceltaVerso == 2)
{
errore2 = 0;
//direzione[l]=sceltaVerso;
//l++;
}
else
printf("Hai sbagliato a digitare, riprova! \n");
}
fflush(stdin);
if (*sceltaVerso == 1)
{
counter_Colonne1[*sceltaColonna-1]++;
if (counter_Colonne1[*sceltaColonna-1]==4)
{
printf("\nE\' l'ultima volta che puoi spostare in alto questa bacchetta");
system("pause");
}
for (i=0, temp= Piano2[i][*sceltaColonna-1]; i<15; i++)
{
Piano2[i][*sceltaColonna-1] = Piano2[i+1][*sceltaColonna-1]; //sposta in alto
}
Piano2[i][*sceltaColonna-1]= temp;
}
if (*sceltaVerso == 2)
{
counter_Colonne1[*sceltaColonna-1]--;
if (counter_Colonne1[*sceltaColonna-1]==-4)
{
printf("\nE\' l'ultima volta che puoi spostare in basso questa bacchetta\n");
system("pause");
}
for (i=15, temp=Piano2[i][*sceltaColonna-1]; i>0; i--)
{
Piano2[i][*sceltaColonna-1] = Piano2[i-1][*sceltaColonna-1]; //sposta in basso
}
Piano2[i][*sceltaColonna-1]= temp;
}

mossa=1;
}

void controlloBuchi(int Piano1[16][16], int Piano2[16][16], int Tavolo1[16][16])
{
/* Controllo buchi */
for (i=0; i<16; i++)
{
for (j=0; j<16; j++)
{
if (Piano1[i][j] == 1 && Piano2[i][j] == 1)
{
Tavolo1[i][j]=8;
}
}
}
}

void salvataggioMosse(struct cella **t, char scelta1,char sceltaRiga1,char sceltaLato1,char sceltaColonna1,char sceltaVerso1,int counter1,int Piano1[16][16],int Piano2[16][16])
{
struct cella *nuovoElemento;

nuovoElemento = (struct cella*)malloc(sizeof(struct cella));
if (nuovoElemento == NULL)
{
printf("\n\n Errore nell\'allocazione della memoria.\n Il programma verra\' chiuso!\n ");
system("pause");
exit(1);
}
nuovoElemento->sceltaRigaColonna = scelta1;
nuovoElemento->sceltaRigaS = sceltaRiga1;
nuovoElemento->sceltaLatoS = sceltaLato1;
nuovoElemento->sceltaColonnaS = sceltaColonna1;
nuovoElemento->sceltaVersoS = sceltaVerso1;
nuovoElemento->counterS = counter1;
nuovoElemento->Piano1S = Piano1;
nuovoElemento->Piano2S = Piano2;
nuovoElemento->next = *t;
*t = nuovoElemento;
}

void stampaMosse(struct cella *t)
{
printf("\n");
if (t == NULL)
{
printf(" La pila e\' vuota!\n");
return;
}

do
{
printf(" \nMOSSA NUMERO: %i\n",t->counterS);
printf(" scelta riga o colonna: %c\n",t->sceltaRigaColonna);
if (t->sceltaRigaS !=0) printf(" numero di riga scelto: %i\n",t->sceltaRigaS-4);
else printf(" numero di riga scelto: %i\n",t->sceltaRigaS);
printf(" lato di spostamento scelto: %i\n",t->sceltaLatoS);
if ( t->sceltaColonnaS !=0 ) printf(" numero di colonna scelta: %i\n",t->sceltaColonnaS-4);
else printf(" numero di colonna scelta: %i\n",t->sceltaColonnaS);
printf(" verso di spostamento scelto: %i\n",t->sceltaVersoS);

t = t->next;
} while(t != NULL);
}

struct cella * pop(struct cella **t)
{
struct cella *temp;

if (*t == NULL)
return NULL;
temp = *t;
*t = (*t)->next;
temp->next = NULL;
return temp;
}

void annullaMossa(struct cella **t)
{
struct cella *temp;
temp = pop(t);
if (temp != NULL)
free(temp);

}

[Fenomeno85]

non puoi in c copiare array ;) come se fosse una normale variabile.

~§~ Sempre E Solo Lei ~§~

[::::Dani83::::]

non puoi in c copiare array ;) come se fosse una normale variabile.

~§~ Sempre E Solo Lei ~§~

uhmm.... come posso copiare una matrice in una struttura allora? faccio un ciclo che copia ogni elemento dell'array?

[Fenomeno85]

uhmm.... come posso copiare una matrice in una struttura allora? faccio un ciclo che copia ogni elemento dell'array?

allora il c in questo senso non l'ho mai capito forse qualche guru potrà spiegarmelo .. ma il c ha il "difetto" che non puoi fare un copia di un array per tutto il resto invece si ... esempio anche di strutture contenenti array

Sto vedendo se esiste una funzione del genere oppure con i puntatori se è possibile fare qualcosa. Se erano stringhe so che esiste strcpy

~§~ Sempre E Solo Lei ~§~

[Fenomeno85]

nisba ti tocca fare uso del for oppureint usare http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemarrayclasscopytopic.asp

ma funziona solo sotto windows

~§~ Sempre E Solo Lei ~§~

[andbin]

ahmm.... come si passa una matrice ad una struttura? scusate se stresso ma ho cercato su google e sul manuale che ho ma nn ho trovato nulla :(
se la passo così:
nuovoElemento->Piano1S = Piano1;

mi dice:
error C2440: '=' : cannot convert from 'int [][16]' to 'int [16][16]'
devo passargliela tramite un doppio puntatore? :fagiano:
No, un array non viene passato per valore ad una funzione. Viene passato solo il puntatore al primo elemento dell'array. Quindi Piano1 e Piano2 (i parametri di salvataggioMosse) sono nient'altro che dei puntatori.

Ti posso dare semmai un piccolo suggerimento. Visto che hai molti dati nella struttura cella (e magari ne aggiungerai altri), puoi fare una cosa del genere:
struct daticella
{
...tutti i tuoi dati...
};

struct cella
{
struct daticella dati;
struct cella *next;
};
e alla funzione che inserisce passi un puntatore alla daticella e poi la copi con una memcpy nella cella che hai allocato con malloc.

[::::Dani83::::]

grazie mille, problema risolto grazie a voi :cool:

[river]

è servito pure a me :) :) :)