4. Integerwerte über Pointer an Integervariable zuweisen.

Integerwerte über Pointer an Integervariable zuweisen.

  • D

    O.K.,

    aber wirklich nur ein klein wenig 😃 Will ja schliesslich nicht, daß jemand von meinem genialen Brain partizipiert *LOL* (kleiner Scherz am Rande)

    Hier ist die Routine, die dem Baum Nodes zuweist:

    void __fastcall Tappoptionen::comserversClick(TObject *Sender)
{
if (comservers->FocusedNode)
        {
        server->SaveEvents();
        }

TServer* data;
TVirtualNode* node;
TVirtualNode* mnode;
TVirtualNode* mmethod;
TVirtualNode* setting;
TServermodule* module;
TPropertyData* nodedata;

TRegistry* regeintraege = new TRegistry(KEY_ALL_ACCESS);

servermodules->NodeDataSize = sizeof(TPropertyData);

node = comservers->FocusedNode;
data = (TServer*)comservers->GetNodeData(node);

if (!node) {return;}

servermodules->Clear();

regeintraege->RootKey = HKEY_CURRENT_USER;
regeintraege->OpenKey("ERGE-Formelsammlung", false);
regeintraege->OpenKey("COMServers", false);
regeintraege->OpenKey(data->clsid, false);
server->SetServer(mainwindow->appreg->serverpath + data->name);
regeintraege->CloseKey();

if (server->Count == 0) {exit;}

for  (int i=0; i<server->Count; i++)
        {
        module = (TServermodule*)server->Items[i];
        mnode = servermodules->AddChild(NULL);
        mnode->NodeHeight = 30;
        nodedata = (TPropertyData*)servermodules->GetNodeData(mnode);
        servermodules->ValidateNode(mnode, false);
        nodedata->Value = module->name;
        //nodedata->Value1 = "";
        nodedata->PropertyTyp = ptNone;
        nodedata->Data = &module->clsidString;
        TList* methods;
        methods = module->events;
        TServermoduleevent* entry;

        for (int a=0; a<methods->Count; a++)
                {
                mmethod = servermodules->AddChild(mnode);
                nodedata = (TPropertyData*)servermodules->GetNodeData(mmethod);
                servermodules->ValidateNode(mmethod,false);
                methods = module->events;
                entry = (TServermoduleevent*)methods->Items[a];
                nodedata->Value = "Ereignis: ";
                //nodedata->Value1 = "";
                nodedata->PropertyTyp = ptNone;
                nodedata->Data = &entry->name;

                //Icon setzen
                setting = servermodules->AddChild(mmethod);
                nodedata = (TPropertyData*)servermodules->GetNodeData(setting);
                servermodules->ValidateNode(setting,false);
                nodedata->Value = "Icon: ";
                //nodedata->Value1 = IntToStr(entry->icon);
                nodedata->PropertyTyp = ptIcon;
                nodedata->Data = &entry->icon;

                //Menues setzen
                setting = servermodules->AddChild(mmethod);
                nodedata = (TPropertyData*)servermodules->GetNodeData(setting);
                servermodules->ValidateNode(setting,false);
                nodedata->Value = "Wird angezeigt in: ";
                //nodedata->Value1 = IntToStr(entry->toolbar);
                nodedata->PropertyTyp = ptToolbar;
                nodedata->Data = &entry->toolbar;

                // Verwendung 
                setting = servermodules->AddChild(mmethod);
                nodedata = (TPropertyData*)servermodules->GetNodeData(setting);
                servermodules->ValidateNode(setting,false);
                nodedata->Value = "Sichtbar: ";
                //nodedata->Value1 = IntToStr(entry->show);
                nodedata->PropertyTyp = ptShow;
                nodedata->Data = &entry->show;
                }
        }
}

    Im o.g. Code will ich die Variable nodedata->Value1 einsparen (aus Speichergründen). Hier nun die Funktion, die jeder Node ein Bildchen zuweist:

    void __fastcall Tappoptionen::servermodulesGetImageIndex(
      TBaseVirtualTree *Sender, PVirtualNode Node, TVTImageKind Kind,
      TColumnIndex Column, bool &Ghosted, int &ImageIndex)
{
TPropertyData* Data;

if ((Kind == ikNormal) || (Kind == ikSelected))
        {
        Data =(TPropertyData*)servermodules->GetNodeData(Node);
        if ((Column == 0) && (Data->PropertyTyp == ptNone) && (Sender->GetNodeLevel(Node) == 0)){ImageIndex = 31; }       // Modul
        if ((Column == 0) && (Data->PropertyTyp == ptNone) && (Sender->GetNodeLevel(Node) == 1)){ImageIndex = 32; }       // Event

        if ((Column == 0) && (Data->PropertyTyp == ptToolbar) && (Sender->GetNodeLevel(Node) == 2)){ImageIndex = 33;}

        if ((Column == 0) && (Data->PropertyTyp == ptIcon) && (Sender->GetNodeLevel(Node) == 2)){ImageIndex = 33; }      // Setting
        if ((Column == 0) && (Data->PropertyTyp == ptShow) && (Sender->GetNodeLevel(Node) == 2)){ImageIndex = 33; }

        if ((Column == 1) && (Data->PropertyTyp == ptIcon) && (Sender->GetNodeLevel(Node) == 2) ){
        Data = (TPropertyData*)servermodules->GetNodeData(Node);
        int *CNodeData = (int*)Data->Data;
        ImageIndex = *CNodeData; } // Current-Icon Modul
        }
        else
                {ImageIndex = -1;}
}

    Auf meiner Form befinden sich zwei Trees comservers und servermodules. Klickt der User in comservers auf eine Node (die steht für jeweils einen Com-Server), dann werden in servermodules die enthaltenen Servermodule bzw. Coclassen und deren zugehörige Events angezeigt. Während in servermodules die Nodes erstellt werden, tritt o.g. GetImageIndex-Event auf und man hat die Möglichkeit, jeder Node eines oder mehrer Icons hinzuzufügen. Den Code, den Du hier siehst, stellt im Prinzip schon die Lösung für mein Prob dar (habe ich grade erst entwickelt, nachdem ich diesen Threat erstellt hatte). Aber in der if-Schleife

    if ((Column == 1) && (Data->PropertyTyp == ptIcon) && (Sender->GetNodeLevel(Node) == 2) ){
        Data = (TPropertyData*)servermodules->GetNodeData(Node);
        int *CNodeData = (int*)Data->Data;
        ImageIndex = *CNodeData; } // Current-Icon Modul
        }

    ist mir das Zuweisen bloß gelungen, weil ich Data->Data erst zum Integerpointer CNodeData gecastet habe und dann diesen erst dem ImageIndex zuweise. Gibts hier keine direktere Möglichkeit evtl. so

    ImageIndex = *Data->Data

    Die Struktur von Data sieht folgendermaßen aus:

    typedef struct {
   TPropertyTyp    PropertyTyp;
   TVirtualNode*   Node;
   WideString      Value;
   //WideString      Value1;
   bool            Changed;
   void*           Data;
} TPropertyData, *lpPropertyData;

    Hier ist zwar Value1 noch enthalten, soll aber später eben komplett wegfallen. Das ganze möchte ich eben aus reinen Speichergründen ein wenig reduzieren.

    Wäre super, wenn Du mir helfen könntest. Wenn Du mehr Code brauchst, dann schick ich Dir den gern auch nochmal per Mail zu. Das ganze Ding hier zu posten wäre nämlich zuviel. Danke jedoch schon mal vorab für Deine Hilfe.

    Gruß Udo 🕶

    [ Dieser Beitrag wurde am 10.01.2003 um 03:00 Uhr von Darkheart editiert. ]

    0
  • E

    Das war zu viel Code... die Struktur hätte gereicht. 😉

    Guck dir nochmal WebFritzis Beispiel an, wie man von einem Zeiger(TPropertyData::Data ist ja ein zeiger) nach int castet.

    0
  • W

    Oh man, es hätte wirklich gereicht, wenn du 2 Zeilen gepostet hättest. Und zwar diese hier:

    int *CNodeData = (int*)Data->Data;
ImageIndex = *CNodeData;

    So, und wie du dir auch selber denken kannst, geht das auch in einer Zeile:

    ImageIndex = *(int*)Data->Data;

    Das Casten muss aber sein. Im Übrigen hatte ich das Prinzip oben schon lange gepostet. Wenn du schlau gewesen wärst, hättest du dir meinen Beitrag besser durchgesehen.

    0
  • D

    Sorry,

    hatte ich echt übersehen, aber danke für Euere Hilfe!

    Gruß

    Udo

    0
  • D

    Jetzt muß ich Euch mit dem Thema leider trotzdem nochmal belästigen. Wie sieht das dann bei Klassen aus. Hier ein Beispiel:

    In einer Klasse mit dem Namen Item wird ein Pointer auf einen Klasse Katitem abgelegt (alles beide eigene Klassendefinitionen von mir).

    Item->DataP = &Katitem;

    Wie kann ich jetzt später diesen Pointer wieder auslesen und auf die Struktur bzw. die Daten von Katitem zugreifen?

    Folgender Versuch

    Tkatitem *tmpKatitem = (Tkatitem*)Item->DataP;

    und der danach folgende Zugriff auf die Elemente von *tmpKatitem(Katitem) mit z.B.

    tmpKatitem->Name

    Bringt mir leere Werte. Warum? Normalerweise sollte doch der Pointer in Item-DataP lt. o.g Code in einen Pointer auf ein Tkatitem gecastet und dann tmpKatitem zugewiesen werden oder?

    Danke
    Udo

    0
  • W

    Du machst hier alles richtig. Entweder ist Katiitem leer oder du setzt Item->DataP irgendwann wieder auf eine leere Tkatiitem-Struktur.

    0
  • J

    Lokale Variablen werden am Ende des Blocks (Teil zwischen {}) in dem sie erstellt werden zerstört. Entsprechend wird der Zeiger damit auch ungültig.

    Die Tatsache dass du den & Operator benötigt hast lässt mich vermuten du hast da den Wert einer lokalen Variablen zugewiesen und hast einfach Glück gehabt, dass es keine AccessVoilation gibt.

    -junix

    0
  • ?

    Ab welcher BCB-Version ist Tkatiitem dabei?

    0
  • J

    Original erstellt von <Kleiner Feiglich>:
    Ab welcher BCB-Version ist Tkatiitem dabei?

    Gar keiner. Wird eine eigene Klasse oder eine Struktur sein (: Sowas kann man mit C/C++ auch als Datentyp verwenden (-;

    -junix

    0
  • W

    Original erstellt von junix:
    Die Tatsache dass du den & Operator benötigt hast lässt mich vermuten du hast da den Wert einer lokalen Variablen zugewiesen und hast einfach Glück gehabt, dass es keine AccessVoilation gibt.

    Aua, ich Idiot. Das hätte mir auffallen müssen. 😉

    0
  • ?

    Achso ist das. Danke. Das mit dem T vor dem Klasse/Datentyp hat mich so verwirrt. Sorry. 😃

    0
  • D

    Junge, junge soviel Antworten habe ich nicht erwartet.

    WebFritzi hatte recht, Tkatitem wurde nicht richtig initialisiert, da ich die Initialisierungsroutine überladen hatte und ausgerechnet die falsche Version der Funktion verwendet wurde.

    Junix, die Variablen sind Teil von Tkatitem sprich Tkatitem ist wie folgt aufgebaut:

    class Tkatitem
        {
        public:
                AnsiString name;
                AnsiString iconnect;
                GUID iguid;
                TList* events;
        }

    Hier müßten doch dann die Variablen im Speicher erhalten bleiben, wenn ich die Klasse nicht freigebe oder ?

    Mittlerweile krieg ich auch was auf dem Bildschirm angezeigt, wenn ich

    tmKatitem->name

    z.B. einem Editfeld zuweise. Allerdings sind das im Moment leider noch irgendwelchen unidentifizierbaren Hieroglyphen, obwoh dort eigentlich der Name stehen sollte. Weiß hier jemand, womit das zusammenhängt?

    <KleinerFeiglich> sorry, ist ne eigene Klasse in meinem Programm und dient nur zu programminternen Geschichten.

    Gruß

    Udo

    0
  • W

    z.B. einem Editfeld zuweise. Allerdings sind das im Moment leider noch irgendwelchen unidentifizierbaren Hieroglyphen, obwoh dort eigentlich der Name stehen sollte. Weiß hier jemand, womit das zusammenhängt?

    Schau dir nochmal in Ruhe junix' Post an, bevor du weiterfragst... Oder noch besser: schau dir in einem C++-Tutorial ein Kapitel über Pointer an.

    [ Dieser Beitrag wurde am 13.01.2003 um 00:53 Uhr von WebFritzi editiert. ]

    0
  • J

    ...und, udo, Schau mal in der FAQ den Beitrag "Public-Variablen sind Böse aber wieso?" an den du im FAQ-Index unter "Allgemeines" findest.

    -junix

    0
  • D

    Ehrlich gesagt, versteh ich hier wirklich was nicht. Kann sein, daß ich mich täusche, aber wenn ich ne neue Klasse oder ein Objekt mit new deklariere muß ich die doch extra mit delete wieder freigeben, da sie ansonsten im Speicher bleiben.

    Also müßte es doch möglich sein, über nen Pointer aus einer anderen Funktion auf die Daten von Katitem zuzugreifen, weil die Klasse eben mit new erzeugt wird ?!

    Und die Version mit tmpKatitem->name hat bei einer anderen Möglichkeit auch funktioniert. Siehe z.B. den VirtualTreeView die Funktion VT.NodeGetDataSize(Node); hier wird über diese Funktion ein Pointer auf ne Klasse bzw. Datenstruktur zurückgegeben und ich kann nach dem Typcasten einwandfrei auf die Daten der Struktur zugreifen (hoffe den VT kennt Ihr, aber ich denke schon).

    Also helft mir bitte. Es kann durchaus sein, daß ich hier im Moment auf dem Schlauch stehe und was verwechsle.

    Danke

    Udo

    0
  • J
     

    Item->DataP = &Katitem;

    Diese Zeile sagt mir, dass du Katitem garantiert nicht mit new erzeugt hast. Sonst könnte der restliche Code auch nichtmehr funktionieren.
    Ich kann nur nochmal auf Webfritzi verweisen. Er hat recht. Bevor du weitermit Zeigern rumspielst solltest du dringends in einem Tutorial mal über Zeiger nachlesen.

    KLeine Zwischenfrage an dich: Was macht der Operator '&'?

    -junix

    [ Dieser Beitrag wurde am 13.01.2003 um 01:24 Uhr von junix editiert. ]

    0
  • D

    & weist einem Pointer die Adresse von einem Objekt oder einer Variablen als Wert zu. In diesem Fall hier soll die Adresse von Katitem an Item->DataP übergeben werden, so daß DataP die Adresse von Katitem enthält.

    Aber Du hattest recht Unix. Es lag wirklich am &-Operator. In meiner Funktion werden mehrere Katitems in einer TList gespeichert (natürlich nur die Addressen) und durch die Zuweisung mit dem &-Operator habe ich die Adresse des TListitems erhalten und nicht die Adresse von Katitem. Das kann natürlich nicht funktionieren.

    Aber ich möchte Euch trotzdem nochmal recht herzlich für Eure Hilfe bedanken. :p Und das mit den Pointer krieg ich auch noch auf die Reihe. Arbeite erst seit ungefähr 6 Wochen mit dem BCB und da läuft halt noch nicht alles rund.

    Gruß

    Udo

    [ Dieser Beitrag wurde am 13.01.2003 um 01:31 Uhr von Darkheart editiert. ]

    0
  • W

    & weist einem Pointer die Adresse von einem Objekt oder einer Variablen als Wert zu.

    Falsch. Der weist garnichts zu... der gibt was zurück! Und zwar einen Pointer auf die Adresse des angegebenen Objektes.

    Also, sagen wir Katiitem ist ein Pointer auf ein Tkatiitem. Von welchem Typ ist dann wohl &katiitem?

    [ Dieser Beitrag wurde am 13.01.2003 um 01:37 Uhr von WebFritzi editiert. ]

    0
  • D

    Sorry, gibt die Adresse zurück! Natürlich und dass sollte ja auch so sein. DataP soll ja den Pointer von Katitem enthalten. Habs vielleicht falsch ausgedrückt.

    0
  • W

    DataP soll ja den Pointer von Katitem enthalten

    Und genau das ist der Punkt. Ich dachte, Katiitem ist ein Pointer?

    Edit: Beantworte meine Frage in meinem vorigen Post.

    [ Dieser Beitrag wurde am 13.01.2003 um 01:39 Uhr von WebFritzi editiert. ]

    0
Anmelden zum Antworten