Vergleich der Werte zeigte auf die von void-Zeigern in C

Muss ich vergleichen die Werte von zwei void Zeigern in C. Im folgenden code, ich bin immer in der Konsole ausdrucken, dass Sie anders sind. Es scheint, dass der Vergleich zwischen den Adressen, die in diesen zwei void Zeiger.

Wie kann ich es so machen, dass der code vergleicht Werte (sprich: 1 == 1) der void Zeiger und druckt "same"?

int main(void)
{
    int i = 1;
    int j = 1;
    void *pi = &i;
    void *pj = &j;
    if (pi == pj) {
        printf("same.\n");
    } else {
        printf("different.\n");
    }
    return 0;
}
  • Sie haben keine void-Zeiger haben, dann haben Sie int Zeiger dann *pi == *pj. Aber während dessen ein void-Zeiger, es ist NUR ein Zeiger, sehr schlechte Praxis, um dann zu versuchen und vergleichen, was ist am spitz
  • verwenden memcmp E. g. if(memcmp(pi, pj, sizeof(int))==0){
  • Um genauer zu sein, ich bin zu versuchen, eine verknüpfte Liste, wo die Knoten speichern generische leere Werte. Und in der delete-Methode, würde ich wollen, eine void-Element, das verglichen wird mit den Werten in der verlinkten Liste gelöscht werden. Aber wenn ich versuchte, Sie zu vergleichen, die zwei void-Pointer, obwohl die Werte, die Sie zeigen, sind die gleichen, der Vergleich false zurück. Also, ich Frage mich, ob es einen Weg gibt, zu vergleichen Sie die Werte der Zeiger?
  • Es ist nicht möglich Werte zu vergleichen zeigte void * Zeiger ohne expilcitly sagen dem compiler, wie Sie zu vergleichen. Der compiler weiß es nicht. Nur Sie wissen, wie zu tun. Im einfachsten Fall müssen Sie dem compiler, welche Arten diese Werte mit der Angabe des genauen Typs in der Besetzung. Alternativ können Sie die delete Methode mit dem generischen Vergleich-Funktion (die Sie liefern), nur wie es gemacht wird mit der standard - bsearch oder qsort Funktionen.
InformationsquelleAutor Jie | 2014-09-10
  1. 3

    Müssen Sie wissen, welche Art von Daten die void Zeiger wirklich zeigen sich bei, zwingen Sie den Zeiger zum Punkt zu geben, und dann dereferenzieren der aufgezwungenen Zeiger (und davon ausgehen, dass die Typen, die vergleichbar sind mit ==):

    if (*(int *)pi == *(int *)pj)
    printf("same.\n");
else
    printf("different.\n");

    Es ist viel einfacher, nur zu vergleichen mit den original-Variablen:

    if (i == j)
    …

    oder richtig verwenden typisierte Zeiger:

    int *pi = &i;
int *pj = &j;
if (*pi == *pj)
    …

    Was in dem Fall passiert, dass ich nicht wissen, die Art der Daten (unter der Annahme, dass ein Benutzer immer an der selben Art von Daten werden im Vergleich mit meiner verlinkten Liste löschen-Methode)?

    Dann wird das Leben schwierig. Im Idealfall bekommen Sie den Programmierer übergeben Sie eine Komparator-Funktion — sehen bsearch() und
    qsort() aus der Standard-C-Bibliothek für die Beispiele.

    Gelingt das nicht, müssen Sie wissen, die Größe der Ziel-Typ, und Sie hoffen, dass memcmp() wird die Arbeit ausreichend gut. Das ist bei weitem nicht gewährleistet — es ist nicht klar, dass der Vergleich von zwei double Werte mit memcmp() produziert immer die richtige Antwort (es kann behauptet werden unterschiedliche Darstellungen von NaN sind anders, zum Beispiel), und vergleichen struct Typen mit Polsterung behaftet ist, und es wäre nicht korrekt, für deine Link-Liste Datentyp, wenn Sie übergeben der Knoten (es wäre OK, wenn Sie übergeben die Daten-Felder aus den beiden Knoten).

    Wenn Sie benötigt, um die Bestellung eher als nur Gleichheit (ein binärer Suchbaum, zum Beispiel), dann ist die situation noch schlimmer ist — in diesem Fall erfordert die Programmierer, um die Versorgung der Komparator-Funktion.

    • Was passiert in dem Fall, dass ich nicht wissen, die Art der Daten (unter der Annahme, dass ein Benutzer immer an der selben Art von Daten werden im Vergleich mit meiner verlinkten Liste löschen-Methode.)?
    InformationsquelleAutor Jonathan Leffler
  2. 2

    Den Zeiger sind anders. Wenn Sie versuchen, zu vergleichen mit den ganzen zahlen die Zeiger zeigen auf, dann wollen Sie

        if ( *(int*)pi == *(int*)pj ) {
    InformationsquelleAutor Gene
  3. 1

    u Typ cast der void-Zeiger auf Typ int*

    da der compiler nicht weiß, welche Art der Adresse, die der Zeiger gerichtet ist, die es nicht wissen, wie viele bytes zu Lesen, von der pointer-Adresse ein und vergleichen Sie. versuchen Sie, diese

        int i = 2;
    int j = 1;
    void *pi = &i;
    void *pj = &j;
    if ( (*(int*)(pi)) == (*(int*)(pj)) ) 
    {
        printf("same.\n");
    } else 
    {
        printf("different.\n");
    }
    return 0;
    • Dann ist es unmöglich zu vergleichen, die zwei Zeiger (vorausgesetzt Sie sind vom gleichen Typ, aber Sie wissen nicht, welche Art, und kann somit nicht wirken in Ihren jeweiligen Arten)?
    • wie kann man nicht wissen, welche Art der Zeiger ist.. der Codierung des Programms. als Jonathan darauf hingewiesen, wenn u müssen nur ein Zeiger, den Sie nicht benötigen, mit dem void Typ ist, beginnen Sie einfach mit dem Typ (int*). aber wenn u wollen, zu halten, ändern Sie den Typ des Zeigers zum zeigen auf unterschiedliche Werte dann u müssen explizit Typumwandlung es jedesmal beim vergleichen.
    InformationsquelleAutor Haris
  4. 1

    Aus Ihren Kommentaren, Sie sind tryng zu implementieren Sie eine verkettete Liste und nicht wissen, die Daten, die Art der Ziele von Zeigern. Dein design ist falsch: mit void* pointersyou einfach nicht (angemessen oder sicher) vergleichen Sie die Daten ohne wissen der Typ. Sie müssen es anders Herangehen. Der beste Ansatz ist die Implementierung der verketteten Liste als template-Klasse. Ihre Knoten-Klasse Aussehen wird, so etwas wie

    template <typename T> class Node
{
    private:
        T *m_pValue;
        Node *m_prev;
        Node *m_next;
    ...
}

    Aber bewusst sein, dass Sie müssen sehr vorsichtig sein, der Speicher-management. Sie müssen entscheiden, wer gehen Besitz und Verwaltung der Objekte. In der Klasse oben, muss der Benutzer die Verwaltung der Objekte, die sich vollständig. Wenn Sie möchten, entlasten den Benutzer von dieser Belastung, Verwendung autopointers, so dass Ihre Knoten zu so etwas wie

    template <typename T> class Node
{
    private:
        std::auto_ptr<T> m_pValue;
        Node *m_prev;
        Node *m_next;
    ...
}

    In beiden Fällen können Sie Werte vergleichen, die über

    Node rhs, lhs;
*(lhs.m_pValue) == *(rhs.m_pValue);

    und diesem einfach vermutet, dass der Typ T kann im Vergleich per ==, die erfüllt sein soll, in den meisten Fällen.

    Beachten Sie, dass die Vorschläge der Verwendung von Speicher, vergleichen und dergleichen sind nur gefährlich, solche Vergleiche völlig ignorieren die Struktur und symantics der zugrunde liegenden Daten geben.

    OK, da dies muss in C, machen Sie Ihre Knoten wie

    struct node
{
    void * m_pValue;
    node * m_pPrev;
    node * m_pNext;
}

    und erfordern, dass der Benutzer des linked-Liste muss man mit einem Zeiger auf eine comparitor Funktion

    int (comparitor*)(void* lhs, void* rhs);

    das ist genau das, was Jonathan Leffler unten vorgeschlagen. Genau wie die Struktur alles hängt davon ab, wie Ihr Strukturierung deiner verlinkten Liste.

    • Vielen Dank für die Anregungen, die in c++ aber! Allerdings würde ich brauchen, um dies zu implementieren in c.
    • Woops! Verpasste das kleine Problem... natürlich, dass ist der Grund, warum C++ erstellt wurde nehme ich an, aufgrund von Problemen wie diesem.
    InformationsquelleAutor David I. McIntosh
Schreibe einen Kommentar