Esiste un uso legittimo di void *?

Esiste un uso legittimo di void*in C ++? O è stato introdotto perché ce l'aveva C?

Solo per ricapitolare i miei pensieri:

Input : Se vogliamo consentire più tipi di input, possiamo sovraccaricare funzioni e metodi, in alternativa possiamo definire una classe base comune o un modello (grazie per averlo menzionato nelle risposte). In entrambi i casi il codice diventa più descrittivo e meno soggetto a errori (a condizione che la classe base sia implementata in modo sano).

Risultato : non riesco a pensare a nessuna situazione in cui preferirei ricevere void*invece di qualcosa derivato da una classe base nota.

Giusto per chiarire cosa intendo: non sto chiedendo specificamente se esiste un caso d'uso per void*, ma se c'è un caso in cui void*è la scelta migliore o l'unica disponibile. A cui hanno risposto perfettamente diverse persone di seguito.

void*è almeno necessario come risultato di ::operator new(anche ogni operator new...) e di malloce come argomento newdell'operatore di posizionamento .

void*può essere pensato come il supertipo comune di ogni tipo di puntatore. Quindi non significa esattamente puntatore a void, ma puntatore a qualsiasi cosa.

A proposito, se si desidera conservare alcuni dati per diverse variabili globali non correlate, è possibile utilizzarne alcuni std::map<void*,int> score; quindi, dopo aver dichiarato global int x;and double y;and std::string s;do score[&x]=1;and score[&y]=2;andscore[&z]=3;

memset vuole un void*indirizzo (i più generici)

Inoltre, i sistemi POSIX hanno dlsym e il suo tipo di ritorno evidentemente dovrebbe esserevoid*

Ci sono diversi motivi per utilizzare void*, i 3 più comuni sono:

1. interagire con una libreria C utilizzando void*nella sua interfaccia
2. cancellazione del tipo
3. che denota la memoria non tipizzata

In ordine inverso, indicare la memoria non tipizzata con void*(3) invece di char*(o varianti) aiuta a prevenire operazioni aritmetiche di puntatori accidentali; ci sono pochissime operazioni disponibili, void*quindi di solito richiede il casting prima di essere utile. E, naturalmente, proprio come conchar* con l'aliasing non ci sono problemi.

La cancellazione del tipo (2) è ancora utilizzata in C ++, in combinazione con i modelli o meno:

• il codice non generico aiuta a ridurre il bloat binario, è utile nei percorsi freddi anche nel codice generico
• Il codice non generico è necessario a volte per l'archiviazione, anche in contenitori generici come std::function

E ovviamente, quando l'interfaccia di cui ti occupi usa void*(1), hai poca scelta.

Oh si. Anche in C ++ a volte usiamo void *piuttosto che template<class T*>perché a volte il codice extra dall'espansione del modello pesa troppo.

Di solito lo userei come implementazione effettiva del tipo e il tipo di modello erediterà da esso e avvolgerà i cast.

Inoltre, devono essere utilizzati gli allocatori slab personalizzati (nuove implementazioni dell'operatore) void *. Questo è uno dei motivi per cui g ++ ha aggiunto un'estensione per consentire l'aritmatica del puntatore void *come se fosse di dimensione 1.

Input: se vogliamo consentire più tipi di input, possiamo sovraccaricare funzioni e metodi

Vero.

in alternativa possiamo definire una classe base comune.

Questo è parzialmente vero: e se non puoi definire una classe base comune, un'interfaccia o simili? Per definirli è necessario avere accesso al codice sorgente, cosa che spesso non è possibile.

Non hai menzionato i modelli. Tuttavia, i modelli non possono aiutarti con il polimorfismo: funzionano con tipi statici, cioè conosciuti in fase di compilazione.

void*può essere considerato come il minimo comune denominatore. In C ++, in genere non lo fai bisogno perché (i) non puoi intrinsecamente farci molto e (ii) ci sono quasi sempre soluzioni migliori.

Inoltre, in genere finirai per convertirlo in altri tipi di cemento. Ecco perché di char *solito è migliore, anche se potrebbe indicare che ti aspetti una stringa in stile C, piuttosto che un puro blocco di dati. Ecco perché void*è meglio di char*quello, perché consente il cast implicito da altri tipi di puntatore.

Dovresti ricevere alcuni dati, lavorarci e produrre un output; per ottenere ciò, devi conoscere i dati con cui stai lavorando, altrimenti hai un problema diverso che non è quello che stavi risolvendo originariamente. Molte lingue non ce l'hanno void*e non hanno problemi con questo, ad esempio.

Un altro uso legittimo

Quando si stampano indirizzi di puntatore con funzioni come printfil puntatore deve avere il void*tipo e, quindi, potrebbe essere necessario un cast a void*

Sì, è utile come qualsiasi altra cosa nella lingua.
Ad esempio, puoi usarlo per cancellare il tipo di una classe che sei in grado di lanciare staticamente al tipo giusto quando necessario, in modo da avere un'interfaccia minimale e flessibile.

In quella risposta c'è un esempio di utilizzo che dovrebbe darti un'idea.
Lo copio e incollo qui sotto per motivi di chiarezza:

class Dispatcher {
    Dispatcher() { }

    template<class C, void(C::*M)() = C::receive>
    static void invoke(void *instance) {
        (static_cast<C*>(instance)->*M)();
    }

public:
    template<class C, void(C::*M)() = &C::receive>
    static Dispatcher create(C *instance) {
        Dispatcher d;
        d.fn = &invoke<C, M>;
        d.instance = instance;
        return d;
    }

    void operator()() {
        (fn)(instance);
    }

private:
    using Fn = void(*)(void *);
    Fn fn;
    void *instance;
};

Ovviamente, questo è solo uno dei tanti usi di void*.

Interfacciamento con una funzione di libreria esterna che restituisce un puntatore. Eccone uno per un'applicazione Ada.

extern "C" { void* ada_function();}

void* m_status_ptr = ada_function();

Questo restituisce un puntatore a qualunque cosa Ada voleva dirti. Non devi farci niente di speciale, puoi restituirlo ad Ada per fare la prossima cosa. In effetti, districare un puntatore Ada in C ++ non è banale.

In breve, C ++ come linguaggio rigoroso (non tenendo conto delle reliquie C come malloc () ) richiede void * poiché non ha un genitore comune di tutti i tipi possibili. A differenza di ObjC, ad esempio, che ha object .

La prima cosa che mi viene in mente (che sospetto sia un caso concreto di un paio delle risposte precedenti) è la capacità di passare un'istanza di oggetto a un threadproc in Windows.

Ho un paio di classi C ++ che devono farlo, hanno implementazioni di thread di lavoro e il parametro LPVOID nell'API CreateThread () ottiene un indirizzo di un'implementazione del metodo statico nella classe in modo che il thread di lavoro possa fare il lavoro con un'istanza specifica della classe. Un semplice cast statico nel threadproc restituisce l'istanza con cui lavorare, consentendo a ogni oggetto istanziato di avere un thread di lavoro da una singola implementazione del metodo statico.

In caso di ereditarietà multipla, se è necessario ottenere un puntatore al primo byte di un blocco di memoria occupato da un oggetto, è possibile dynamic_castfarlo void*.