Hallo zusammen,
Ich bin C++ Anfänger, ich hoffe jemand mir helfen kann.
Die Aufgabe:
Entwickeln Sie eine Klasse für ein dynamisches Array. Allerdings soll bei Überlauf nicht das gesamte Array neu alloziert werden, sondern es soll nur Platz für 20 neue Arrayelemente geschaffen werden. Die verschiedenen Teile des Arrays sollen mittels einer Liste zusammengehalten werden. Auf diese Art kann man sich das aufwändige Kopieren der Arrayelemente beim Vergrößern ersparen. Implementieren Sie einen Kopierkonstruktor und einen Zuweisungsoperator für diese Art von dynamischen Arrays.

Ich mach die Aufgabe einfacher, nehme ich ein stringarray, struct statt class und eine fixe array in der Liste mit 21 elemente (20 + ’\0’) statt eine dynamische array.
Dann habe ich generell das Problem, wie ich das array mit 20 elemente füllen kann?
Ich habe 2 Möglichkeiten, entweder ist die Liste leer (am Anfang) oder ist was drinnen. Wenn sie leer und die Eingabe kleiner als 20 ist, ist easy. Ich habe das Problem mit Eingaben, die länger als 20 sind oder wenn die Liste nicht leer ist.

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;

#define MAX 21	   //Stringlaenge zum speichern
#define Laenge 50	//50 Zeichenlenge zum lesen, kann geändert werden

struct List{
   char daten[MAX]; //Daten werden reingeschrieben

   struct List *anfang;
   struct List *next;
};
//----------------------------------
struct List *next   = NULL;
struct List *anfang = NULL;

void anhaengen(char *d) {
   struct List *zeiger;

   if(anfang == NULL) { //gleich am Anfang ist die Liste leer

      if((anfang = (struct List *)
		  malloc(sizeof(struct List))) == NULL) {
         cout << stderr, "Kein Speicherplatz vorhanden fuer anfang\n";
         return;
      }
		
      strcpy(anfang->daten,d); //wenn d länger als 20 ist???
      
      anfang->next=NULL;      //Ende der Liste, zeigt auf NULL
   }

   else {
      zeiger=anfang; // 1. Element
      while(zeiger->next != NULL) //suche letzte element
         zeiger=zeiger->next;
     
      if((zeiger->next =(struct List *)
		malloc(sizeof(struct List))) == NULL) {
          cout << stderr,"Kein Speicherplatz für das letzte Element\n";
          return;
      }
       
      zeiger=zeiger->next;     // zeiger auf neuen Speicherplatz
      strcpy(zeiger->daten,d); //wenn die Liste nicht leer ist???
     
      
      zeiger->next=NULL;
   }
}
// Funktion zur Eingabe der Daten
void eingabe(void) {
	char str1[Laenge];
	char *ptr;
	cout << "Ihre Eingabe : ";
	
	fgets(str1, Laenge, stdin);
	ptr = strrchr(str1, '\n');
	*ptr = '\0';

	anhaengen(str1);
}

// Funktion zum Ausgeben der Dateien 
void ausgabe(void) {
   struct List *zeiger = anfang;
   cout << "\nIhre stringarray: ";
   int cnt=0;
   if (zeiger == NULL)
	   cout<< "Keine Eingabe! \n";
   else
   while(zeiger != NULL) {
	     cnt++;
		 cout << zeiger->daten <<" ";
         zeiger=zeiger->next;
   }
   cout <<"\nAnzahl Ihre Liste : " << cnt <<endl;
}

//-----------

int main(void) {
   int wahl = 0;
   char str2[MAX]={0}; //mit null initialisiere
   do {
	  cout <<endl;
	  cout <<"1 : Eingabe\n";
     
      cout <<"2 : Ausgabe\n";

	  cout <<"3 : ?\n";
     
      cout <<"5 : Ende\n";
	  cout <<endl;
      cout <<"Ihre Wahl : ";
	 
      scanf("%d",&wahl);
      getchar();
      switch(wahl) {
         case 1 : eingabe();
                  break;
         case 2 : ausgabe();
                  break;
	//	 case 3 : counter();
	//			  break;
	//	 case 4 : zuweisung();
	//			  break;

         case 5 : break;
         default: cout<<"Falsche Eingabe!\n";
      }
   } while(wahl != 5);
   return 0;
 
}

Herzlichen Dank.

Ich empfehle dir daher, dir nochmal ein kleines Tut über Objektorientierung durchzulesen.
Das scheint ihr ja dort an der Uni Wien nicht ordentlich behandelt zu haben (oder hast du einfach nicht aufgepasst? :P)

btw. ist das, was du hier zu programmieren versuchst C++, KEIN Ansi-C. Deswegen bitte Verschiebung ins richtige Forum..

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Ich glaube du hast schlichtweg deine Aufgabe nicht richtig verstanden. Ziel ist es eine Klasse zu programmieren, aber genau das tust du nicht....
Das scheint ihr ja dort an der Uni Wien nicht ordentlich behandelt zu haben (oder hast du einfach nicht aufgepasst? :P)
btw. ist das, was du hier zu programmieren versuchst C++, KEIN Ansi-C. Deswegen bitte Verschiebung ins richtige Forum..

Ali schrieb:

Zuerst danke ich euch fürs Verschieben in richtigem Forum.
Wegen der Aufgabe hast du Recht. Ich habe aber andere Frage gestellt gehabt, anscheinen habe ich mich nicht so richtig ausgedruckt, tut mir leid.
An der Uni Wien haben wir schon gelernt, aber innerhalb eines Semesters kann man nicht alles lernen. Wenn ihr irgendwelche Schwäche sieht, liegt sicher an mir, ich muss viel üben!
Also den Code habe ich jetzt geändert, es fehlt aber einiges.
Brauche ich eine weitere Klasse (z.B. class List der selber 2 Zeiger beinhaltet *anfang und *zeiger), wie normale verkettete Liste?
Und das Problem mit einfügen habe ich noch, wo od. wie soll ich nächste element anfordern, wenn meine dynamische array voll wird (in der Methode einfügen od. im Hauptprogramm muss das geschehen)?
Ich bin dankbar für jede Hilfe.
LG

#include <iostream>
#include <iomanip>
using namespace std;

//=============================================

class element {
private:
	int max;		//maximale Arraylaenge = 20
	int itsLen;		//aktuelle Arraylaenge
	int *inhalt;	//dynamisches array, hier kommen die werte rein. 
	element *next;	//zeigt auf das naechste Objekt
public:
	//=== Konstrukturen ===
	element(int n=20);				//Konstruktur
	element(int n, int wert); 
	element (const int* const);
	~element();						//Destruktur
	
	//=== Ueberladene Operatoren ===
	int &operator[](int i);			//Index-Operator
	int operator[](int i)const;
	element(const element&);			//Kopierkonstruktur
	element &operator=(const element&);	//Operator = od. Zuweisung

	int length() const{return itsLen;}
	
	bool anhaengen(int wert);		//eine element wird angehaengt
	bool remove(int pos);			//element vom position pos loeschen

	void printall(void);

	//friend class List;
};

class element *anfang = NULL;
class element *zeiger = NULL;

int arr_len(const int *s)			//arraylaenge wird zurueck gegeben.
{
	if(!s) return 0;
	int itsLen=0;
	while(s[itsLen])
		++itsLen;
	return itsLen;
}

//=============================================

element::element(int n)
{
	max=n; itsLen=0;			//max und itsLen setzen.
	inhalt = new int[20];		//Speicher reservieren
}

element::element(int n, int wert)
{
	max=itsLen=n;				//max und itsLen setzen.
	inhalt = new int[20];
	
	for(int i=0;i<20;++i)		//Speicher reservieren
		inhalt[i]=wert;
}

// Konvertiert ein integerarray in einem Array 
element::element(const int *cpelement)
{
	itsLen = arr_len(cpelement);
	inhalt = new int[itsLen];
	for (int i=0; i<itsLen; i++)
		inhalt[i] = cpelement[i];
}

// Destruktor
element::~element ()
{
	delete [] inhalt;
}

//erster Operand ist das Feld (der zeiger), 
//und zweiter ist der Index zur Aenderung von Array
int &element::operator[](int i)
{
	if(i<0 || i>=itsLen)
	{
		cerr << "\nclass element is out of range!";
		exit(1);
	}
	return inhalt[i];
}

int element::operator [](int i)const
{
	if(i<0 || i>=itsLen)
	{
		cerr << "\nclass element is out of range!";
		exit(1);
	}
	return inhalt[i];
}

// Kopierkonstruktur
element::element(const element& s)
{
	max = s.max;
	itsLen = s.itsLen;
	inhalt = new int[max];

	for (int i=0; i<itsLen; i++)
		inhalt[i] = s.inhalt[i];

}
// Selbstzuweisung pruefen, Speicher freigeben,
// dann Array und Groesse kopieren
element& element::operator =(const element& s)
{
	if(this!=&s)				//keine Selbszuweisung
	{
		max = s.max;
		itsLen = s.itsLen;
		delete[] inhalt;		//Speicher freigeben
		
		inhalt = new int[max];	//Speicher neu reservieren
		for (int i=0; i<itsLen; i++)
			inhalt[i]=s.inhalt[i];
	}
	return *this;
}

bool element::anhaengen(int wert)
{
	if (anfang==NULL)
	{
		if (itsLen < max)
		{
			anfang->inhalt;
			inhalt[itsLen++] = wert;
			
			return true;
		}
		else 
			return false;
	}
}
// Für die Aufgabe brauchen wir keine remove!
bool element::remove(int pos)
{
	if (pos >= 0 || pos < itsLen)
	{
		for (int i=pos; i<itsLen-1; ++i)
			inhalt[i] = inhalt[i+1];
		itsLen--;
		return true;
	}
	else
		return false;
}

void element::printall(void) //muss korrigiert werden !!!
{
	//int inhalt[20]={0};
	if (anfang!=NULL)
	{
		zeiger=anfang;
		while (zeiger->next !=NULL)
		{
			for (int i=0;i<20;++i)
			{
				cout<<zeiger->inhalt[i];
			}
			cout<<endl;
			zeiger = zeiger->next;
		}
		for (int i=0; i<itsLen;++i)
			cout<<zeiger->inhalt[i];
	}
	cout<<endl;
}
/*			//wahrscheinlich muss ich zweite Klasse definieren?
class List
{
public:
	element *anfang;
	element *zeiger;
public:
	List(void);
	~List(void);

};

List::List(void)
{
	anfang=NULL;
	zeiger=NULL;

// und weitere Methoden
}*/

//------------------------------------------------------------------------
// Hauptprogramm
int main(void) {	

	int i, j;
	element v(9);		//leer
	element w(10,1);	//10 elemente mit nur eins
	cout << "\naktuelle Anzahl Elemente in v: " << v.length();
	cout << "\naktuelle Anzahl Elemente in w: " << w.length() << endl;

	cout << "\naktuelle Inhatl von v und w wird ausgegeben: " << endl;
	
	cout << "v: ";
	for(i=0;i<v.length();i++)
		cout << setw(4) << v[i]; //wird nichts ausgegeben! ist leer
	cout << endl;
	cout << "w: ";
	for(j=0;j<w.length();j++)
		cout << setw(4) << w[j];
	cout << endl;

	int x=5;
	for (;x<30;x+=5)
	v.anhaengen(x);
	cout << "\nDie Vektorelemente Nach dem Anhaengen: "<<endl;
	for(i=0;i<v.length();i++)
		cout << setw(4) << v[i]; 
	cout << endl;

	v.anhaengen(7);	
	v.anhaengen(8);
	v.anhaengen(9);
	v.anhaengen(10);
	v.anhaengen(11);
	v.anhaengen(12);
	v.anhaengen(13);
	
	cout << "\nAn v wurde weitere Elemente angehaengt: " << endl;
	for(i=0;i<v.length();i++)
		cout << setw(4) << v[i]; 
	cout <<endl;

	const element cpv(v);		//Kopierkonstruktur
	cout << "\nKopie von v wurde angelegt: " << endl;
	for(i=0;i<cpv.length();i++)
		cout << setw(4) << cpv[i];
	cout << endl;

	v = w;		//Zuweisung
	cout << "\nDie Elemente nach der Zuweisung: " << endl;
	for (j=0;j<v.length();++j)
		cout << setw(4) << v[i];
	cout << endl;
	
	//v.printall(); //das funktioniert nicht, sollte korrigiert werden!

	
return 0;
}

Ich habe deinen Sourcecode jetzt nur kurz überflogen, aber du scheinst jetzt lediglich eine Klasse für ein Element (bestehend aus einem Array mit 20 Elementen) angelegt zu haben. Das musst du zwar nicht machen, ist aber ein guter Ansatz. Das Array innerhalb dieser Klasse kannst du jedoch statisch anlegen (also mit der festen Größe 20), das jedoch nur nebenbei.

Ziel deiner Aufgabe ist es eine Liste aus Arrays zu erstellen. Immer wenn die vorhandenen Arrays voll sind (du wieder 20 Elemente gespeichert hast) wird dann ein neues Listenelement mit Platz für 20 neue Elemente angelegt.
Das heißt im Klartext, du musst noch eine übergeordnete Klasse anlegen, die im Prinzip nur deine Listenelemente verwaltet. (Also neue hinzufügt etc.)

Ziel ist es sowas zu haben:

Liste:

ListElem1 --> ListElem2 --> ListElem3 --> ...
 |             |             |
 v             v             v
arr[20]       arr[20]       arr[20]
 |             |             |
 v             v             v
 1.elem        21.elem      41.elem
 2.elem        22.elem      42.elem
 .             .            .
 .             .            .
 20.elem       40.elem      60.elem