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

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.

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

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;
};

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();

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

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.