structs in structs oder doch struct in klasse?

Hallo,

ich möchte eine klasse/struktur bilden, wobei bei der sowieso alles public sein wird. (sinn außen vor gelassen)

Jetzt würde ich gerne wissen ob es besser ist eine struct in einer struct zu verwenden oder eher eine klasse die eine struct verwendet?
Oder gar nur Klassen?

Für structures kann man ja Heap so alloziieren:

struct line {...};
  line l = (line *) malloc(sizeof(line));

Kann man denn auch von KLassen sowas machen?

oder wie ist das dann analog wenn ich für eine Klasse speicher reservieren will?

Wie ist denn so das prinzipielle vorgehen?
Danke

Braunstein

Hallo,

Auch bei structs sollte man bei C++ new statt malloc verwenden. Structs und Klassen sind bei C++ fast das Gleiche. Der einzige Unterschied liegt im default-Gültigkeitsbereich der Member. Der ist bei Structs public und bei Klassen private.
Also können bei C++ Structs auch Memberfunktionen, Konstruktor, Destruktor, Operatoren etc. haben. man kann erben usw.

darthdespotism

new - new[] allokiert genauso auf dem Heap
Structs und Klassen sind /identisch/ außer dem default-Public der structs
Mit malloc() kannst du sowohl structs als auch calsses nur allokieren wenn diese POD sind

akari

Hallo

In C++ ist der einzige Unterschied zwischen class und struct die Standard-Sichtbarbeit der Member. Demzufolge kannst du dir auch aussuchen was du nimmst.
Nicht verwenden solltest du aber malloc und Co., dafür gibts in C++ new und delete. Dann klappts auch mit den Konstruktoren.

/Edit : zu langsam...

bis bald
akari

Danke euch - macht es z.B Sinn für nur 3 Datenwerte die aber zusammengehören ne eigene Klasse anzulegen? Eher sinnvoller da ein struct zu bauen oder nicht?

Ist es üblich das man in einer Klasse andere KLassen verwendet - also z.B so:

#include "Class2.h"
#include "Class3.h"

Class class1
{
   Class();
   ~Class();

    Class2 cl2;
    Class3 cl3;
};

Braunstein

Wenn man nur drei Datenwerte kapseln möchte, würde ich eine struct nehmen.
Ja, es ist durchaus üblich Klassen in anderen Klassen zu verwenden.

struct struct1
{
   Class();
   ~Class();

    Class2 cl2;
    Class3 cl3;
};

Konstruktor und Destruktor sollte man aber nur anlegen wenn man ihn wirklich braucht. Ansonsten erledigt das der Compiler für dich schon sehr schön.

Konstruktor und Destruktor sollte man aber nur anlegen wenn man ihn wirklich braucht.

echt? ich dachte ein leerer konstruktor sollte immer vorhanden sein.
Wenn wir schon dabei sind: Wie soll ich denn dann ein Objekt instantiieren wenn ich keinen Konstruktor habe?

also wie sollte ich eine Methode einer Klasse aufrufen können?

Class c = Class::Class();
c.my_method();

Braunstein

Wenn du keinen Konstruktor definierst macht das der Compiler für dich. Du kannst also ganz normal mit deiner Klasse arbeiten.

Class c; //hierbei wird der Konstruktor auch aufgerufen
c.my_method();

und das macht man auch so normalerweise? Klassen ohne Konstruktor?

Simon2

gast_xy schrieb:

und das macht man auch so normalerweise? Klassen ohne Konstruktor?

Neee, das hast Du mißverstanden: Klassen haben immer einen Konstruktor (egal, ob man sie mittels "class" oder mittels "struct" definiert) - aber der Compiler stellt automatisch einen Default- einen Copy-Konstruktor und einen operator=() zur Verfügung, wenn er keine selbstdefinierten findet (Achtung: Sobald er EINEN selbstdefinierten Konstruktor mit Argumenten findet, legt er keinen DefaultCTor mehr automatisch an).

Beispiel:

struct A0 { // keine selbstdefinierten CToren
};

struct A1 { // selbstdefinierter DefCTor
   A1() {}
};

struct A2 { // selbstdefinierter CopyCTor
   A2(const A2&) {}
};

struct A3 { // selbstdefinierter parametrisierter CTor
   A3(int) {}
};

template <typename A> // Bin faul, deswegen als Funktionstemplate
void checkCTors() {
   A a;    // Default-Konstruktion
   A b(a); // Copy-Konstruktion
   b = a;   // Zuweisung
}  

int main (int argc, char **argv)
{
   checkCTors<A0>();   // OK
   checkCTors<A1>();   // OK
   checkCTors<A2>();   // Fehler: Kein DefaultKonstruktor 
   checkCTors<A3>();   // Fehler: Kein DefaultKonstruktor
   return 0;
}

... und da die compilergenerierten Konstruktoren "Standardverhalten" zeigen, reicht das üblicherweise aus.

Sowas Ähnliches das hast Du übrigens bestimmt schonalk genutzt, ohne es zu wissen: Der Compiler reichert auch automatisch die Initialisierungsliste von Konstruktoren an. So macht er aus

struct A : public B {
   A() { cout << "Alles klar"; }
   string s;
};

automatisch:

struct A : public B {
   A() 
      : B(), // Defaultkonstruktor des Basisklasse
        s()  // Defaultkonstruktor des Elements
   { cout << "Alles klar"; }
   string s;
};

Gruß,

Simon2.