Hallo,

in letzter Zeit schreibe ich in C++ aus Faulheit die Funktionsimplementierung direkt in die Klassendefinition rein. Das sieht in etwa so aus:

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

class Test { public:   Test(int _a)   {     a = _a;   }   ~Test()   {   }   int GetA()   {     return a;   } private:     int a; };

statt:

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

class Test { public:   Test(int _a);   ~Test();   int GetA(); private:     int a; };   Test(int _a) {   a = _a; }   ~Test() { }   int GetA() {   return a; }

Ich habe irgendwo gelesen, dass es dabei einen technischen Unterschied gibt, nur hab ich ihn leider vergessen...

Gibt es einen Grund wieso man generell nicht so machen sollte?

mfg
Kaiser206

Hi.

Wenn du die Implementierung der Methoden in der Klassendefinition vornimmst, bedeutet das, das alle Methoden automatisch inline sind.

D.h. jede Übersetzungseinheit die diesen Header (bzw. diese Klassendef.) nutzt wird eine eigene Kopie der Methodenimplemtierungen erhalten. (je nachdem ob der Compiler entscheidend den Code "inline" zu verwenden).

Einerseits verlängert das die Kompilierzeit, andereseits ist es dann möglich das verschiedene Objektdateien unterschiedliche Versionen des Codes haben, was dann evtl. später wieder zu unerklärlichen Abstürzen führen könnte. Letztlich kann es auch neg. Auswirkungen auf die Laufzeit haben.

Auf der anderen Seite sind inline Methoden auch recht nützlich, z.B. wenn es sich um nur eine return Anweisung handelt wie in der GetA Methode, da man sich dadurch einen Funktionsaufruf sparen kann. Wobei es manchmal nicht ganz offensichtlich ist, ob eine Methode "teuer" ist oder nicht.

Virtuelle Methoden können beim Aufruf über eine Referenz oder Zeiger sowieso nicht inline behandelt werden oder wenn man einen Zeiger auf eine inline Methode benötigt muss der Compiler sogar zusätzlich noch eine Methode generieren.

Grundsätzlich solltest du aber die Initialisierungslisten beim Konstruktor verwenden.

Gruß

Code cpp:

1 2 3 4 5 6 7 8 9 10 11

class Test {     int m_value;   public:     Test(const int value = 0)         : m_value(value)     {}       const int get_value() const { return m_value; } };

find ich doch schöner Default-D-tor braucht man nicht extra angeben. const is doch auch mal schön, oder? :P und bezeichnernamen mit a ... nja i do not like it sollte etw. eindeutiger sein ...

Ich nutze für get() und set() sehr häufig diese inline-Technik.
Ist jetzt vielleicht off-topic, kann man in VC++ Makros entwickeln, die dabei helfen?
Ich träume jetzt mal ein wenig. Man schreibt eine leere Klasse, z.B. so:

Code :

1 2 3

class Sohn : public Verwandter {   };

Dann würde ich den Cursor gern in die Klasse setzen, dann ein Makro namens "constructors" aufrufen, dass dann folgendes an Cursorposition einfügt:

Code :

1 2 3 4

public:   Sohn() ;   Sohn(const Sohn& c);   ~Sohn();

Und ich träume weiter. Makro "operator=":

Code :

1 2 3 4 5 6

Sohn& operator= (const Sohn& c) {   if (&c != this) {       }   return *this; }

Makro "VariableReadWrite"

Code :

1 2 3 4 5

private:   int A; public:   int GetA() const { return A; }   void SetA(int new_A) { A = new_A; }

Ist sowas machbar? Mann, würde das Schreibarbeit sparen!

Hallo Onkel Schuppig,

machbar wäre das zwar schon, nur die Lesbarlkeit des Quelltextes würde meiner Meinung nach darunter leiden.

Hier ein Beispiel:

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

// Konstruktor #define CONSTRUCTOR(x)                          \     public:                                     \         x();                                    \         x(const x& _x);                         \         ~x();   // Zuweisungsoperator #define OP_ASSIGN(x)                            \     public:                                     \         x& operator = (const x& _x) {           \             if (&_x != this) {                  \             }                                   \             return *this;                       \         }   // Get/Set Methode #define GET_SET(funcGet, funcSet, type, var)    \     private:                                    \         type var;                               \     public:                                     \         type funcGet() const { return var; }    \         void funcSet(type _v) { var = _v; }       // Klasse zum testen class CTest {     // Konstruktor     CONSTRUCTOR(CTest)     // Zuweisungsoperator     OP_ASSIGN(CTest)     // Variable und Get/Set-Methode     GET_SET(GetA, SetA, int, A) };

Beste Grüße,
Jacal

Hi.

Zitat von Jacal

machbar wäre das zwar schon, nur die Lesbarlkeit des Quelltextes würde meiner Meinung nach darunter leiden.

Ich glaube Onkel Schuppig meinte keine C Makros, sondern Makros für die Visual C++ IDE die ihm einfach die Tipparbeit abnehmen.

Für andere Sprachen (C#, VB.NET) kann man sich ja im Studio Snippets bzw. Templates einrichten. Für C++ gibt es diese Möglichkeit (noch) nicht.

Allerdings müßte man ja erstmal die umgebende Klasse analysieren, um den Namen herauszufinden. Aber machbar wäre das sicherlich schon.

Gruß

Danke Jungs (oder Mädels), auf Präprozessor-Definitionen wäre ich gar nicht gekommen. Aber ich möchte den Code nicht wie eine andere Sprache aussehen lassen. Vielleicht bastele ich mir ein Makro mit Dialog, wo ich nur den Klassennamen eingebe und dann über Checkboxes ankreuze, was ich möchte. Schaumer mal ...