class Test
{
<!-- ... -->
int blub;
void MachWas(int blub)
{
    this.blub = blub;
}

oder
void MachWas(int blaa)
{
    blub = blaa;
}

};

Also wo ist der Unterschied bzw. wann genau verwende ich dann "this."?

void kraks( Bla* b )
{
}

class Bla
{
    void foo()
    {
        kraks( this );
    }
};

natürlich noch mit Forward-Declarations, aber es geht ja ums Prinzip

In diesem Fall ist this nötig, da blub jetzt nur noch den Parameter bezeichnet, nicht mehr die Membervariable. Aber man sollte da ohnehin unterschiedliche Bezeichner wählen.
Den this-Zeiger braucht man eher bei der Übergabe an Funktionen, die einen Zeiger benötigen.

class foo_t {

    private:
        int m_bar;

    public:
        const int &bar;
        foo_t( int bar ) : m_bar( bar ), bar( m_bar ) { }
};

int main( ) {

    foo_t foo( 42 );                   // Der user "sieht" mit IntelliSense "bar"
    int bar = foo.bar; // und greift auf das Attribut auch mit bar lesend zu.
}

greetz, Swordfish

class Foo {
  int bar;
public:
  Foo(int bar) : bar(bar) {}
  int GetBar() { return bar; }
};

int main() {
  Foo foo(42);
  int bar = foo.GetBar();
}

Foo(int bar) : bar(bar) {}

das ist im prinzip auch der grund, warum ich keine unterstriche oder m_ bei meinen membervariablen führe.

@pumuckl: so ein beispiel lässt sich leicht herbeizaubern.

template <typename T>
struct Base
{
  T t;
};

template <typename T>
struct Derived : Base<T>
{
  void foo ()
  {
     t = 12; //Fehler
  }
};

lass mich mal ausschlafen, dann erklär ich's auch

greetz, Swordfish

greetz, Swordfish

Ich bin es gewohnt, auf public member einer Klasse zuzugreifen. Ob das nun eine Methode oder ein Attribut ist, juckt mich ehrlichgesagt nicht.

Ich glaube dies würde sich ändern wenn du bereits die Nachteile kräftig ausbaden durftest die ein direkter Attributszugriff hat. Ich habe Beispielsweise ein Projekt übernehmen müssen, das dies sehr intensiv tut, und bis heute nicht die nötige Zeit gehabt es komplett davon zu befreien.

Selbst ein getter und setter das nur durchreicht ist besser als ein direkter Attributszugriff, da man später noch Änderungen (seien es zusätzliche Prüfungen, Rechtebehandlungen oder gar Mechanismen wegen Threading) machen kann ohne die Schnittstelle ändern zu müssen.

Ja, es gibt Teile einer Schnittstelle die sich nicht oder nur sehr unwahrscheinlich ändern. Aber es ist immer besser eine saubere Schnittstelle zu haben die, die Implementierung und Attribute kapselt, da man so noch ohne weiteres die Klasse in einen Adapter für eine Neuimplementierung umtauschen kann.

cu André

und zur eigentlichen frage: ich glaube die verwendung von this zum qualifizierten zugriff auf member ist eher in der java welt verbreitet. in der c-welt werden member eher mit einem prefix versehen. wahrscheinlich aus historischen gründen. denn ehrlich gesagt fällt mir kein grund ein, warum ein "m_" schöner, besser oder effizienter wäre, als ein "this->" vor jedem member-zugriff.
ich persönlich verwende lieber this, um zugriff zu qualifizieren. es ist ein sprachkonstrukt und schliesst so, im gegensatz zu selbst definierten prefixes, fehler schon auf compilerebene aus.

greetz, Swordfish