void-Zeiger in der Funktion parameter

Betrachten Sie Folgendes Programm:

#include <iostream>
void f(void* a)
{
    std::cout<<"(void*)fun is called\n";
    std::cout<<*(int*)a<<'\n';
}
int main()
{
    int a=9;
    void* b=(int*)&a;
    f(b);
    return 0;
}

Wenn ich die Funktion call-Anweisung wie dieser:

f(&b);

Es noch kompiliert fein & stürzt zur Laufzeit. Warum? Was ist der Grund? Sollte ich nicht die compile-Zeit-Fehler? Da die richtige Art und Weise zum Aufruf der Funktion ist f(b). richtig? Auch, warum es zulässig ist, übergeben Sie den Wert NULL zu einer Funktion, deren parameter vom Typ (void*)?

Bitte korrigieren Sie mich Wenn ich bin fehlt etwas oder verstehen Sie etwas falsch.

Ein Zeiger ein Zeiger ist immer noch ein Zeiger, so ist es akzeptiert, als ein void*.
Sie meinte wohl passieren a's Adresse um das gleiche zu erreichen: f(&a);
Während EdHeals Kommentare sind nicht gerade nett, im Grunde hes Recht. Wenn Sie nicht verstehen, was dieser tut, nicht tun. Sie nicht sogar müssen alle Hinweise hier.

InformationsquelleAutor Destructor | 2015-06-20

  1. 6

    Es noch kompiliert fein & stürzt zur Laufzeit. Warum? Was ist der Grund?

    Weil void* ist eine Technik, für das entfernen aller Typ-Sicherheit und die Typüberprüfung.

    Sollte ich nicht bekommen compile-Zeit-Fehler?

    Mithilfe void* anstelle des richtigen Zeigertyp int* Sie sind ausdrücklich sagen, der compiler nicht zu sagen, Sie wenn Sie mit einer Art falsch oder in einer unbestimmten Weise.

    Weil der richtige Weg zum Aufruf der Funktion ist f(b). richtig?

    Ihre Funktion Erklärung und Inhalt nicht Zustimmen.

        std::cout<<"(void*)fun is called\n";
    std::cout<<*(int*)a<<'\n';

    Den Inhalt oben implizieren, dass ein Zeiger auf int übergeben werden sollte:

    void f(void* a)

    Diese Erklärung impliziert einige Zeiger übergeben werden sollte, und keine weiteren Einschränkungen gemacht werden.

    InformationsquelleAutor Drew Dormann

  2. 2

    void* erfassen können jede Art von Zeiger, es ist keine Ausnahme void**

    Warum stürzt es bei der Laufzeit?
    Sie interpretieren die Adresse von b als int*, aber b selbst ist ein Zeiger, nicht eine int.

    InformationsquelleAutor Xiaotian Pei

  3. 1

    Ok.

    Als angefordert.

    Verwenden Sie keine void-Pointer, es sei denn, Sie können Sie nicht vorstellen, dass es eine andere Möglichkeit um ihn herum.

    - Und die gehen ins Bett und denken Sie wieder.

    Void-Zeiger ermöglicht dem Programmierer, zu vergessen, über die verschiedenen Arten. Dies bedeutet, dass der compile geben kann, auf einfache überprüfungen. Dies auch in meinem Sinn bedeutet, dass der Programmierer hat den Faden verloren.

    Downvote mich, wenn Sie es wünschen.

    Anhand der Typen, die den Luxus haben, dass der compiler überprüfen kann, die Dinge für Sie. E. g. wie die Dinge miteinander verbunden sind. Wie behandeln Sie das Objekt.

    Aber mit einem void-Zeiger Sie sind sehr viel auf Ihrer eigenen. Viel Glück

    InformationsquelleAutor Ed Heal

  4. 1

    Werden Sie nicht bekommen einen compile time error, weil f(&b) Anrufe f und übergibt die Adresse des b als parameter, die dann gegossen in ein void*. Sie erhalten einen Laufzeitfehler, weil Sie dann versuchen, werfen einen Zeiger auf eine Ganzzahl als eine Ganzzahl.
    Aber ja, wie andere gesagt haben, dies zu tun, ein sehr schlechtes.

    InformationsquelleAutor Abhishek Bagchi

  5. 1

    Ersten

    Können Sie eine void* Punkt zu void**. Dein code ist eines der vielen Beispiele, die zeigen, wie gefährlich void* Zeiger werden kann.

    Zweiten

    Sollten Sie für die Typkonvertierung verwenden:

    void* b = static_cast<int*>(&a);

    statt die c-Stil-Konvertierung, die Sie verwenden:

    void*b = (int*)&a;

    InformationsquelleAutor Kieren Pearson

  6. 1

    Wenn ich die Funktion call-Anweisung wie folgt aus:
    f(&b);
    Es noch kompiliert fein & stürzt zur Laufzeit. Warum?

    Ihre Funktion f(void*) akzeptiert einen Zeiger auf einen beliebigen Typ, ohne Beanstandung. Alle Zeiger still konvertiert in einen void-Zeiger. Ein Zeiger auf einen Zeiger ist immer noch ein Zeiger. Damit Ihre zweite Fall tatsächlich kompilieren einwandfrei. Und dann stürzt es ab. Vielleicht.

    Im ersten Fall, Sie konvertiert einen Zeiger auf int Zeiger auf void zurück, um einen Zeiger auf int. Diese round-trip Konvertierungen durch void* (und auch durch char*) arbeiten müssen. Im zweiten Fall, Sie in einem void** zu einem void* zu einem int*. Jetzt bist du aufrufen zu undefiniertem Verhalten. Geht alles. Auf meinem computer, mein compiler, der code läuft einfach gut. Es druckt Müll. Ich war ziemlich sicher, dass der code würde nicht löschen, meine Festplatte, aber es könnte. Alles geht mit undefinierten Verhalten. Nicht aufrufen Undefiniertes Verhalten.

    Den Grund für die Unterstützung void* ist historisch. Es gibt eine Menge von alten C-und C++ - code verwenden, void-Pointer. Die nur Grund zu schreiben, neue C++ - code, der nutzt void-Zeiger ist, wenn Sie benötigen, um die Interaktion mit einem dieser alten Funktionen verwenden, void-Pointer.

    InformationsquelleAutor David Hammen

  7. 0

    Fand ich mich hier, weil ich arbeite gerade an einer Hausaufgabe, die Anfragen, die die gleiche Funktionalität. Nachdem die Kombination jeder Kommentar, das ist, was ich kam mit. 

    //A function that accepts a void pointer
void f(void* a)
{
    std::cout<<"(void*)fun is called\n";
    std::cout<< "value for a: " << *(int*)a << '\n';
}


int main() {
    int a = 9;
    void* c = static_cast<int*>(&a);

    int b = 3;
    f(&b);
    f(c);
}
    Compiler nie Abstürzen zur Laufzeit 🙂

    InformationsquelleAutor Laura

Schreibe einen Kommentar