Perché 'void *' non è implicitamente cast in C ++?

In C, non è necessario eseguire il cast di a void *su qualsiasi altro tipo di puntatore, viene sempre promosso in modo sicuro. Tuttavia, in C ++, non è così. Per esempio,

int *a = malloc(sizeof(int));

funziona in C, ma non in C ++. (Nota: so che non dovresti usare mallocin C ++, o per quello new, e dovresti invece preferire puntatori intelligenti e / o STL; questo è chiesto per pura curiosità) Perché lo standard C ++ non consente questo cast implicito, mentre lo standard C fa?

Poiché le conversioni di tipo implicito non sono in genere sicure e C ++ assume una posizione più sicura rispetto alla digitazione in C.

In genere C consentirà conversioni implicite, anche se la maggior parte delle probabilità è che la conversione sia un errore. Questo perché C presume che il programmatore sappia esattamente cosa stanno facendo e, in caso contrario, è il problema del programmatore, non il problema del compilatore.

Il C ++ di solito non consente le cose che potrebbero essere potenzialmente errori e richiede che tu dichiari esplicitamente la tua intenzione con un cast di tipo. Questo perché C ++ sta cercando di essere facile da programmare.

Potresti chiedere come mai è amichevole quando in realtà ti richiede di digitare di più.

Bene, vedi, ogni data riga di codice, in qualsiasi programma, in qualsiasi linguaggio di programmazione, sarà generalmente letta molte volte più di quanto non sarà scritta (*). Quindi, la facilità di lettura è molto più importante della facilità di scrittura. E durante la lettura, avere conversioni potenzialmente non sicure si distingue per cast di tipo esplicito aiuta a capire cosa sta succedendo e ad avere un certo livello di certezza che ciò che sta accadendo è in realtà ciò che doveva succedere.

Inoltre, l'inconveniente di dover digitare il cast esplicito è banale rispetto all'inconveniente di ore e ore di risoluzione dei problemi per trovare un bug che è stato causato da un incarico errato di cui avresti potuto essere avvisato, ma mai.

(*) Idealmente, verrà scritto una sola volta, ma verrà letto ogni volta che qualcuno deve esaminarlo per determinarne l'idoneità per il riutilizzo e ogni volta che è in corso la risoluzione dei problemi e ogni volta che qualcuno deve aggiungere codice vicino ad esso, e poi ogni volta che c'è la risoluzione dei problemi del codice vicino e così via. Questo è vero in tutti i casi tranne che per gli script "scrivi una volta, esegui, poi butta via", e quindi non sorprende che la maggior parte dei linguaggi di scripting abbia una sintassi che facilita la scrittura con totale disprezzo per facilità di lettura. Hai mai pensato che il perl sia completamente incomprensibile? Non sei solo. Pensa a tali lingue come lingue di "sola scrittura".

Ecco cosa dice Stroustrup :

In C, puoi implicitamente convertire un vuoto * in un T *. Questo non è sicuro

Quindi continua a mostrare un esempio di come il vuoto * possa essere pericoloso e dice:

... Di conseguenza, in C ++, per ottenere un T * da un vuoto * è necessario un cast esplicito. ...

Infine, osserva:

Uno degli usi più comuni di questa conversione non sicura in C è quello di assegnare il risultato di malloc () a un puntatore adatto. Per esempio:

int * p = malloc (sizeof (int));

In C ++, utilizzare il nuovo operatore typesafe:

int * p = new int;

Ne approfondisce molti dettagli in The Design and Evolution of C ++ .

Quindi la risposta si riduce a: il progettista del linguaggio crede che sia un modello non sicuro, e quindi lo ha reso illegale e ha fornito modi alternativi per ottenere ciò per cui il modello era normalmente utilizzato.

In C, non è necessario trasmettere un vuoto * a nessun altro tipo di puntatore, viene sempre promosso in modo sicuro.

È sempre promosso, sì, ma a malapena sicuro .

C ++ disabilita questo comportamento proprio perché tenta di avere un sistema di tipo più sicuro di C e questo comportamento non è sicuro.

Considerare in generale questi 3 approcci per digitare la conversione:

1. costringere l'utente a scrivere tutto, quindi tutte le conversioni sono esplicite
2. supponiamo che l'utente sappia cosa stanno facendo e converta qualsiasi tipo in qualsiasi altro
3. implementare un sistema di tipi completo con generici sicuri (tipi, nuove espressioni), operatori di conversione espliciti definiti dall'utente e forzare conversioni esplicite solo di cose che il compilatore non può vedere sono implicitamente sicure

Bene, 1 è brutto e un ostacolo pratico per fare qualsiasi cosa, ma potrebbe davvero essere usato dove è necessaria grande cura. C ha optato approssimativamente per 2, che è più facile da implementare, e C ++ per 3, che è più difficile da implementare ma più sicuro.

Per definizione, un puntatore vuoto può puntare a qualsiasi cosa. Qualsiasi puntatore può essere convertito in un puntatore vuoto e, quindi, sarai in grado di riconvertirlo arrivando allo stesso identico valore. Tuttavia, i puntatori ad altri tipi possono avere vincoli, come le restrizioni di allineamento. Ad esempio, immagina un'architettura in cui i caratteri possono occupare qualsiasi indirizzo di memoria, ma i numeri interi devono iniziare su limiti di indirizzo pari. In alcune architetture, i puntatori a numeri interi potrebbero persino contare 16, 32 o 64 bit alla volta, in modo che un carattere * possa effettivamente avere un multiplo del valore numerico di int * mentre punta allo stesso posto in memoria. In questo caso, la conversione da un vuoto * in realtà arrotonderebbe i bit che non possono essere recuperati e quindi non sono reversibili.

In parole povere, il puntatore vuoto può puntare a qualsiasi cosa, comprese le cose che altri puntatori potrebbero non essere in grado di indicare. Pertanto, la conversione al puntatore vuoto è sicura ma non viceversa.