Ich habe eine kleine Frage, vielleicht könnt ihr mir da behilflich sein.

Ich verwende das struct COORD aus der windows.h:

typedef struct _COORD {
  SHORT X;
  SHORT Y;
} COORD, *PCOORD;

Dieses nutze ich als Membervariable einer Klasse: m_dwPos
Die Werte X und Y möchte ich nun über den Konstruktor möglichst geschickt zuweißen. Bei einfachen Datentypen kann man ja diese verkürzte Form nutzen: (Angenommen meine Membervariablen wären vom Typ short.)

CTest::CTest(short nX, short nY) :
    m_nX(nX),
    m_nY(nY)
{
}

Kann man dies auch irgendwie für ein struct nutzen oder ist es hier eine derarte Implementierung geschickter:

CTest::CTest(short nX, short nY)
{
    this->m_dwPos.X = nX;
    this->m_dwPos.Y = nY;
}

Dann hätte ich noch eine kleine Verständnisfrage:
In der Implementierung der Klassenfunktionen nutze ich stehts den this->-Zeiger um auf Klassenvariablen etc. zuzugreifen, da dadurch ja das aktuelle Objekt/Instanz der Klasse angesprochen wird. Ist das korrekt?
Oder ist es sauberer diese mittels Klassenname:: aufzurufen?`

Vielen Dank schonmal für eure Hilfe.

struct Klasse
{
    static int statischeVariable;
    int    nichtstatischeVariable;

    void tuWasGeniales(int);
};

int Klasse::statischeVariable = 18;

void machIrgendwas(Klasse*);

void Klasse::tuWasGeniales(int v)
{
     nichtstatischeVariable = v;
     //oder
     this->nichtstatischeVariable = v;

     statischeVariable = 23823;

     machIrgendwas(this);
}

Die Werte X und Y möchte ich nun über den Konstruktor möglichst geschickt zuweisen.

Ne das geht leider nicht, da die Struktur keinen Konstruktor hat, der Werte entgegennimmt

SilverOne06 schrieb:

Dann hätte ich noch eine kleine Verständnisfrage:
In der Implementierung der Klassenfunktionen nutze ich stehts den this->-Zeiger um auf Klassenvariablen etc. zuzugreifen, da dadurch ja das aktuelle Objekt/Instanz der Klasse angesprochen wird. Ist das korrekt?
Oder ist es sauberer diese mittels Klassenname:: aufzurufen?`

Du kannst auch alles davor weglassen, also einfach nur "m_dwPos.X = ..." schreiben; dein Kürzel m_ sollte ja schon darauf hinweisen, dass es eine Member-Variable ist (für das visuelle Argument).

SilverOne06 schrieb:

Vielen Dank schonmal für eure Hilfe.

Gern geschehen

edit: Mist, a little too late..

CTest(short nX, short nY) : m_dwPos(x, y)

...aber das geht bei der COORD-Struktur leider nicht, da kein expliziter Konstruktor dafür definiert wurde. Von daher ist Deine Lösung mit der Wertzuweisung an jedes einzelne Element der COORD-Struktur innerhalb Deines Klassenkonstruktors schon richtig so, allerdings kannst Du in dem Fall this weglassen. (Siehe obige Erklärung)

CTest::CTest(short nX, short nY)
{
    m_dwPos.X = nX;
    m_dwPos.Y = nY;
}

Edit: Mist, noch mehr little to late! :p

Das mit dem this Zeiger sieht in Kombination mit dem Prefix wirklich etwas übertrieben aus. ^^ Ich steh eben noch ziemlich am Anfang und da möcht ich mir nicht gleich was unschönes bzw. falsches angewöhnen, deswegen wollt ich das mal bestätigt haben.

Das mit dem this Zeiger sieht in Kombination mit dem Prefix wirklich etwas übertrieben aus. ^^ Ich steh eben noch ziemlich am Anfang und da möcht ich mir nicht gleich was unschönes bzw. falsches angewöhnen, deswegen wollt ich das mal bestätigt haben.

Sieh es so... Was unschön ist lässt sich hierbei streiten.

Ich persönlich habe mich schon seit langer Zeit von der UN (Ungarischen Notation) die du hier verwendest, verabschiedet [Gründe gibt es viele, und du wirst hierzu viele Pros und Contras hören]. Und dann kann this-> Sinn machen.

Wenn du der UN treu bleiben willst, bitte ich dich nur um eins: verwende trotz der Präfixe bitte sprechende Namen.

Dein Beispiel ohne UN:

Test::Test(short xPosition, short yPosition) // Oder wenn aus Kontext ersichtbar: nur x statt xPosition
{
    this->position.X = xPosition;
    this->position.Y = yPosition;
}

Überleg dir selber was du als lesbarer im Code empfindest.

Zu 1.)
Man könnte zwar folgendes machen:

CTest(short nX, short nY) : m_dwPos(x, y)

...aber das geht bei der COORD-Struktur leider nicht, da kein expliziter Konstruktor dafür definiert wurde.

Da ist soweit richtig aber nicht zu Ende gedacht. Es gibt schließlich noch andere Methoden, die in einem geeignet initialisierten Objekt resultieren. Falls uns eine spezielle Memberfunktion (a.k.a. Konstruktor) nicht zur Verfügung steht, behelfen wir uns eben mit einer normalen Funktion:

COORD make_COORD(short nX, short nY)
{
    COORD x = { nX, nY };
    return x;
}

CTest(short nX, short nY) : m_dwPos(make_COORD(x, y)) {}

Das ist nur geringfügig ausführlicher, als ein Konstruktor es wäre, und kein bisschen weniger effizient.

Ich bin mir selbst noch nicht ganz sicher, ob ich die UN nun verwenden möchte oder nicht. Dadurch wird natürlich alles etwas kryptischer und der Einwand mit den sprechenden Namen ist berechtigt, werd ich in Zukunft berücksichtigen.

Habt ihr vielleicht ein paar Seiten bzw. Theards mit Vorschlägen zu Konventionen, die ihr vllt. sogar selbst so übernehmt? Klar, das ist natürlich jedem selbst überlassen und ich denke mal, mit der Zeit entwickelt man sicherlich auch etwas seinen eigenen Stil, nur am Anfang ist es nicht schlecht, wenn man was hat, an das man sich halten kann.
Also nur für den Fall das jemand gerade was passendes zur Hand hat, Google etc. werde ich natürlich selber bemühen.

@camper, ist natürlich eine Lösung. Danke. Aufjeden Fall gut das Konzept im Hinterkopf zu haben.

Also nur für den Fall das jemand gerade was passendes zur Hand hat, Google etc. werde ich natürlich selber bemühen.

Schau dir mal den folgenden Artikel an (Interessant sind imho hauptsächlich der Punkt Kritik und die Links die sowohl die UN positiv wie auch negativ darstellen):
http://de.wikipedia.org/wiki/Ungarische_Notation
(Mein Eigener Stil ähnelt den Namenskonventionen wie in C#, die dort auch als Link aufgeführt sind).

Wegen Benennungen ohne UN: In der Regel wird einfach sprechend benannt, manche lassen einen kleinen UN-Bruchstück bestehen (so etwas wie m_ für Member oder p_ für Zeiger) andere benutzen hier teilweise das this-> (Was unter VC den Vorteil hat das man die Member meist auch zur Auswahl bekommt ;p).

Und ja, sowas wie Präfixe habe ich (sehr selten zwar) auch... Bei boolischen Variablen steht z.B. bei mir meist ein "is" davor (isNew, isEmpty) da ich das als allgemein lesbar empfinde und Ausdrücke wie "if(isNew)" fast schon wie normale Sprache lesbar sind.

cu André