Wann verwenden Sie das Schlüsselwort "this"? [geschlossen]

Ich war neugierig, wie andere Leute dieses Schlüsselwort verwenden. Ich neige dazu, es in Konstruktoren zu verwenden, aber ich kann es auch in der gesamten Klasse in anderen Methoden verwenden. Einige Beispiele:

In einem Konstruktor:

public Light(Vector v)
{
    this.dir = new Vector(v);
}

Anderswo

public void SomeMethod()
{
    Vector vec = new Vector();
    double d = (vec * vec) - (this.radius * this.radius);
}

Es gibt mehrere Verwendungen dieses Schlüsselworts in C #.

1. Um Mitglieder zu qualifizieren, die unter einem ähnlichen Namen versteckt sind
2. Damit sich ein Objekt als Parameter an andere Methoden übergibt
3. Damit sich ein Objekt von einer Methode zurückgibt
4. Indexer deklarieren
5. Erweiterungsmethoden deklarieren
6. Parameter zwischen Konstruktoren übergeben
7. Um den Wert intern neu zuzuweisen, geben Sie den Wert (struct) ein .
8. So rufen Sie eine Erweiterungsmethode für die aktuelle Instanz auf
9. Sich auf einen anderen Typ zu werfen
10. Zum Verketten von Konstruktoren, die in derselben Klasse definiert sind

Sie können die erste Verwendung vermeiden, indem Sie keine Mitglieds- und lokalen Variablen mit demselben Namen im Gültigkeitsbereich haben, z. B. indem Sie allgemeine Namenskonventionen befolgen und Eigenschaften (Pascal-Fall) anstelle von Feldern (Kamel-Fall) verwenden, um eine Kollision mit lokalen Variablen (auch Kamel) zu vermeiden Fall). In C # 3.0 können Felder mithilfe automatisch implementierter Eigenschaften einfach in Eigenschaften konvertiert werden .

Ich meine nicht, dass das snarky klingt, aber es spielt keine Rolle.

Ernsthaft.

Schauen Sie sich die Dinge an, die wichtig sind: Ihr Projekt, Ihr Code, Ihr Job, Ihr persönliches Leben. Keiner von ihnen wird seinen Erfolg davon abhängen, ob Sie das Schlüsselwort "this" verwenden, um den Zugriff auf Felder zu qualifizieren. Das Schlüsselwort this hilft Ihnen nicht, pünktlich zu versenden. Es wird keine Fehler reduzieren, es wird keine nennenswerten Auswirkungen auf die Codequalität oder Wartbarkeit haben. Es wird Ihnen keine Gehaltserhöhung bringen oder Ihnen erlauben, weniger Zeit im Büro zu verbringen.

Es ist wirklich nur ein Stilproblem. Wenn Sie "dies" mögen, dann verwenden Sie es. Wenn nicht, dann nicht. Wenn Sie es benötigen, um die richtige Semantik zu erhalten, verwenden Sie es. Die Wahrheit ist, dass jeder Programmierer seinen eigenen Programmierstil hat. Dieser Stil spiegelt die Vorstellungen des jeweiligen Programmierers wider, wie der "ästhetisch ansprechendste Code" aussehen sollte. Per Definition hat jeder andere Programmierer, der Ihren Code liest, einen anderen Programmierstil. Das heißt, es wird immer etwas geben, das du getan hast und das der andere nicht mag oder anders gemacht hätte. Irgendwann wird ein Typ Ihren Code lesen und über etwas meckern.

Ich würde mich nicht darüber ärgern. Ich würde nur sicherstellen, dass der Code nach Ihrem Geschmack so ästhetisch wie möglich ist. Wenn Sie 10 Programmierer fragen, wie Code formatiert werden soll, erhalten Sie ungefähr 15 verschiedene Meinungen. Es ist besser, sich darauf zu konzentrieren, wie der Code berücksichtigt wird. Sind die Dinge richtig abstrahiert? Habe ich sinnvolle Namen für Dinge ausgewählt? Gibt es viele Codeduplikationen? Gibt es Möglichkeiten, wie ich Dinge vereinfachen kann? Ich denke, diese Dinge richtig zu machen, wird den größten positiven Einfluss auf Ihr Projekt, Ihren Code, Ihren Job und Ihr Leben haben. Zufälligerweise wird es wahrscheinlich auch dazu führen, dass der andere am wenigsten murrt. Wenn Ihr Code funktioniert, leicht zu lesen und gut berücksichtigt ist, wird der andere nicht prüfen, wie Sie Felder initialisieren. Er wird nur Ihren Code verwenden, sich über seine Größe wundern,

Ich benutze es nur, wenn es absolut notwendig ist, dh wenn eine andere Variable eine andere beschattet. Wie hier:

class Vector3
{
    float x;
    float y;
    float z;

    public Vector3(float x, float y, float z)
    {
        this.x = x;
        this.y = y;
        this.z = z;
    }

}

Oder wie Ryan Fox betont, wenn Sie dies als Parameter übergeben müssen. (Lokale Variablen haben Vorrang vor Mitgliedsvariablen)

Persönlich versuche ich immer zu verwenden , dies , wenn auf Membervariablen beziehen. Es hilft, den Code zu verdeutlichen und lesbarer zu machen. Selbst wenn es keine Mehrdeutigkeit gibt, weiß jemand, der meinen Code zum ersten Mal liest, das nicht, aber wenn er sieht, dass dies konsistent verwendet wird, weiß er, ob er eine Mitgliedsvariable betrachtet oder nicht.

Ich benutze es jedes Mal, wenn ich auf eine Instanzvariable verweise, auch wenn ich es nicht brauche. Ich denke, das macht den Code klarer.

Ich kann nicht glauben, dass alle Leute, die sagen, es immer zu benutzen, eine "Best Practice" und so sind.

Verwenden Sie "this", wenn Unklarheiten bestehen, wie in Coreys Beispiel, oder wenn Sie das Objekt als Parameter übergeben müssen, wie in Ryans Beispiel . Es gibt keinen Grund, es anders zu verwenden, da die Fähigkeit, eine Variable basierend auf der Bereichskette aufzulösen, klar genug sein sollte, dass es nicht erforderlich sein sollte, Variablen damit zu qualifizieren.

BEARBEITEN: Die C # -Dokumentation zu "this" gibt neben den beiden genannten eine weitere Verwendung für das Schlüsselwort "this" an - zum Deklarieren von Indexern

EDIT: @Juan: Huh, ich sehe keine Inkonsistenz in meinen Aussagen - es gibt 3 Fälle, in denen ich das Schlüsselwort "this" verwenden würde (wie in der C # -Dokumentation dokumentiert), und dies sind Zeiten, in denen Sie es tatsächlich benötigen . "Dies" vor Variablen in einem Konstruktor zu halten, wenn keine Schattenbildung stattfindet, ist einfach eine Verschwendung von Tastenanschlägen und eine Verschwendung meiner Zeit beim Lesen. Es bietet keinen Vorteil.

Ich benutze es immer dann , wenn StyleCop es mir sagt. StyleCop muss befolgt werden. Oh ja.

Immer wenn Sie einen Verweis auf das aktuelle Objekt benötigen.

Ein besonders praktisches Szenario ist, wenn Ihr Objekt eine Funktion aufruft und sich selbst an sie übergeben möchte.

Beispiel:

void onChange()
{
    screen.draw(this);
}

Ich neige dazu, es auch überall zu verwenden, nur um sicherzustellen, dass klar ist, dass es sich um Instanzmitglieder handelt, mit denen wir es zu tun haben.

Ich benutze es überall dort, wo es (offensichtlich) Unklarheiten geben könnte. Nicht nur die Mehrdeutigkeit des Compilers (in diesem Fall wäre dies erforderlich), sondern auch die Mehrdeutigkeit für jemanden, der sich den Code ansieht.

Eine andere, etwas seltene Verwendung für dieses Schlüsselwort ist, wenn Sie eine explizite Schnittstellenimplementierung innerhalb der implementierenden Klasse aufrufen müssen. Hier ist ein erfundenes Beispiel:

class Example : ICloneable
{
    private void CallClone()
    {
        object clone = ((ICloneable)this).Clone();
    }

    object ICloneable.Clone()
    {
        throw new NotImplementedException();
    }
}

Hier ist, wenn ich es benutze:

• Zugriff auf private Methoden innerhalb der Klasse (zur Unterscheidung)
• Übergeben des aktuellen Objekts an eine andere Methode (oder als Absenderobjekt im Falle eines Ereignisses)
• Beim Erstellen von Erweiterungsmethoden: D.

Ich verwende dies nicht für private Felder, da ich privaten Feldvariablennamen einen Unterstrich (_) voranstelle.

[C ++]

Ich bin mit der Brigade "benutze es, wenn du musst" einverstanden. Dekorieren Code unnötig mit diesem ist keine gute Idee , da der Compiler benachrichtigt Sie nicht , wenn Sie vergessen , es zu tun. Dies führt zu potenzieller Verwirrung für Menschen, die erwarten, dass dies immer da ist, dh sie müssen darüber nachdenken .

Also, wann würden Sie es verwenden? Ich habe mich gerade in einem zufälligen Code umgesehen und diese Beispiele gefunden (ich kann nicht beurteilen, ob dies gute Dinge sind oder nicht):

• "Sich" an eine Funktion übergeben.
• Zuweisen von "sich selbst" zu einem Zeiger oder ähnlichem.
• Casting, dh Up / Down-Casting (sicher oder anderweitig), Wegwerfen von Konstanz usw.
• Vom Compiler erzwungene Begriffsklärung.

Sie sollten es immer verwenden, ich verwende es, um private Felder und Parameter zu unterscheiden (da unsere Namenskonventionen besagen, dass wir keine Präfixe für Mitglieds- und Parameternamen verwenden (und sie basieren auf Informationen, die im Internet gefunden wurden, daher denke ich, dass a beste Übung))

Ich benutze es , wenn in einer Funktion , die einen Verweis auf ein Objekt des gleichen Typs akzeptiert, ich es machen will , ganz klar , welches Objekt beziehen ich mich auf, wo.

Beispielsweise

class AABB
{
  // ... members
  bool intersects( AABB other )
  {
    return other.left() < this->right() &&
           this->left() < other.right() &&

           // +y increases going down
           other.top() < this->bottom() &&
           this->top() < other.bottom() ;
  }
} ;

(vs)

class AABB
{
  bool intersects( AABB other )
  {
    return other.left() < right() &&
           left() < other.right() &&

           // +y increases going down
           other.top() < bottom() &&
           top() < other.bottom() ;
  }
} ;

Auf einen Blick, auf den sich AABB bezieht right()? Das thisfügt ein bisschen einen Klärer hinzu.

In Jakub Šturcs Antwort könnte seine Nummer 5 über die Weitergabe von Daten zwischen Konstrukteuren wahrscheinlich eine kleine Erklärung gebrauchen. Dies ist beim Überladen von Konstruktoren der Fall, in dem die Verwendung von thisobligatorisch ist. Im folgenden Beispiel können wir den parametrisierten Konstruktor vom parameterlosen Konstruktor mit einem Standardparameter aufrufen.

class MyClass {
    private int _x
    public MyClass() : this(5) {}
    public MyClass(int v) { _x = v;}
}

Ich habe festgestellt, dass dies gelegentlich eine besonders nützliche Funktion ist.

Ich habe mir angewöhnt, es in Visual C ++ großzügig zu verwenden, da dies IntelliSense auslösen würde, wenn ich die Taste '>' drücke, und ich bin faul. (und anfällig für Tippfehler)

Aber ich habe es weiterhin verwendet, da ich es praktisch finde, zu sehen, dass ich eher eine Mitgliedsfunktion als eine globale Funktion aufrufe.

Ich neige dazu, Felder mit _ zu unterstreichen, also muss ich das nie wirklich verwenden. Auch R # neigt sowieso dazu, sie weg zu überarbeiten ...

Ich verwende dies so ziemlich nur, wenn ich auf eine Typeigenschaft innerhalb desselben Typs verweise. Wie bereits von einem anderen Benutzer erwähnt, unterstreiche ich auch lokale Felder, damit sie erkennbar sind, ohne dass dies erforderlich ist .

Ich benutze es nur bei Bedarf, mit Ausnahme von symmetrischen Operationen, die aufgrund des Polymorphismus einzelner Argumente in Methoden einer Seite eingefügt werden müssen:

boolean sameValue (SomeNum other) {
   return this.importantValue == other.importantValue;
} 

[C ++]

Dies wird im Zuweisungsoperator verwendet, bei dem Sie die meiste Zeit seltsame (unbeabsichtigte, gefährliche oder nur Zeitverschwendung für das Programm) Dinge überprüfen und verhindern müssen, wie:

A a;
a = a;

Ihr Zuweisungsoperator wird geschrieben:

A& A::operator=(const A& a) {
    if (this == &a) return *this;

    // we know both sides of the = operator are different, do something...

    return *this;
}

this auf einem C ++ - Compiler

Der C ++ - Compiler sucht stillschweigend nach einem Symbol, wenn er es nicht sofort findet. Manchmal ist es meistens gut:

• Verwenden Sie die Methode der Mutterklasse, wenn Sie sie in der untergeordneten Klasse nicht überladen haben.
• Förderung eines Wertes eines Typs in einen anderen Typ

Aber manchmal möchte man einfach nicht, dass der Compiler es errät. Sie möchten, dass der Compiler das richtige Symbol und nicht ein anderes aufnimmt.

Für mich sind diese Zeiten, in denen ich innerhalb einer Methode auf eine Mitgliedsmethode oder eine Mitgliedsvariable zugreifen möchte. Ich möchte nur nicht, dass ein zufälliges Symbol aufgenommen wird, nur weil ich printfstattdessen geschrieben habe print. this->printfhätte nicht kompiliert.

Der Punkt ist, dass bei C-Legacy-Bibliotheken (§) vor Jahren geschriebener Legacy-Code (§§) oder was auch immer in einer Sprache passieren könnte, in der das Kopieren / Einfügen eine veraltete, aber immer noch aktive Funktion ist, die den Compiler manchmal auffordert, nicht zu spielen Witz ist eine großartige Idee.

Dies sind die Gründe, die ich benutze this.

(§) Es ist immer noch eine Art Rätsel für mich, aber ich frage mich jetzt, ob die Tatsache, dass Sie den Header <windows.h> in Ihre Quelle aufnehmen, der Grund dafür ist, dass alle Legacy-Symbole der C-Bibliotheken Ihren globalen Namespace verschmutzen

(§§) zu erkennen, dass "Sie einen Header einfügen müssen, das Einfügen dieses Headers jedoch Ihren Code beschädigt, weil ein dummes Makro mit einem generischen Namen verwendet wird", ist einer dieser russischen Roulette- Momente im Leben eines Codierers

'Dies.' hilft bei der Suche nach Mitgliedern in dieser Klasse mit vielen Mitgliedern (normalerweise aufgrund einer tiefen Vererbungskette).

Das Drücken von STRG + Leertaste hilft dabei nicht, da es auch Typen enthält. wo-als "das". schließt NUR Mitglieder ein.

Normalerweise lösche ich es, sobald ich das habe, wonach ich gesucht habe: aber das ist nur mein Stil, der durchbricht.

In Bezug auf den Stil entscheiden Sie, wenn Sie ein Einzelgänger sind; Wenn Sie für ein Unternehmen arbeiten, halten Sie sich an die Unternehmensrichtlinien (sehen Sie sich die Informationen in der Quellcodeverwaltung an und sehen Sie, was andere Personen tun). In Bezug auf die Verwendung zur Qualifizierung von Mitgliedern ist weder richtig noch falsch. Das einzig Falsche ist Inkonsistenz - das ist die goldene Regel des Stils. Lassen Sie die Nit-Picking andere. Verbringen Sie Ihre Zeit damit, über echte Codierungsprobleme nachzudenken - und natürlich über das Codieren -.

Ich benutze es jedes Mal, wenn ich kann. Ich glaube, es macht den Code lesbarer und besser lesbarer Code bedeutet weniger Fehler und mehr Wartbarkeit.

Wenn Sie viele Entwickler sind, die an derselben Codebasis arbeiten, benötigen Sie einige Coderichtlinien / -regeln. Wo ich arbeite, haben wir beschlossen, "dies" für Felder, Eigenschaften und Ereignisse zu verwenden.

Für mich ist es sinnvoll, dies so zu tun. Es erleichtert das Lesen des Codes, wenn Sie zwischen Klassenvariablen und Methodenvariablen unterscheiden.

Das hängt von dem Codierungsstandard ab, unter dem ich arbeite. Wenn wir _ verwenden, um eine Instanzvariable zu bezeichnen, wird "dies" redundant. Wenn wir _ nicht verwenden, neige ich dazu, dies zu verwenden, um Instanzvariable zu bezeichnen.

Ich benutze es, um Intellisense genau wie JohnMcG aufzurufen , aber ich gehe zurück und lösche "this->", wenn ich fertig bin. Ich folge der Microsoft-Konvention, Mitgliedsvariablen "m_" voranzustellen, daher wäre es nur überflüssig, sie als Dokumentation zu belassen.

1 - Allgemeine Java-Setter-Sprache:

 public void setFoo(int foo) {
     this.foo = foo;
 }

2 - Beim Aufruf einer Funktion mit diesem Objekt als Parameter

notifier.addListener(this);

Es gibt eine Verwendung, die in C ++ noch nicht erwähnt wurde und die nicht darin besteht, auf das eigene Objekt zu verweisen oder ein Mitglied von einer empfangenen Variablen zu unterscheiden.

Sie können thiseinen nicht abhängigen Namen in einen argumentabhängigen Namen innerhalb von Vorlagenklassen konvertieren, die von anderen Vorlagen erben.

template <typename T>
struct base {
   void f() {}
};

template <typename T>
struct derived : public base<T>
{
   void test() {
      //f(); // [1] error
      base<T>::f(); // quite verbose if there is more than one argument, but valid
      this->f(); // f is now an argument dependent symbol
   }
}

Vorlagen werden mit einem Zwei-Pass-Mechanismus kompiliert. Während des ersten Durchlaufs werden nur nicht argumentabhängige Namen aufgelöst und überprüft, während abhängige Namen nur auf Kohärenz überprüft werden, ohne die Vorlagenargumente tatsächlich zu ersetzen.

In diesem Schritt hat der Compiler, ohne den Typ tatsächlich zu ersetzen, fast keine Informationen darüber, was sein base<T>könnte (beachten Sie, dass die Spezialisierung der Basisvorlage sie in völlig andere Typen verwandeln kann, sogar in undefinierte Typen), sodass er lediglich davon ausgeht, dass es sich um einen Typ handelt . Zu diesem Zeitpunkt ist der nicht abhängige Aufruf f, der dem Programmierer nur natürlich erscheint, ein Symbol, das der Compiler als Mitglied derivedoder in eingeschlossenen Namespaces finden muss - was im Beispiel nicht vorkommt - und er wird sich beschweren.

Die Lösung besteht darin, den nicht abhängigen Namen fin einen abhängigen Namen umzuwandeln. Dies kann auf verschiedene Arten geschehen, indem der Typ, in dem es implementiert ist, explizit angegeben wird (- Durch base<T>::fHinzufügen von base<T>wird das Symbol abhängig, Tund der Compiler geht nur davon aus, dass es vorhanden ist, und verschiebt die eigentliche Prüfung für den zweiten Durchgang danach Argumentersetzung.

Der zweite Weg, viel sortierter, wenn Sie von Vorlagen erben, die mehr als ein Argument oder lange Namen haben, ist das Hinzufügen eines this->vor dem Symbol. Da die von Ihnen implementierte Vorlagenklasse von einem Argument abhängt (von dem sie erbt base<T>), this->ist sie argumentabhängig, und wir erhalten das gleiche Ergebnis: this->fWird in der zweiten Runde nach dem Ersetzen der Vorlagenparameter überprüft.

Sie sollten "dies" nicht verwenden, es sei denn, Sie müssen unbedingt.

Es gibt eine Strafe, die mit unnötiger Ausführlichkeit verbunden ist. Sie sollten nach Code streben, der genau so lang ist, wie er sein muss, und nicht mehr.