Salve a tutti ragazzi ho avuto questo compito a scuola la simulazione dello stack di un microprocessore utilizzando le liste ho creato il programma riscontrando i seguenti errori:
codice:
In function `InserisciNodo': 
 [Warning] assignment from incompatible pointer type 
In function `EstraiNodo': 
 [Warning] assignment from incompatible pointer type
in più mi ritrovo che quando stampo la lista un loop del messaggio che ho dato per la stampa
riuscite a darmi una mano ?
un ringraziamento in anticipo

Codice programma:
codice:
/***********************************************************************************
Autore: Capuano Nicola
Data:05/05/2011
Titolo: Simulazione dello STACK
Descrizione:Questo programma simulera uno stack attraverso le liste
            Ogni Nodo sarà l'elemento dello stack, verrà inserito 
            ogni volta in testa alla lista seguendo l'ordine LIFO (Last in Firt Out)
            cioè quando noi inseriamo un elemento l'elemento sarà sempre in cima alla
            pila e sarà l'ultimo elemento che andremmo ad estrarre.
------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <windows.h>     /* API di windows */
/***************************************************************************************
La struttura e composta da un solo campo d'informazione e un puntatore che punta al 
nodo successivo.
--------------------------------------------------------------------------------------*/
typedef struct Nodo
{
 		  char Numero[200];
 		  struct nodo* Successivo;
}NODO;
/*-----------------------------------------------------------------------------------*/

#define ESC 27

void    Clrscr    (void);
void    Gotoxy    (int x, int y);
void    TextColor (unsigned short Colore);
void    Maschera  (char *Titolo);
void    LeggiStringa(char Buf[],int Max);
NODO* InserisciNodo (NODO* Testa);
NODO* EstraiNodo(NODO* Testa);
void StampaStack(NODO* Head);


/************************************************************************************
Il main e composto unicamente dal menu formato da uno swtich che chiamerà delle 
subroutine che inseriranno e estrarrano i nodi dalla lista 
--------------------------------------------------------------------------------------*/
main()
{
    /***************************
    Dichiriamo il nodo di testa
    che indica la posizione del
    primo elemento nella lista
    --------------------------*/
	 NODO* Testa;
    /*******************************
    La variabile "Tasto" verrà
    utilizzata per interagire
    nel menu utilizzando la
    funzione _getch() che legge 
    il tasto battuto sulla tastiera
    ------------------------------*/
    int Tasto;
    
    do
    {
	    Maschera("Simulazione Dello Stack");
		 /**********************************************
	     Il menu e composto da 3 casi dello switch
	     Inserisci , Estrai, Stampa 
	     per utilizzare questi tre casi 
	     lo switch analizzera la variabile tasto
	     in cui attraverso _getch() abbiamo inserito 
	     il valore ascii del tasto battuto sulla tastiera
	     I=Inserisci
	     S=Stampa
	     E=Estrai
	     per guanto riguarda la grafica del menu, e gestita
	     da una subroutine.
	    -------------------------------------------------*/
		 Tasto=_getch();
		 switch(Tasto)
		 {	
		  	case 'i': Testa=InserisciNodo(Testa);
		  	          break;
         case 's': StampaStack(Testa); 
                   break;
         case 'e': Testa=EstraiNodo(Testa);
                   break;
		 }
	 }while(Tasto!=ESC);
	 /************************************************
	 alla fine liberiamo i nodi che magari non 
	 sono stati estratti durante l'uso del programma
	 ----------------------------------------------*/
	 
}
/***************************************************************************************
FUNZIONI: INSERISCI,STAMPA,ESTRAI UN ELEMENTO DALLA LISTA
----------------------------------------------------------------------------------------*/

/*****************************************************************************************
INSERISCI:
			 Input: Puntatore di testa
			 Output: Nuovo puntatore di testa e nodo inserito nella lista
			 Descrizione: Il nodo verra inserito in testa alla lista per simulare 
			              il modo in cui vengono inserite le informazioni nello stack
---------------------------------------------------------------------------------------*/
NODO* InserisciNodo (NODO* Testa)
{ 
  		char Rigo[200],NuovoNumero;
  		NODO* NuovoNodo;/*Nuovo Nodo*/
      NuovoNodo=(NODO*)malloc(sizeof(NODO));/*Allochiamo Memoria nella heap*/
      printf("\n Inserisci L'elemento nello Stack: ");
		LeggiStringa(Rigo,200);
      strcpy(NuovoNodo->Numero,Rigo);
      NuovoNodo->Successivo=Testa;
      Testa=NuovoNodo;
    return Testa;
}
/***************************************************************************************
STAMPASTACK:
				input: Puntatore di testa
				Output: Stampa sul video della lista
				Descrizione: La subroutine stampera semplicemente sul video gli elementi
				             della lista.
-----------------------------------------------------------------------------------------*/
void StampaStack(NODO* Testa)
{
 	  NODO* NuovoNodo;
 	  NuovoNodo=Testa;
	  while(NuovoNodo != NULL)
	  {
	  	  printf("\nElemento in lista: ",NuovoNodo->Numero);
			NuovoNodo->Successivo;
     }
}
/******************************************************************************************
ESTRAINODO:
			  Input: Puntatore di testa
			  output: Lista vuota
			  Descrizione: Questa subroutine ha il compito di estrarre dall'ultimo nodo in poi
			                gli elementi della lista simulando l'estrazione da uno stack
								 cioè l'ultimo elemento inserito sarà il primo eliminato.
------------------------------------------------------------------------------------------*/
NODO* EstraiNodo(NODO* Testa)
{
 		NODO* NuovoNodo;
		NuovoNodo=Testa;
		Testa=NuovoNodo->Successivo; 
		free(NuovoNodo);
  return Testa;
}  
/***************************************************************************************
FUNZIONI DI INPUT E OUTPUT
***************************************************************************************/


/**************************************************************************************
LEGGI STRINGA
***************************************************************************************/
void LeggiStringa (char Buf[], int Max)
{
   int i;

   fgets(Buf, Max, stdin);
   fflush(stdin);
   for (i=0; Buf[i]<0 || Buf[i]>31; i++);
   Buf[i] = 0;
}


/*************************************************************************************
  Crea una maschera standard per il software:
  Il titolo e' centrato in un rigo di 80 caratteri.
**************************************************************************************/
void Maschera
(	char *Titolo
)
{	char Rigo[96];                                  // multiplo anche di 16
    int  d, i, n;

	if ( (n=strlen(Titolo)) > 78) n = 78;           // tronca il titolo lungo
	sprintf (Rigo,  "%80s", " ");
	for (d=(80-n)/2, i=0; i<n ; Rigo[d++]=Titolo[i++]);

	Clrscr(); Gotoxy(0, 0); TextColor (0xC0); printf(Rigo);
	sprintf (Rigo, "%60s%s", " ", "Capuano Nicola       ");
	Gotoxy(0,24); TextColor (0xC0); printf(Rigo);
	Gotoxy(0, 0); TextColor (7);
}


/*****************************************************************************
  Cancella lo schermo.
******************************************************************************/
void Clrscr (void)
{
	COORD coord;
	DWORD written;
	CONSOLE_SCREEN_BUFFER_INFO info;

	coord.X = 0;
	coord.Y = 0;
	GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
	FillConsoleOutputCharacter (GetStdHandle(STD_OUTPUT_HANDLE), ' ',
					  info.dwSize.X * info.dwSize.Y, coord, &written);
	Gotoxy (1, 1);
}


/*****************************************************************************
  Posiziona il cursore di console alle coordinate x,y.
******************************************************************************/
void Gotoxy
(   int x,         // indice di colonna
	int y          // indice di riga
)
{	COORD Cur = {x, y};
	SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), Cur);
}




/*****************************************************************************
 Utilizzando la funzione SetConsoleTextAttribute(HANDLE,WORD)
 cambia il colore del testo da stampare in console.
******************************************************************************/
void TextColor
(	unsigned short Colore    // codice numerico del colore
)
{	HANDLE h = GetStdHandle ( STD_OUTPUT_HANDLE );
	SetConsoleTextAttribute ( h, Colore );
}
/*****************************************************************************
MENU
******************************************************************************/