offizielle Aufgabenstellung:
m)Lege nun eine eigene Klasse Main mit der main() Methode an und definiere 2 Instanzen
der Klasse Mitglied in main().
n) Definiere eine weitere Klasse Verein. Diese hat als Instanzvariablen die Anzahl der
Mitglieder und ein Array aus Objekten der Klasse Mitglieder.
Hinweis: Das Array soll immer nur so groß sein wie Mitglieder eingetragen wurden.
o) Schreibe (in Verein) eine Methode add() mit der man ein (bereits instanziertes)
Objekt der Klasse Mitglied zum Verein hinzufügen kann (wird ans Ende des Arrays
kopiert).

da steh ich an:

class CMain{		

	public:
		void main();
};

void CMain::main(){

	CMitglieder Mitglied1;
	CMitglieder Mitglied2;
}

class Verein{

	private:
		CMitglieder m_Array[2];
		int m_iAnzahl;

	public:
		void add(???);
};

void Verein::add(???){

	for(int i=0; i<m_iAnzahl; i++){
		//checks nicht mehr
}

Wie muss ich das schreiben das es den Fragestellungen gerecht wird, also ohne vektoren u.s.w.
Versuche schon seit Stunden es zu lösen und bin schon ziemlich am Ende mit den Denken.
Für die Fragenstellung o habe ich überhaupt keinen vernünftigen Ansatz. Man Mit einer Arraylösung fällt mir nur das Schlüsselwort new ein, um dynamisch zu bleiben, nur weis ich nicht wie das funktionieren soll, ein BEREITS instanziertes Objekt an ein dynamisches Array zuzufügen.

Das viele Kopieren ist natürlich wahnsinnig ineffizient bei großen Arrays (deswegen fordert der richtige std::vector immer mehr Speicher an als er braucht, dann muss er nicht so oft alles kopieren), aber anders kannst du die Klausel in der Aufgabenstellung nicht erfüllen.

Wie bekomme ich die Anzahl der Instanzen im Array heraus um anschließend das neue Array 1 größer zu machen?

Angemerkt sei noch: Es ist unmöglich, bei einem Zeiger auf ein Array die Anzahl der Elemente im Array rauszufinden, deshalb muss man sich die Anzahl bei dynamischen Arrays immer irgendwo abspeichern.

Ne, hab ich nicht, diese Var ist noch nicht initialisiert

Dafür wurden Konstruktoren erfunden. Beim Erzeugen von Verein setzt du den Wert auf 0. Du musst beim add() natürlich nochmal aufpassen, wenn du das alte Array löscht, ob es überhaupt schon vorhanden war.

Noch was, musst du nicht aufpassen, dass der Destruktur aufgerufen wird ? Bei der Zuweisung (vorausgesetzt der Operator = ist nicht überladen) dürfte nur die Adresse kopiert werden...

void add()
{
    CMitglieder temp;
    m_Array[num]=temp;
} //Wird hier nicht der Destruktor von m aufgerufen ?

Bei der Zuweisung (vorausgesetzt der Operator = ist nicht überladen) dürfte nur die Adresse kopiert werden...

Der Threadersteller sollte wohl besser ohnehin einen eigenen Kopierkonstruktor, Zuweisungsoperator und Destruktor schreiben, sonst birgt seine Klasse reichlich Fehlerpotential für den Benutzer.

void add(CMitglieder m)
{
    //...
}

sollte es eigentlich auch Probleme geben...

using namespace std;

class CVerein{

	private:
	CMitglieder *pMitglieder;
	int m_iAnzahl;

	public:
		void add();
		CVerein();
};

void CVerein::add(){

	m_iAnzahl++;
	pMitglieder=new CMitglieder[m_iAnzahl];

	for(int i=0; i<m_iAnzahl; i++){
		pMitglieder[i]= keine Ahnung

	}
	delete[] pMitglieder;
        pMitglieder=NULL;
}

CVerein::CVerein(){
	CMitglieder *pMitglieder=NULL;
	m_iAnzahl=0;
}

Kann mir wer zeigen wie das mit den kopieren und den Zeiger neu setzten geht?

class CVerein{

    private:
    CMitglieder* (*pMitglieder);
    int m_iAnzahl;

    public:
        void add();
        CVerein();
};

void CVerein::add(CMitglieder*m){

    CMitglieder* (*pMitgliederTemp)=new CMitglieder*[m_iAnzahl];
    int i;
    for(i=0;i<m_iAnzahl;i++)
    {
        pMitgliederTemp[i]=pMitglieder[i];
    }
    delete[] pMitglieder;

    m_iAnzahl++;
    pMitglieder=new CMitglieder*[m_iAnzahl];

    for(i=0; i<m_iAnzahl-1; i++){
        pMitglieder[i]= pMitgliederTemp[i];

    }
    pMitglieder[i]=m;
    delete[] pMitgliederTemp;

}

CVerein::CVerein(){
    pMitglieder=NULL;
    m_iAnzahl=0;
}

So ungefähr würde ich das machen...
Probleme:
- 1. Mitglied, reservierter Speicher 0, ich weiß nicht ob das Probleme gibt, aber das must du lösen :p

Was ist das für eine Schreibweise CMitglieder* (*pMitglieder);? Habe ich noch nie gesehen. Pointer Pointer??

Bedeutet das hier, pMitglieder=new CMitglieder*[m_iAnzahl]; oder void CVerein::add(CMitglieder *Mitglied), ein Pointer erwartet wird?

Bedeutet das hier, pMitglieder=new CMitglieder*[m_iAnzahl]; oder void CVerein::add(CMitglieder *Mitglied), ein Pointer erwartet wird?

Genau. Der Funktion "add" wird ein Pointer übergeben, um das Problem mit dem Destruktor zu lösen; und dieser Pointer wird in dem Array gespeichert.

Die Objekte legst du dann so an:

CVerein verein;
CMitglieder* MitgliedNr1 = new CMitglieder();
CMitglieder* MitgliedNr2 = new CMitglieder();

verein.add(MitgliedNr1);
verein.add(MitgliedNr2);

@franz-21,
Die grundsätzliche Vorgehensweise über das temporäre Array, wie es Darkshadow44 gemacht hat, ist schon korrekt. Aber naja, es stimmt einiges anderes überhaupt nicht.

class Verein
{
private:
  Mitglied* m_mitglieder;
  int m_anzahl;

public:
  Verein();
  ~Verein();

  void add(Mitglied const& mitglied);
};

Verein::Verein()
  : m_mitglieder(NULL)
  , m_anzahl(0)
{
}

Verein::~Verein()
{
  delete[] m_mitglieder;
}

void Verein::add(Mitglied const& mitglied)
{
  Mitglied* altMitglieder = m_mitglieder;
  m_mitglieder = new Mitglied[m_anzahl + 1];

  for(int i = 0; i < m_anzahl; ++i)
  {
    m_mitglieder[i] = altMitglieder[i];
  }

  m_mitglieder[m_anzahl] = mitglied;
  ++m_anzahl;

  delete[] altMitglieder;
}

Damit die Klasse Verein noch sinnvoll verwendet werden kann, musst du noch einen Zuweisungsoperator und den Kopierkonstruktor dafür schreiben.

Grüssli

void operator=(const Vector &derAndereVector)  //für was steht operator= ?
   {
      delete[] m_data;
      m_size=derAndereVector.m_size;
      m_data=new double[m_size];
      for(int i=0;i<m_size;++i)
         m_data[i]=derAndereVector.m_data[i];
   };

Grüssli

Vector a;
Vector b;
//tuwas
b=a;//<--Hier

1. Wozu diese Klammern? Die sind völlig unnötig.

Ups. Keine Ahnung warums vorhin ohne nicht ging

Dein präsentierter Code erfüllt die Aufgabenstellung nicht mehr. Es steht explizit, dass Objekte von Mitglieder gespeichert werden müssen und nicht Zeiger davon. Zudem soll das übergebene Objekt ans Ende des Array kopiert werden und nicht ein Zeiger darauf gespeichert.

Sorry, habe ich überlesen.

3. Bitte Intialisierungslisten im Konstruktor verwenden.

Warum ? Die Anzahl muss 0 werden und der Pointer NULL.

4. Du brauchst ein unnötiges temporäres Array zuviel.

Da denke ich zu kompliziert

Verein ist eine Art von Containerklasse, verhält sich aber überhaupt nicht so, was die Besitzverhältnisse betrifft.

Wie meinst du das ?

Überladung von Operatoren in C++

Grüssli

Ich mein mit Übungen, das ist ein Bisschen trocken

Wenn du so willst, ist C++ trocken. Operatorüberladung ist nämlich reines C++, und Theorie gehört eben dazu.