Wann sollte ich den "this" -Zeiger explizit verwenden?

In der Regel müssen Sie nicht haben, this-> impliziert ist.

Manchmal, es ist ein name, der Zweideutigkeit, wo es verwendet werden kann, um keine Verwechslungen Klasse Mitgliedern und lokalen Variablen. Allerdings ist hier ein komplett anderer Fall, wo this-> wird ausdrücklich gefordert.

Betrachten Sie den folgenden code:

template<class T>
struct A {
   int i;
};

template<class T>
struct B : A<T> {

    int foo() {
        return this->i;
    }

};

int main() {
    B<int> b;
    b.foo();
}

Wenn du weglassen this->, die der compiler nicht wissen, wie zur Behandlung von i, da es möglicherweise oder möglicherweise nicht vorhanden in allen Instanziierungen A. Um zu sagen, dass es i ist in der Tat ein Mitglied der A<T> für alle T, die this-> Präfix ist erforderlich.

Hinweis: es ist möglich, noch weglassen this-> Präfix:

template<class T>
struct B : A<T> {

    using A<T>::i; //explicitly refer to a variable in the base class

    int foo() {
        return i; //i is now known to exist
    }

};

InformationsquelleAutor der Antwort ASk

Es gibt mehrere Gründe, warum Sie möglicherweise verwenden müssen this Zeiger explizit.

• Wenn Sie möchten, übergeben Sie einen Verweis auf das Objekt an eine Funktion.
• , Wenn es ein lokal deklariertes Objekt mit dem gleichen Namen wie die member-Objekt.
• , Wenn Sie versuchen, Zugriff auf Mitglieder abhängig Basisklassen.
• Einige Leute bevorzugen die notation visuell keine Verwechslungen Mitglied greift in Ihrem code.

InformationsquelleAutor der Antwort avakar

Einem anderen Fall wird beim Aufruf von Operatoren. E. g. statt

bool Type::operator!=(const Type& rhs)
{
    return !operator==(rhs);
}

kann man sagen,

bool Type::operator!=(const Type& rhs)
{
    return !(*this == rhs);
}

Welche vielleicht mehr lesbar. Ein weiteres Beispiel ist die copy-and-swap:

Type& Type::operator=(const Type& rhs)
{
    Type temp(rhs);
    temp.swap(*this);
}

Ich weiß nicht warum es nicht geschrieben swap(temp) aber das scheint weitverbreitet zu sein.

InformationsquelleAutor der Antwort rlbond

Es gibt nur wenige Fälle, in denen mit this muss verwendet werden, und es gibt andere, bei denen das this Zeiger ist ein Weg, um ein problem zu lösen.

1) Alternativen zur Verfügung: Zum auflösen von Mehrdeutigkeit zwischen lokalen Variablen und Klasse Mitglieder, dargestellt durch @ASk.

2) Keine Alternative: zurück, einen Zeiger oder Referenz auf this von einer member-Funktion. Dies geschieht Häufig (und getan werden sollte), wenn eine überlastung operator+, operator-, operator= usw:

class Foo
{
  Foo& operator=(const Foo& rhs)
  {
    return * this;
  }
};

Dies ermöglicht ein idiom bekannt als "Methode Verkettung", wo Sie mehrere Operationen auf ein Objekt in einer Zeile code. Wie:

Student st;
st.SetAge (21).SetGender (male).SetClass ("C++ 101");

Einige halten dies für consise, andere halten es für ein Greuel. Zählen Sie mich in der letzteren Gruppe.

3) Keine Alternative: Zum auflösen von Namen in abhängiger Arten. Dies kommt bei der Verwendung von Vorlagen, wie in diesem Beispiel:

#include <iostream>


template <typename Val>
class ValHolder
{
private:
  Val mVal;
public:
  ValHolder (const Val& val)
  :
    mVal (val)
  {
  }
  Val& GetVal() { return mVal; }
};

template <typename Val>
class ValProcessor
:
  public ValHolder <Val>
{
public:
  ValProcessor (const Val& val)
  :
    ValHolder <Val> (val)
  {
  }

  Val ComputeValue()
  {
//   int ret = 2 * GetVal();  //ERROR:  No member 'GetVal'
    int ret = 4 * this->GetVal();  //OK -- this tells compiler to examine dependant type (ValHolder)
    return ret;
  }
};

int main()
{
  ValProcessor <int> proc (42);
  const int val = proc.ComputeValue();
  std::cout << val << "\n";
}

4) Alternativen Verfügbar: Als Teil des coding-Stil zu dokumentieren, welche Variablen sind die Variablen, die im Gegensatz zu lokalen Variablen. Ich bevorzuge ein anderes Namensschema, wo die varibales können niemals den gleichen Namen haben wie die einheimischen. Derzeit bin ich mit mName für Mitglieder und name für die einheimischen.

InformationsquelleAutor der Antwort John Dibling

Müssen Sie this keine Verwechslungen zwischen einem Parameter/lokale Variablen und member-Variablen.

class Foo
{
protected:
  int myX;

public:
  Foo(int myX)
  {
    this->myX = myX; 
  }
};

InformationsquelleAutor der Antwort Brian R. Bondy

Anderen Gebrauch für dieses (wie ich dachte, wenn ich Lesen Sie die Zusammenfassung und die Hälfte der Frage... .), missachten (schlechte) Benennung Begriffsklärung in anderen Antworten, sind wenn Sie wollen zu werfen, die das aktuelle Objekt haben, binden Sie es in ein function-Objekt, oder verwenden Sie es mit einem Zeiger-auf-member.

Wirft

void Foo::bar() {
    misc_nonconst_stuff();
    const Foo* const_this = this;
    const_this->bar(); //calls const version

    dynamic_cast<Bar*>(this)->bar(); //calls specific virtual function in case of multi-inheritance
} 

void Foo::bar() const {}

Bindung

void Foo::baz() {
     for_each(m_stuff.begin(), m_stuff.end(),  bind(&Foo:framboozle, this, _1));        
     for_each(m_stuff.begin(), m_stuff.end(), [this](StuffUnit& s) { framboozle(s); });         
} 

void Foo::framboozle(StuffUnit& su) {}

std::vector<StuffUnit> m_stuff;

ptr-Mitglied

void Foo::boz() {
    bez(&Foo::bar);
    bez(&Foo::baz);
} 

void Foo::bez(void (Foo::*func_ptr)()) {
    for (int i=0; i<3; ++i) {
        (this->*func_ptr)();
    }
}

Hoffe, es hilft, zu zeigen, dass andere Verwendungen von diesem, als nur diese->Mitglied.

InformationsquelleAutor der Antwort Macke

Dem Haupt - (oder kann ich sagen, das einzige) Zweck der this Zeiger ist, dass es auf das Objekt verwendet, um auf eine member-Funktion.

Basis auf diesem Zweck, wir haben einige Fälle, die nur mit this Zeiger kann das problem lösen.

Zum Beispiel, wir müssen zurück, die dem aufrufenden Objekt in eine member-Funktion mit argument ist eine gleichen Klasse Objekt:

class human {

... 

human & human::compare(human & h){
    if (condition)
        return h;       //argument object
    else 
        return *this;   //invoking object
    }
};

InformationsquelleAutor der Antwort Nik