C++ Dereferenzierung eines void-Zeiger , der Umwandlung von int ptr zu void-ptr

Diese Codezeilen zeigen folgende Fehlermeldung:

int e = 5, * ePtr = &e;
void * vPtr = ePtr; 
cout << *vPtr;

syntax error :

`void*' ist nicht ein Zeiger-auf-Objekt-Typ

Weiß ich:

  1. jedem Zeiger-Typ gespeichert werden kann, in void-pointer-Typ auch ohne expliziten cast
  2. dereferenzieren Versuch der void-Zeiger ist ein syntax-Fehler

aber wenn wir nicht tun, Punkt 2, was ist die Verwendung von Punkt # 1, außer syntaktisch korrekt? Will ich drucken 5 (d.h. e hier) mit vPtr..ist das möglich?

Dieser gut funktioniert:

int e = 5, * ePtr = &e;
void * vPtr = ePtr; //specific to generic Ok!
double * dPtr = (double *)vPtr; //to let compiler know stoarge size
cout << *dPtr; //indirectly it is vPtr i.e. a void ptr, can be deref only if cast
void * verwendet wird, so ziemlich ausschließlich für die Speicherung beliebiger Zeiger, so können Sie werfen es zurück auf die richtige Art und Nutzung. Und es ist viel mehr eine C-Stil der Codierung.
versuchen Sie es mit casting void * vPtr = (void*)ePtr;
Sie suchen backticks: `void *vPtr = (void*)ePtr;`

InformationsquelleAutor ShivaniDhanked | 2013-05-30

  1. 4

    void* können nichts, daher die Zuweisung jedes Zeiger-es ist völlig in Ordnung.

    Sondern weil es verweist auf etwas, Dereferenzierung ist es nicht möglich: Der compiler nicht wissen, welchen Objekttyp es Punkte zu, so ist es nicht in der Lage, code zu erzeugen, zu tun, die richtige je nach den Typ des Objekts.

    InformationsquelleAutor Timbo

  2. 5

    Zur Ehrerbietung eine void* Zeiger, müssen Sie die cast der Zeiger wieder auf einem kompatiblen Typ.

    void* Zeiger werden Häufig verwendet, in C, aber da in C++ können wir tun, überladen von Funktionen und Polymorphismus, Ihre Verwendung ist viel mehr begrenzt.

    Ein gutes Beispiel der Verwendung von void* Zeiger in C sind Funktionen, die die Verwendung von Rückrufen :

    int pthread_create(pthread_t *thread, const pthread_attr_t *attr, 
                   void *(*start_routine) (void *), void *arg);

    Beim Aufruf der pthread_create Funktion, ruft Sie Ihre start_routine zurück.
    In diesem Fall möchten Sie vielleicht einige Daten zu Ihrem start_routine. Da der thread-Bibliothek kann nicht erklären, eine pthread_create-Funktion für jeden Typ können Sie weitergeben wollen, um Sie Rückruf, der void*Typ stattdessen verwendet.

    void myCallBack(void* arg) {
   int* value = (int*)arg;

   /* Do something with value: it is an int* now*/
   printf("Message from callback %d\n", *value);
}


/* Some main function or whatever... */
{ 
  /*  ... */
  int foo = 123;
  ret = pthread_create(&thread, &attr,myCallBack, &foo);

  /*  ... */
}

    InformationsquelleAutor Matthieu Rouget

  3. 3

    Kann man nicht dereferenzieren, weil der compiler nicht weiß, was es ist. Sie haben zu werfen es in einen geeigneten Typ (und der compiler muss annehmen, dass Sie wissen, was Sie tun).

    void * Zeiger sind am besten eingesetzt, wo Sie Schnittstellen mit den Sachen auf einem relativ geringen Niveau (wie I/O-Treiber) wo Sie kümmern sich sehr wenig, was die Daten, die Sie beschäftigen, die Sie gerade wissen, Sie haben einen Puffer und eine Größe.

    Jede andere Verwendung ist mit Gefahren verbunden. Zum Beispiel

    int i = 5;
void *p = &i;
.....
float *f = (float *)p;

    Diese erhalten keine compiler-Fehler oder-Warnungen. Es ist vollkommen gültig. Aber es ist unwahrscheinlich, dass zu tun, was Sie erwarten

    InformationsquelleAutor Tom Tanner

  4. 2

    Kann es nützlich sein, zu speichern, die Zeiger und gleichgültig bleiben, um Ihren Typ. Dies ist, was void* ist. Es ist ein Ansatz, die Sie ergreifen können, wenn die Gestaltung einer storage container (verkettete Liste, hash map) in reinem C.

    Wenn Sie wollten machen verwenden der Zeiger dann würden Sie haben, zu verfolgen, seine Art sowie seinen Wert, da Sie sich nicht beliebig Rücksicht Zeiger, und alle Typinformationen verloren gehen, wenn Sie cast auf void*.

    In deinem Beispiel, könntest du eine einfache Struktur mit einem void* und ein Typ-Feld.

    In C++, die Sie erreichen können, diese Dinge mit polymorphen Strukturen und sogar Vorlagen: was Sie tun, ist weit mehr C-Stil.

    InformationsquelleAutor Bathsheba

  5. 1

    Können Sie nicht drucken e hier mit void* ohne typecasting.
    Ein Zeiger ist nicht nur eine einfache variable, die die Adresse speichern, aber Sie hat eine Art zu, die sagt dem compiler, wie viel Größe sollte es Lesen mit dieser Adresse. Ein void*, da er nicht im Besitz jeglicher Art, können nicht aufgelöst werden, ohne typecasting. Durch typecasting, Sie sagen dem compiler, wie viel bytes er Lesen soll beginnend von der Adresse, die Zeiger trägt.

    void* bietet eine einfache Möglichkeit für Programmierer, um auf einfache Weise speichern und verwenden von Zeigern von den anderen Typen. Wir können nicht unsigned int oder ähnlich zu speichern, den Wert eines Zeigers, da die Größe eines Zeigers ist abhängig vom Prozessor. Auch wir können void* zu machen, die pointer-Argumente/Rückgabewerte von Funktionen mehr Generika.

    raj raj : das ist nicht wahr, machen einen "void * vPtr = (int *)ePtr; cout << *vPtr;" erzeugt den gleichen Fehler. Also einmal für nichtig erklärt Art der Zeiger nie dereferenziert.
    siehe edit, wahrscheinlich meintest du das.danke!
    ich meine, wir können dereferenzieren eine void* nach Typisierung der void* auf seinen eigentlichen Typ.

    InformationsquelleAutor raj raj

  6. 0

    Ich Sache also, die Sie speichern möchten, int Zeiger auf void* - Zeiger.
    In diesem Zustand können Sie eine Warnung erhalten, wie "cast to pointer from integer of different size".Dazu müssen Sie zunächst auf zuweisen von Speicher void-Zeiger mit Bezug zu integer, und verwenden Sie dann das void-Zeiger kann wie folgt,

    void *ptr = malloc(sizeof(int));
*((int*)ptr) = 5;
printf("%d\n",*((int*)ptr));

    InformationsquelleAutor santosh dhanawade

Schreibe einen Kommentar