[C/C++] Differenza liste a puntatori

[bonzox]

#include <stdio.h>   /* per printf */
#include <stdlib.h>  /* per malloc */
 
typedef struct ns {
        int data;
        struct ns *next;
} node;
 
node *list_add(node **p, int i) {
    node *n = malloc(sizeof(node));
    n->next = *p;
    *p = n;
    n->data = i;
    return n;
}
 
void list_remove(node **p) { /* rimuove head */
    if (*p != NULL) {
        node *n = *p;
        *p = (*p)->next;
        free(n);
    }
}
 
node **list_search(node **n, int i) {
    while (*n != NULL) {
        if ((*n)->data == i) {
            return n;
        }
        n = &(*n)->next;
    }
    return NULL;
}
 
void list_print(node *n) {
    if (n == NULL) {
        printf("la lista è vuota\n");
    }
    while (n != NULL) {
        printf("print %p %p %d\n", n, n->next, n->data);
        n = n->next;
    }
}
 
int main(void) {
    node *n = NULL;
 
    list_add(&n, 0); /* lista: 0 */
    list_add(&n, 1); /* lista: 1 0 */
    list_add(&n, 2); /* lista: 2 1 0 */
    list_add(&n, 3); /* lista: 3 2 1 0 */
    list_add(&n, 4); /* lista: 4 3 2 1 0 */
    list_print(n);
    list_remove(&n);            /* rimuove il primo elemento (4) */
    list_remove(&n->next);      /* rimuove il nuovo secondo (2) */
    list_remove(list_search(&n, 1)); /* rimuove la cella che contiene 1 (primo) */
    list_remove(&n->next);      /* rimuove il successivo (0) */
    list_remove(&n);            /* rim
uove l'ultimo (3) */
    list_print(n);
 
    return 0;
} 

Questo codice se lo compilo con gcc va, con g++ no:

[bonzo@wolverine Desktop]$ g++ -c lista.cpp
lista.cpp: In function ‘node* list_add(node**, int)’:
lista.cpp:10: error: invalid conversion from ‘void*’ to ‘node*’
[bonzo@wolverine Desktop]$ gcc -c lista.cpp
lista.cpp: In function ‘node* list_add(node**, int)’:
lista.cpp:10: error: invalid conversion from ‘void*’ to ‘node*’
[bonzo@wolverine Desktop]$ gcc -c lista.c
[bonzo@wolverine Desktop]$


Cos'è che non va?

[shodan]

Risposta veloce (vado di fretta )
Il C++ richiede sempre un cast al tipo di destinazione, mentre il C no.

node *n = malloc(sizeof(node));  // ok per il C, no per il C++

node *n = (node*) malloc(sizeof(node)); // ok per il C++ 

[bonzox]

Grazie mille, mi dovrò studiare un po' questa differenza.

[andbin]

Nel linguaggio "C" esiste una conversione implicita da un puntatore a void (void*) a un puntatore ad altro tipo.