Memberfunktion auf Memberfunktion wird nicht ausgeführt

Hallo ich habe da folgendes Problem.

ich möchte aus einer Memberfunktion eine andere Memberfunktion der selben Klasse aufrufen. Wenn ich es im Debugmodus mache funzt es einwandfrei lasse ich das Programm normal ablaufen wird diese Funktion nicht ausgeführt. Mein zweiter Versuch das über Zeiger zu machen ist ebenfalls fehlgeschlagen. Nachfolgend habe ich meine beiden erfolglosen Versuche aufgeschrieben und hoffe das mir jemand weiter helfen kann.

im Voraus schon mal vielen Dank

MfG

1. Versuch direkt aufrufen
--------------------------

void CDatenbestandDlg::get()
{
...
CDatenbestandDlg::put(...);
}

2. Versuch indirekt über Zeiger
-------------------------------

void CDatenbestandDlg::get()
{
...
CDatenbestandDlg pDlg;
pDlg->put(...);
}

Knuddlbaer

Was passiert wenn Du einfach nur put(...) schreibst ?

Ohne was davor ?

Die 2. Varante feht nicht da es

1. kein Zeiger ist
2. die Methode eines anderen Objektes aufgerufen wird, nicht aber vom eigenen Objekt (also this->put(...);

Hallo einfach nur put geht nicht da es ja nicht aussagt das die Membermethode mit gemeint ist. Die Idee mit this ist besser probiers morgen aus jetzt mach ich erstmal Feierabend :-))

Danke

Knuddlbaer

void put()
{
}

struct t
{
  put(){};
  get(){
    put(); // ruft this->put auf
    ::put(); // ruft globales put auf
   }
}

Was passiert wenn man t::put schreibt weiß ich ehrlich gesagt nicht. Ich kenne das mit dem <ClassName>:: davor nur wenn es

Eine Statische Methode ist die ohne INstanz aufgerufen werden soll
oder es sich um Vererbung handelt und eine Methode der Basisklasse aufgerufen wird.

HumeSikkins

Was passiert wenn man t::put schreibt weiß ich ehrlich gesagt nicht

Es wird t::put() aufgerufen
t::put() ist in diesem Kontext gleichbedeutend mit this->t::put() und das wiederum hier mit put().
Wichtig wird diese Syntax im Zusammenhang mit virtuellen Funktionen, da du hiermit die dynamische Bindung unterdrücken kannst.
Ein Beispiel:

struct Base
{ 
    virtual void put()
    {
        // Annahme: Der dynamische Typ von this ist Derived.
        // In einer Funktion wurde also z.B. folgendes gemacht:
        // Derived d;
        // Base& b = d;
        // b.put();

        put();         // Ruft Derived::put auf
        this->put();   // Ruft Derived::put auf
        Base::put();   // Bindet put statisch -> ruft Base::put auf
        this->Base::put(); // wie Base::put
    }
};

struct Derived : public Base
{
    void put() {}
};