invalid conversion from 'void*' to 'pNodo {aka nodo*}' [-fpermissive]

[Zir]

Hola a todos, ojala pudieran ayudarme, estoy atorado en un programa de c++, mi compilador es devc++, gracias por su ayuda, les dejo el codigo:

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


struct nodo{
int dato;
struct nodo *siguiente;
};

typedef struct nodo Nodo;
typedef Nodo *pNodo;

void insertar(pNodo *nodoRaiz, int valor);
int eliminar(pNodo *nodoRaiz, int valor);
int estaVacia(pNodo nodoRaiz);
void imprimeLista(pNodo nodoActual);
void instrucciones (void);
void ordenar(pNodo *nodoRaiz);

int main () {
pNodo nodoInicial = NULL;
int op;
int elemento;
instrucciones();
printf("?");
scanf("%d", &op);
while (op != 4){
switch(op){
case 1:
printf("Valor del nodo: ");
scanf("\n%d",&elemento);
insertar(&nodoInicial,elemento);
imprimeLista(nodoInicial);
break;
case 2:
if(!estaVacia(nodoInicial)){
printf("Valor a eliminar: ");
scanf("\n%d",&elemento);

if(eliminar(&nodoInicial,elemento)){
printf("Valor %d eliminado.\n",elemento);
imprimeLista(nodoInicial);
}else{
printf("No se encuentra el elemento %d.\n\n",elemento);
}
}else{
printf("La lista esta vacia.\n\n");
}
break;
case 3:
ordenar(&nodoInicial);
imprimeLista(nodoInicial);
break;
default:
printf("Opción no válida.\n\n");
instrucciones();
break;
}
printf("? ");
scanf("%d",&op);
}
printf("Fin del programa");
return 0;
}

void instrucciones(void){
printf("Seleccione una opción:\n"
"1.- Insertar un elemento\n"
"2.- Eliminar un elemento\n"
"3.- Ordenar\n"
"4.- Salir\n");
}

void insertar(pNodo *nodoRaiz, int valor){
pNodo nodoNuevo;
pNodo nodoAnterior;
pNodo nodoActual;

nodoNuevo = malloc(sizeof(Nodo)); ////////////////ERRRORRR

if(nodoNuevo != NULL){
nodoNuevo -> dato = valor;
nodoNuevo -> siguiente = NULL;

nodoAnterior = NULL;
nodoActual = *nodoRaiz;

//while(nodoActual != NULL && valor > nodoActual->dato){
while(nodoActual != NULL){
nodoAnterior = nodoActual;
nodoActual = nodoActual -> siguiente;
}

if(nodoAnterior == NULL){
nodoNuevo -> siguiente = *nodoRaiz;
*nodoRaiz = nodoNuevo;
}else{
nodoAnterior -> siguiente = nodoNuevo;
nodoNuevo -> siguiente = nodoActual;
}
}else{
printf("No se inserto %d. No hay memoria disponible.\n",valor);
}
}

int eliminar(pNodo *nodoRaiz, int valor){
pNodo nodoAnterior;
pNodo nodoActual;
pNodo temp;

if(valor == (*nodoRaiz) -> dato){
temp = *nodoRaiz;
*nodoRaiz = (*nodoRaiz) -> siguiente;
free(temp);
return valor;
}else{
nodoAnterior = *nodoRaiz;
nodoActual = (*nodoRaiz) -> siguiente;
while(nodoActual != NULL && nodoActual -> dato != valor){
nodoAnterior = nodoActual;
nodoActual = nodoActual -> siguiente;
}

if(nodoActual != NULL){
temp = nodoActual;
nodoAnterior -> siguiente = nodoActual -> siguiente;
free(temp);
return valor;
}
}

return 0;
}

int estaVacia(pNodo nodoRaiz){
return nodoRaiz == NULL;
}

void imprimeLista(pNodo nodoActual){
if(nodoActual == NULL){
printf("La lista esta vacia");
}else{
printf("La lista es:\n");

while (nodoActual != NULL){
printf("%d -> ",nodoActual -> dato);
nodoActual = nodoActual -> siguiente;
}
printf("NULL\n\n");
}
}

void ordenar(pNodo *nodoRaiz){
pNodo actual;
int aux;
int cambio = 1;

while(cambio)
{
cambio = 0;
actual = *nodoRaiz;
while(actual->siguiente != NULL)
{
if(actual -> dato > actual -> siguiente ->dato)
{
aux = actual -> dato;
actual -> dato = actual -> siguiente ->dato;
actual -> siguiente -> dato = aux;
cambio = 0;
}
actual = actual -> siguiente;
}
}
}

Aquí una imagen:

[dehm]

Estas usando mal la función malloc();

Prueba así:

Código C++:

nodoNuevo = (pNodo)malloc(sizeof(Nodo)); ////////////////ERRRORRR
 

http://www.cplusplus.com/reference/cstdlib/malloc/

Y un consejo, cuando pegues código etiquétalo en forma C++, para que quede más legible (en el desplegable donde pone "Highlight")

Saludos

[Zir]

Genial gracias!! no comprendo todavia esos detalles...

[vangodp]

eso es que malloc devuelve un puntero genérico a void.
En una explicacion algo más entendible:

Código C:

#include <stdio.h>
#include <stdlib.h>
 
struct nodo{
int dato;
struct nodo *siguiente;
}n;
 
int main (){
    //nodo nuevo junto con malloc ahora no chilla ya que devuelve es un puntero a void, pues lo guardamos en un puntero de tipo void como debe de ser =D
    void* nodoNuevo = malloc( sizeof(n) ); 
    
    nodo* pNodo;  // <- ¿Pero quieres guardarlo aquí no? XD
    
    //¡solución! Cast de nuevo nodo que es del tipo void* a pNodo que es un puntero a nodo*. =DD
    pNodo = ( nodo* ) nodoNuevo; 
    
    //ahora pNodo ya guarda la dirección de lo que tu quieres. Es más o menos lo que 
    //hace nodoNuevo = (pNodo)malloc(sizeof(Nodo)); tal como te lo dijo dehm
    pNodo->dato = 10;
    
    
    printf("%d\n",pNodo->dato );
    
    free(nodoNuevo);
    getchar();
    return 0;
}
 

Todo lo de arriba hace en una sola linea: nodo* pNodo; = ( nodo* )malloc( sizeof(n) );
Creo que ahora ya sabes que ocurre y por que te da error. El error te da por que malloc no es advino.. No puede saber el tipo de puntero que debe retornar, eso lo tienes que indicar tu haciendo un cast al tipo que necesites. ;)