Casting von int nach void-Zeiger

Guten Tag,
Ich habe gerade angefangen zu lernen, void-Zeiger in c++ und jetzt Schreibe ich binären Baum, wo ein Wert gespeichert, jeder Knoten ist void-Zeiger auf einen Wert.

struct TreeNode
{
    int count;
    void* data;
    TreeNode *left;
    TreeNode *right;
    };

Das problem trat im ersten Verfahren-add-Methode.
meine Methode nimmt jetzt ein int parameter und nichts zurückgeben
Habe ich ganz am Anfang erstellen Sie neue Knoten.
Dafür müsste ich mir den cast von integer in die leere.
Programm compiliert und erstes element fügt root richtig-aber wenn ich dann senden Sie eine andere Nummer zu Methode speichert diese im root wieder.
also, wenn Sie in der main habe ich so etwas wie
Baum.addToTree(12);
Baum.addToTree(13);
als würde es speichern, 12 erste und als direkt nach der else-Anweisung(code unten), wie das root->Daten i 13.

void Tree::addToTree(int num)
{
    if(root==NULL){
        root= new TreeNode();
        root->data=#
        //((int *)(root->data)) = num;//i tried to convert to void* in this way but it give me segmentation fault
        root->left=NULL;
        root->right=NULL;
    }
    else{
        //here root value is already changed
        int *intPtr = static_cast<int*>(root->data);
        cout << "key2" << *intPtrT << endl;
        //TreeNode* current= insert(num,root);
    }
}

wie ich verstanden habe das ist weil ich benutze &num so meine parameter immer Riss in einem Ort und einer Wurzel "verbunden" zu &num es zu ändern, wie gut.

Ich habe versucht, Lösungen zu finden, aber war erfolglos.
Gibt es eine Möglichkeit, cat int, void-pointer?

  • Sie sind nicht Gießen Sie den Zeiger auf void in int. Sie Gießen es auf einen Zeiger auf int.
  • ((int *)(root->data)) = num kann nicht kompilieren. Müsste ((int *)(root->data)) = &num oder *((int *)(root->data)) = num. Welche war es?
  • Danke allen für Ihre Antwort.Sie waren sehr hilfreich.Ich habe "new int(num)"-es funktioniert. Zu der Vorlage haben-das wäre effizienter für sicher, aber ich bin ein student jetzt und meine Aufgabe klar brauchen wir leere ,die ich nicht sehr angemessen,wie ich schon sagte)
InformationsquelleAutor aldebaran | 2013-11-06
  1. 1

    Erste von allen, es gibt sehr sehr wenige Gründe, Sie zu speichern etwas wie eine void* statt über eine stark typisierte Methode (z.B. template). Ihre gesamte problem verschwindet ziemlich schnell, wenn Sie den code ändern, um

    template<typename T>
TreeNode
{
    TreeNode<T>* left;
    TreeNode<T>* right;
    T data;
};

    Sagte, das problem, das Sie haben ist, dass Sie speichern die Adresse einer kopieren, die gehen Weg, sobald die Funktion geht out of scope:

    if(root==NULL)
{
    root= new TreeNode();
    root->data=&num; //PROBLEM!!!
    root->left=NULL;
    root->right=NULL;
}

    Das problem der Linie sein sollte:

    root->data = new int(num);

    Und Sie müssen ordnungsgemäß löschen Sie den Speicher, wenn Sie fertig sind (z.B. wenn Ihre Struktur wird zerstört).

    Alternativ, wenn Sie geschehen, werden auf einem system, wo sizeof(void*) == sizeof(int) können Sie dies tun,

    root->data = (void*)num;

    Einfach behandeln die void* Mitglied als integer. Dies funktioniert nicht auf Systemen, auf denen int ist größer als void*.

    InformationsquelleAutor Zac Howland
  2. 1

    Zunächst sollten Sie entscheiden, ob Sie möchten, um Daten zu speichern, durch einen Wert oder einen Zeiger darauf.

    Im ersten Fall, dass ein Zeiger nur nutzlos, Sie könnte verwenden Sie eine Vorlage, wie:

    template <typename T>
struct TreeNode
{
  T data;
  ..
}

TreeNode<int> node;

    Dies funktioniert auch mit Zeigern (wie T *data ... data = new int()).

    In Fall, dass Sie wollen, um zu speichern einen Zeiger auf Daten können Sie auch eine Vorlage verwenden, die mit einem Typ-parameter, oder verwenden Sie einen gemeinsamen Vorfahren-Klasse und dann zu Unterklasse mit den erforderlichen Typen, zB:

    class TreeData {

}

class TreeDataInt {
  int value;
}    

struct TreeNode
{
  TreeData *data;
  ..
}

    Schließlich storying eine int innerhalb einer void* Zeiger ist etwas, was nicht so gefördert, mit void* in C++ zu erreichen Polymorphismus wird davon abgeraten im Allgemeinen, da Sie noch viele andere tools, die sind sicherer und zuverlässiger.

    Wenn Sie wirklich wollen, zu speichern int innerhalb einer void* dann sollten Sie das intptr_t Typ ist eine ganze Zahl, die umwandelbar in einen Zeiger. Eg:

    #include <cstdint>

intptr_t value = 50;
node->data = static_cast<void*>(value);
intptr_t value2 = static_cast<intptr_t>(node->data);

    Diese speichern den Wert der integer-direkt als Adresse in die void*. Dies bedeutet, dass man nicht dereferenzieren Sie den Zeiger selbst.

    Übrigens root->data=&num ist falsch, da Sie die Zuordnung zu data die Adresse eine automatische zugewiesene variable wird ungültig, wenn man Sie verlässt Ihren Anwendungsbereich.

    InformationsquelleAutor Jack
  3. 1

    Ein problem, das ich sehe, ist nicht die Antwort, nur ein problem)... in der Funktion

    void Tree::addToTree(int num)
{

   if(root==NULL){
       root= new TreeNode();
       root->data=&num;

    Zuweisung der Adresse eines automatische variable data. Das Problem ist, dass, sobald die Funktion beendet wird, wird diese variable nicht mehr vorhanden (es wird gesagt, um Gültigkeitsbereich) und so Sie haben, was ist bekannt als eine baumelnden Zeiger, d.h. ein Zeiger verweist auf einen Speicherbereich, der nicht mehr verwendet oder nicht mehr für den ursprünglichen Zweck, dass der Zeiger erwartet.

    Du dieses Problem beheben könnte an drei stellen.

    1. Wenn Sie nur speichern wollen, ints oder irgendwelche Daten geben, deren Breite le, daß sizeof(void *), Sie könnte tun root->data = (void *)num (Hinweis: ich werfe die Wert der Variablen auf einen void* und nicht die Adresse der Variablen). Oder Sie könnte, wie ich das sehe, Zac hat vorgeschlagen, auch
    2. Erstellen Sie eine kopieren der Variablen und speichern der Kopien-Adresse. root->data = new int(num);. In diesem Fall müssen Sie sicherstellen, dass delete den Speicher, wenn der Baum zu zerstören
    3. Vorlagen verwenden, wie andere vorgeschlagen haben (dies ist der bessere Weg) - ich lasse diesen Punkt als andere haben bedeckt es.

    Den anderen etwas von dir Frage wo hast du den Kommentar 

    //((int *)(root->data)) = num;//i tried to convert to void* in this way but it give me segmentation fault

    Der Grund, warum das fehlschlägt, weil root->data an dieser Stelle nur einen Zeiger... es nicht überall (sinnvoll) noch. So, wenn Sie versuchen, Sie zu dereferenzieren es, Sie versuchen, Zugriff auf einige Speicher, bedeutet "existieren" noch (entweder pointer ist NULL oder hat eine ungültige Adresse), und so werden Sie seg fault.

    Wenn ein pointer auf diese Weise müssen Sie erstellen von Speicher und stellen Sie dann die Zeiger zeigen auf, dass der Speicher, z.B. root->data = new int;. Sobald Sie das getan haben, können Sie dann einen Wert zuweisen, die Position im Speicher, z.B. *(root->data) = 1234;

    InformationsquelleAutor Jimbo
Schreibe einen Kommentar