Konflikte zwischen den Mitgliedsnamen und Konstruktorargument Namen

Question

Mögliche Duplizieren:
Members vs method arguments access in C++

Ich habe eine Klasse, die einige Mitglieder, wie x, y, width und height. In seinem Konstruktor, ich würde das nicht tun:

A::A(int x, int y, int width, int height) 
{ 
    x = x; 
    y = y; 
    width = width; 
    height = height; 
} 

Das ist wirklich nicht sinnvoll ist und wann mit g ++ kompiliert x, y, width und height werden seltsame Werte (z -1405737648).

Wie können diese Namenskonflikte optimal gelöst werden?

Answer 1

Sie können Initialisierung Listen ganz gut mit den gleichen Namen verwenden:

A::A(int x, int y, int width, int height) : 
    x(x), 
    y(y), 
    width(width), 
    height(height) 
{ 
} 

Eine Alternative ist, verschiedene Namen zu verwenden, wenn Sie die gleichen Namen haben nicht wollen. Einige Ungarisch-Notation Variation in den Sinn kommt (ich könnte einige Hass dafür bekommen):

//data members 
int x_; 
int y_; 
int width_; 
int height_; 
//constructor 
A::A(int x, int y, int width, int height) : 
    x_(x), 
    y_(y), 
    width_(width), 
    height_(height) 
{ 
} 

Aber es ist nichts falsch mit dem ersten Vorschlag.

Answer 2

Obwohl Sie das Problem vermeiden können, indem Sie die Initialisierungsliste des Konstruktors verwenden, schlage ich vor, eine Konvention für die Benennung von Datenelementen zu befolgen, zum Beispiel eine nachlaufende _ oder eine führende m_. Sonst sind Namenskonflikte sehr wahrscheinlich, besonders wenn Sie Mitglieder mit Namen wie x und y haben.

class A 
{ 
    public: 

    A(int x, int y, int width, int height) : x_(x), y_(y), with_(width), height_(height) {} 

    int x_; 
    int y_; 
    int width_; 
    int height_; 
}; 

Answer 3

Wenn müssen Sie Zuweisungen im Konstruktor verwenden (wie auf die Verwendung einer Liste von Initialisierungen gegenüber, die bevorzugt wird) das spezifische Muster dieses Problem zu beheben ist this Zeiger zu verwenden, wie folgt:

this->a = a; 

Answer 4

Sie können nur die Namen der Konstruktorargumente ändern. Wenn Sie

A::A(int x, int y, int width, int height) 
{ 
    x = x; 
    y = y; 
    width = width; 
    height = height; 
} 

schreiben dann bist du die Argumente der Konstruktor selbst zuweisen, die tatsächlichen Instanzvariablen verlassen nicht initialisiert, das ist, warum Sie falsche Werte zu bekommen.

Die allgemeine Lösung schlage ich vor (und verwende allgemein) ist den Namen der Argumente der Konstruktor-Methode zu ändern:

A::A(int x_initial, int y_initial, int width_initial, int height_initial) 
{ 
    x = x_initial; 
    y = y_initial; 
    width = width_initial; 
    height = height_initial; 
} 

Answer 5

Wenn möglich, ist es besser, Datenelemente über die Initialisiererliste zu setzen, In diesem Fall gibt es kein Problem mit Argumenten, die die Membernamen überschatten. Eine weitere Alternative ist die Verwendung von this->foo = foo; im Body des Konstruktors. Ein ähnliches Problem besteht für Setter, aber jetzt können Sie die Initialisiererlistenlösung nicht mehr verwenden. Sie stecken fest mit this->foo = foo; - oder einfach andere Namen für Argumente und Mitglieder.

Einige Leute hassen Argumente, die Datenmitglieder schatten; Mehrfache Kodierungsstandards sagen explizit, dies nie zu tun. Andere denken, dass diese Art von Beschattung, zumindest für Konstrukteure und Setter, das Miauen der Katze ist. Ich erinnere mich an das Lesen von ein oder zwei Codierungsstandards (aber ich erinnere mich nicht daran), die diese Art von Shadowing als "sollte" (aber nicht "soll") praktizieren.

Eine letzte Option besteht darin, Shadowing in der Funktionsdeklaration zu verwenden, um Lesern einen Hinweis darauf zu geben, was die Funktion macht, aber unterschiedliche Namen in der Implementierung zu verwenden.

Update: Was ist "Shadowing"?

#include <iostream> 

void printi (int i) { std::cout << "i=" << i << "\n"; } 

int i = 21; 

int main() { 
    printi (i); 
    int i = 42; 
    printi (i); 
    for (int i = 0; i < 3; ++i) { 
     printi (i); 
     int i = 10; 
     printi (i); 
    } 
    printi (i); 
} 

Die innerste Erklärung i, int i=10, shadows die Variable i in der for Anweisung deklariert, was wiederum die Variable i bei Funktionsumfang erklärt Schatten, die wiederum i die globale Variable Schatten.

Im Problem auf der Hand, die Argumente x, y, width und height auf den Nicht-Standard-Konstruktor für die Klasse A Schatten der Mitgliedsdaten mit den gleichen Namen wie die Argumente.

Ihre width=width; hat nichts getan, weil das Argument width das Datenelement width schattiert (versteckt). Wenn Sie zwei oder mehr Variablen mit demselben Namen haben, die in verschiedenen Bereichen deklariert wurden, ist der Gewinner immer der Name mit dem innersten Gültigkeitsbereich. Im Allgemeinen gewinnt immer der Name mit dem innersten Umfang.