D_Main: Zugriff auf deren Objekte

Danke für die schnelle Antwort, ist eine gute Idee.
Werde das erstere Versuchen. Rufe also die "property"-deklarierte Klasse vom D_Main-Form auf und setze dort den this-Zeiger.
Dann sollten alle anderen Forms Zugriff auf diese Property-Klasse haben und den Zeiger mit der definierten get-Methode abfragen können.

Noch eine kurze Zwischenfrage:

Ich habe eine Klasse: ( public ref DemoKlasse... )
DemoKlasse^ Demo;
Zum Anlegen des Objekts auf dem Heap brauche ich auf alle Fälle immer "gcnew" oder? (gorbage collector-Variante von new)
Ich habe nicht die Möglichkeit, auf eine Klasse mit static-Methoden ohne gcnew auf die Methoden zuzugreifen?

Grüße
Stefan

theta

Zum Anlegen des Objekts auf dem Heap brauche ich auf alle Fälle immer "gcnew" oder? (gorbage collector-Variante von new)

Ich nehme an, die interessiert nicht in 1. Linie, wo das Objekt tatsächlich im Speicher liegt (Heap, Managed Heap, ...) sonder vielmehr, wie die Lebenszeit geregelt ist.

// demo und demo1 werden beide automatisch "verwaltet", jedoch 
// auf unterschiedliche Art.
{
    Demo^ demo = gcnew Demo;
    demo->f();
    // Wenn keine Referenzen auf demo mehr bestehen, wird das Objekt vom
    // GC eingesammelt und irgendwann aufgeräumt. Das Objekt, wenn Referenzen
    // darauf herumgereicht werden, kann immer noch verwendet werden. Wird
    // delete demo ruft demo->Dispose() auf (falls vorhanden). Der Speicher wird
    // dann vom GC irgendwann freigegeben. Das Objekt ist logisch ungültig.
}
{
    Demo demo1;
    demo1.f();
    // Wenn der Scope verlassen wird, wird automatisch delete demo1; aufgerufen,
    // was zur Folge hat, dass Dipose(), falls vorhanden, aufgerufen wird.
    // Das Objekt kann nicht mehr verwendet werden, da nach dem Aufruf vom 
    // Dispose das Objekt (logisch) ungültig ist.
}

Ich habe nicht die Möglichkeit, auf eine Klasse mit static-Methoden ohne gcnew auf die Methoden zuzugreifen?

Doch, denn sie sind ja static. Du benötigst kein Objekt von der Klasse.
Bsp:

using namespace System;

ref class Demo
{
public:
    void nonStaticMemberFunction()
    {
    }
    static void staticMemberFunction()
    {
    }
};

int main(array<System::String ^> ^args)
{
    Demo^ demo = gcnew Demo;
    demo->nonStaticMemberFunction();

    Demo::staticMemberFunction();

    return 0;
}

Culan

Erstmal danke für die schnelle Antwort, echt spitze.
Wird wohl meine C++/Cli-Fragen Anlaufstelle werden

Würde folgender Methoden-Aufruf funktionieren?

using namespace System;

ref class Demo
{
public:
    static void staticMemberFunction()
    {
    }
};

int main(array<System::String ^> ^args)
{
    Demo::staticMemberFunction();   
    return 0;
}

Also ohne das ich das Object mit gcnew Demo auf dem managed-Heap erzeuge?

Rhombicosidodecahedron

ja

Culan

Im Konstruktor von "D_Main" (Main-Form) speichere ich nun den this-Zeiger in eine static-Variable (static D_Main Instance).
Der Zugriff mit "D_Main::Instance" von einem anderen Objekt aus klappt nun einwandfrei.
Was ist aber, wenn das Object "D_Main" vom gc automatisch einmal verschoben wird?
Wäre hier nicht eine Tracking-Referenz auf "D_Main" vorteilhafter?
Wenn ja, wie deklariere ich diese richtig?
static D_Main^% this ???

Grüße
Stefan

theta

Nicht static!!!
Warum auch...

Das Tracking Handle (^) ist auch gemanagt... Du brauchst keine Tracking Reference.

Simon

Culan

Hier mal ein Abschnitt meines Codes:

public ref class D_Main : public System::Windows::Forms::Form
{
public:
    static D_Main^ Instance;

    // Konstruktor
public:
    D_Main(void)
    {
        Instance = this;
    }
};

Nun kann ich von anderen Klassen mit "D_Main::Instance" auf sämtliche Elemente von D_Main zugreifen.
Wenn der gc nun D_Main verschieben würde, gäbe es kein Problem, denn meine Variable "Instance" ist ja auch gemannaged.
Habe ich das so richtig verstanden?

theta

Nein, komplett verkehrt!

1. Kümmere dich erstmal nicht um den GC. Es gibt fälle wo es manchmal wichtig ist, aber hier nicht!
2. Übergib eine Referenz eines D_Main Objekts an das Objekt, welches es benötigt. Konkret: Über gib beim erzeugen des D_TestDialog Objekts die Referenz auf dein D_Main Objekt. Wenn Du D_TestDialog in D_Main erzeugst ist das eben this.

Das was Du gemacht hast, läuft hin zu globalen Variabeln und das ist selten gut.

Simon

Culan

Ich habe eine separate cpp-Datei, inder ich eine Funktion habe die mir z.B. das Aussehen vom D_Main-Formular ändert. (Position, Größe etc)
In dieser Funktion werden die Einstellungen geladen und entsprechend wird das D_Main-Formular angepasst.
Empfiehlt es sich dieser Funktion den this-Zeiger direkt zu übergeben?

Funktion in der Global.cpp:

bool Chaping::Settings::CConfig::LoadData()
{
  //...
}

Wie gebe ich hier die Parameterliste richtig an, um einen this-Zeiger zu übergeben?

LoadData( D_Main^ Instance) ???

mogel

@Mogel: