"Implementieren sie einen Stack mit Hilfe eines dynamischen Array. Hierbei werden die Stackelemente in einem Array gespeichert.Jedes neue Stapelelement wird dabei als hinterstes Element in das Array eingefügt. Sollte durch eine push Operation die ursprüngliche Arragrösse überschritten werden, wird ein neues, doppelt so grosses Array erstellt, der ursprüngliche Inhalt hineinkopiert und das alte Array anschliessend gelöscht. Führen sie mit einem Zähler die aktuelle Anzahl Elemente mit. Zum Programmstart hat das dynamische Array die Gröse 2."

Nun habe ich leider das Problem, dass ich das Ziel dieser Aufgabe nicht ganz begreiffe? Ich habe einfach einmal ein Programm gemacht und wollte fragen, ob mein Programm die Anforderungen erfüllt?

Es wurde uns ein Framework vorgegeben:

[code]

#include <stdlib.h>
#include <iostream>
#include <string>
using namespace std;

//Structs, Arrays und andere globale Variablen hier definieren.

void init() {
//TODO: Code hier einf�gen	
}

int pop(){
//TODO: Code hier einf�gen		
}

void push(int element){
//TODO: Code hier einf�gen		
}

int size() {
//TODO: Code hier einf�gen	
}

void clear() {
//TODO: Code hier einf�gen	
}

//Dieses Funktion implementiert eine Testumgebung f�r den Stack
void test() {
    cout << "The program has been startet without any arguments." << endl;
    cout << "The program enters the stack test mode:" << endl;
    cout << "Enter one of the commands: push, pop, end" << endl;
    string command;
    do{
      cin >> command;
      if (command == "pop"){
        cout << pop() << endl;
      } else if (command == "push"){
        cout << "element?";
        int elementToPush;
        cin >> elementToPush;
        push(elementToPush);
      } else if(command == "end"){
      } else {cout << "command not recognised"<< endl;};
    }while(command != "end");
}

int main(int argc, char * argv[]){

  init();	
  test();
  clear();
  return 0;

}

Mein Programm schaut nun so aus:

[code]

#include <stdlib.h>
#include <iostream>
#include <string>
using namespace std;

//******************************************************************************

struct dynamic_stapel{
      int groesse;
      int top_Element;
      }stapel = {2,0};

int anzahl_Elemente = 0;

int neudazu =0;

int *dynamic = new int[stapel.groesse];

//******************************************************************************

void init() {

     dynamic_stapel stapel = {2,0};	
}

//******************************************************************************

int pop(){

     anzahl_Elemente =  anzahl_Elemente -1;

}

//******************************************************************************

void push(int element){   

     if (anzahl_Elemente > stapel.groesse){

           while (anzahl_Elemente > stapel.groesse){
                 stapel.groesse = 2*(stapel.groesse);
                 }

           int copy[anzahl_Elemente];

           for (int i=0 ; i<anzahl_Elemente ;i++){
               copy[i] = dynamic[i];
               }

           delete [] dynamic;

           dynamic[anzahl_Elemente];

           for (int i=0 ; i<anzahl_Elemente ;i++){
               dynamic[i] = copy[i];
               }
           }

     for (int j= neudazu; j < anzahl_Elemente ;j++){
           cout << "\n";
           cout << "Bitte geben sie Element " << j+1 << " ein \n";   
           cin >> dynamic[j];
           cout << "\n";
           }		
}

//******************************************************************************

int size() {

    anzahl_Elemente;	
}

//******************************************************************************

void clear() {

     delete [] dynamic;	
}

//******************************************************************************

//Dieses Funktion implementiert eine Testumgebung f?r den Stack
void test() {
    cout << "The program has been startet without any arguments." << endl;
    cout << "The program enters the stack test mode:" << endl;
    cout << "Enter one of the commands: push, pop, end" << endl;
    string command;
    do{
      cin >> command;
      if (command == "pop"){
        cout << pop() << endl;
      } else if (command == "push"){
        cout << "element?\n";
        int elementToPush;
        cin >> elementToPush;
        anzahl_Elemente = anzahl_Elemente +  elementToPush;
        neudazu = anzahl_Elemente -  elementToPush;
        push(elementToPush);
        stapel.top_Element = dynamic[anzahl_Elemente];
      } else if(command == "end"){
      } else {cout << "command not recognised"<< endl;};
    }while(command != "end");
}

//******************************************************************************

int main(int argc, char * argv[]){

  init();	
  test();

  cout << "\n";

  cout << "Der Stapel besteht aus folgenden Elementen: ";
  for (int i=0; i < anzahl_Elemente ;i++){
      cout << dynamic[i];
      }

  cout << "\n";

  cout << "Die Stapelgroesse betraegt: " << stapel.groesse;

  cout << "\n";

  cout << "Der Stapel besteht aus " << anzahl_Elemente << " Elementen.";

  cout << "\n";

  clear();

  cin.get();
  cin.get();
  return 0;

}

Fertig. Aufgabe gelöst.

Wenn du konkrete Fragen hättest, wird dir auch gerne geholfen, aber einfach nur 200 zeilen Code und "guckt mal" ist zu wenig um mehr zu erwarten, als dass ich mal versuche das Ding durch den Compiler zu jagen:

stack.cpp: In function ‘void init()’:
stack.cpp:23: warning: unused variable ‘stapel’
stack.cpp: In function ‘int pop()’:
stack.cpp:32: warning: no return statement in function returning non-void
stack.cpp: In function ‘void push(int)’:
stack.cpp:44: warning: ISO C++ forbids variable length array ‘copy’
stack.cpp:52: warning: statement has no effect
stack.cpp: At global scope:
stack.cpp:36: warning: unused parameter ‘element’
stack.cpp: In function ‘int size()’:
stack.cpp:72: warning: statement has no effect
stack.cpp:73: warning: no return statement in function returning non-void
stack.cpp: At global scope:
stack.cpp:109: warning: unused parameter ‘argc’
stack.cpp:109: warning: unused parameter ‘argv’

Offensichtlich ist da ziemlich viel kaputt. Vielleicht solltest du erst einmal ein korrektes Programm schreiben, bevor du es uns bewerten lässt. Und benutze Compilerwarnungen. C++-Compiler sind sehr tolerant gegenüber ungewöhnlichen Programmiertechniken, da allgemein angenommen wird, dass der Programmierer Ahnung hat und weiß, was er tut. Bei Anfängern ist aber das Gegenteil der Fall und du solltest Warnungen wie Fehler behandeln.

Bei mir hat der compiler keine Warnung angezeigt (devc++) sonst hätte ich natürlich alles überarbeitet, danke.

Du vergisst ein return in einer Funktion und der DevC++ gibt nicht mal eine Warnung raus? Wow, wechsle den Compiler wenn möglich. Oder hast du bewusst Warnungen abgestellt?

Bei mir hat der compiler keine Warnung angezeigt (devc++) sonst hätte ich natürlich alles überarbeitet, danke.

1. Dann lerne mit deiner IDE umzugehen. Das kann Dev-C++ sicher auch.
2. Wenn kein kleines Wunder vorliegt, hast du vermutlich eine hoffnungslos veraltete Version von Dev-C++, da erst kürzlich nach vielen Jahren Pause etwas neues herauskam.
Guckst du hier:
http://www.c-plusplus.net/forum/263174

_matze schrieb:

Du vergisst ein return in einer Funktion und der DevC++ gibt nicht mal eine Warnung raus? Wow, wechsle den Compiler wenn möglich. Oder hast du bewusst Warnungen abgestellt?

Das ist normal, da Dev-C++ auf dem GCC basiert, wo das eine Art "Feature" ist.

gruss

[code]

#include <stdlib.h>
#include <iostream>
#include <string>
using namespace std;

struct dynamic_stapel{ //Definiert ein Struct
      int groesse;
      int top_Element;
      }stapel = {0,0};

int *dynamic_array = new int[stapel.groesse]; //Dies ist das dynamsche Array

int counter =0; //Diese Variable zaehlt die Elemente mit (Groesse Stapel)

void init() { //inizialisiert den struct dynamic_stapel

    stapel.groesse = 2; 
    stapel.top_Element =0; 
}

int pop(){ // nimmt das oberste Element vom Stapel und loescht es, ebenfalls wird der Zeiger auf das Element darunter gerichtet

	if (counter > 0){ // Wenn es mindestens 1 Element gibt

		counter = counter -1; // Elemente nehmen ab
		dynamic_array = dynamic_array -1; //Dann wird der zeiger auf das Array vor dem jetzigen gelegt dynamic_array[i-1]
	}

	return 0; //Soll zeigen, dass der Stapel um 1 Element abnimmt

}

void push(int element){ //legt ein neues Element oben auf den Stappel

     counter = counter + 1; // die Anzahl Elemente nehmen zu

	 if (counter > stapel.groesse){ // Wenn es mehr Elemente gibt als das Array gross ist

		   int copy_array[counter]; //erstellt ein Zwischenspeicherarray

		   for (int i=0 ; i<counter ;i++){ //Umkupieren der Elemente

			   copy_array[i] = dynamic_array[i];
		   }

		   delete [] dynamic_array; //dynamic array Elemente werden geloescht

		   while (counter > stapel.groesse){ //Dann wird die Arraygroesse so lange verdoppelt, bis das Array groesser als die Anzahl Elemente ist.
                 stapel.groesse = 2*(stapel.groesse);
		   }

		   for (int i=0 ; i<counter; i++){ //Nun werden die Copy Elemente wieder in das nun groessere Array kopiert

			   dynamic_array[i] = copy_array[i];
		   }

	 }

	 dynamic_array = dynamic_array +1; //Dynamic Array zeigt nun auf das naechste dynamic_array[i+1]
	 *dynamic_array = element; //Dem obersten Element wird der Wert von der Einageb "element" zugeordnet

}

int size() { //gibt die groesse des Stapels an

	return counter;

}

void clear() { //Loescht den ganzen Stapel

	delete [] dynamic_array;

}

//Dieses Funktion implementiert eine Testumgebung f�r den Stack
void test() {
    cout << "The program has been startet without any arguments." << endl;
    cout << "The program enters the stack test mode:" << endl;
    cout << "Enter one of the commands: push, pop, end" << endl;
    string command;
    do{
      cin >> command;
      if (command == "pop"){
        cout << pop() << endl;
      } else if (command == "push"){
        cout << "element?";
        int elementToPush;
        cin >> elementToPush;
        push(elementToPush);
      } else if(command == "end"){
      } else {cout << "command not recognised"<< endl;};
    }while(command != "end");
}

int main(int argc, char * argv[]){

  init();   
  test();
  cout << "The stacksize is: "; //Gibt die groesse vom Stapel aus
  cout << counter;
  cout << << "\n" << "The top element is: "; //gibt das oberste Element aus

  clear();
  return 0;

}

Ehrlich gesagt: Dein Code ist ein Verbrechen gegen alle Prinzipien sauberer Programmierung und gegen C++. Derjenige der dir das so beigebracht hat, gehört erschossen.

Wenn das, was du da als allererstes gepostet hast, tatsächlich Vorgabe eures Lehrers/Dozenten/Profs ist, hast du natürlich ein Problem - dann macht nämlich schon diese Vorgabe sauberen Code schwierig bis unmöglich.

Wegen dem reservierten Speicher: Ich dachte, wenn ich anschliessend inizialisiere, reserviert der mir auch mehr Platz?

Der Fehler ist folgender:

[code]
/***
*void operator delete() - delete a block in the debug heap
*
*Purpose:
*       Deletes any type of block.
*
*Entry:
*       void *pUserData - pointer to a (user portion) of memory block in the
*                         debug heap
*
*Return:
*       <void>
*
*******************************************************************************/

void operator delete(
        void *pUserData
        )
{
        _CrtMemBlockHeader * pHead;

        RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));

        if (pUserData == NULL)
            return;

        _mlock(_HEAP_LOCK);  /* block other threads */
        __TRY

            /* get a pointer to memory block header */
            pHead = pHdr(pUserData);

             /* verify block type */
            _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));

            _free_dbg( pUserData, pHead->nBlockUse );

        __FINALLY
            _munlock(_HEAP_LOCK);  /* release other threads */
        __END_TRY_FINALLY

        return;
}

#endif  /* _DEBUG */

Wegen dem reservierten Speicher: Ich dachte, wenn ich anschliessend inizialisiere, reserviert der mir auch mehr Platz?

Falsch gedacht. Wenn du machst

int a = 1;
int b = a;
a = 5;

Dann ist b danach schließlich auch nicht 5. (Ich hoffe mal, dass du das auch so siehst)

Du musst also Nachreservieren und Umschichten, wenn du den Stapel vergrößern willst. Du begibst dich hier auf das sehr rutschige Feld der manuellen Speicherverwaltung (etwas, was man in C++ übrigens nie braucht, viel Spaß beim sinnlosen Lernen!), wo selbst geübte Programmierer schnell schwer zu findende und Fehler einbauen, die man zudem immer erst dann auffallen, wenn man das Programm jemandem vorführt (das einzig definierte an undefiniertem Verhalten ).

Aber wenn man dieses Framework schon nutzen muss, so kann man dennoch wesentlich sauberer als dein Versuch vorgehen. Zudem ist mir vieles in deinem Programm völlig unverständlich.

Du benutzt einerseits ein Struct wo du Daten zu einem Stack hälst, aber den eigenen Stack und einen Zähler behandelst du davon unabhängig? Des weiteren solltest du dich auf deutsch oder englisch einigen, und nicht ein Mischmasch verwenden.

Ich würde dir vorschlagen dann wenigstens die Informationen zu dem Stapel auch komplett in der Struktur zu halten. Zudem solltest du nicht ständig den Zeiger mit dem du das Array verwaltest hin und her bewegen, sondern lieber einen separaten Zeiger (falls nötig) auf ein aktuelles Element verwalten.

Nach meiner Meinung benötigst du ohnehin weniger Variablen. Dazu aber eine die grundsätzliche Frage: Willst du den eigentlichen Stapel bei jedem push/pop komplett neu generieren, oder willst du nur bei einem push ihn bei Bedarf vergrößern?

Im letzteren Fall würde ich drei Werte halten:
a) Den Zeiger auf das Array
b) Die Größe (Wie groß ist das reservierte Array? Alternativ einen Zeiger auf das Letzte Element*)
c) Die Position (Wo im Array befindet sich das "oberste" Element? Alternativ einen Zeiger auf das aktuelle Element*)
* Ich wäre aber eher für den Zahlenwert, da dies unabhängiger von a ist.

(Im Ersteren Fall wäre Größe und Position immer identisch).

a Würde ich nur dann anfassen wenn du ein neues Array erzeugst.

Einen leeren Stack würde ich auch nicht durch new allozieren, sondern mit 0/NULL definieren.

Ok, versuche einmal mehr in die Struktur zu nehmen.

[code]
#include <stdlib.h>
#include <iostream>
#include <string>
using namespace std;

//****************************************************************************************************************************************

struct stack{ //Definiert ein Struct
	int size_array; //Arraygroesse
	int position; //Stapelgroesse (pointer zeigt auf oberstes Element)
    }stack_define;

int *dynamic_array = new int[stack_define.size_array]; //Dies ist das dynamsche Array

//****************************************************************************************************************************************

void init() { //inizialisiert den struct dynamic_stapel

    stack_define.size_array = 2; 
    stack_define.position =0; 
}

//****************************************************************************************************************************************

int pop(){ // nimmt das oberste Element vom Stapel und loescht es, ebenfalls wird der Zeiger auf das Element darunter gerichtet
	if (stack_define.position > 0){ // Wenn es mindestens 1 Element gibt
		stack_define.position = stack_define.position -1;// Elemente nehmen ab
		dynamic_array = dynamic_array -1;
	}
	return 0; //Soll zeigen, dass der Stapel um 1 Element abnimmt    
}

//****************************************************************************************************************************************

void push(int element){ //legt ein neues Element oben auf den Stappel
     stack_define.position = stack_define.position + 1; // die Anzahl Elemente nehmen zu

	 if (stack_define.position > stack_define.size_array){ // Wenn es mehr Elemente gibt als das Array gross ist
		   int copy_array[stack_define.position]; //erstellt ein Zwischenspeicherarray
		   for (int i=0 ; i<stack_define.position ;i++){ //Umkupieren der Elemente
			   copy_array[i] = dynamic_array[i];
		   }
		   delete [] dynamic_array; //dynamic array Elemente werden geloescht
		   while (stack_define.position > stack_define.size_array){ //Dann wird die Arraygroesse so lange verdoppelt, bis das Array groesser als die Anzahl Elemente ist.
                 stack_define.size_array = 2*(stack_define.size_array);
		   }
		   for (int i=0 ; i<stack_define.position; i++){ //Nun werden die Copy Elemente wieder in das nun groessere Array kopiert
			   dynamic_array[i] = copy_array[i];
		   }		
	 }
	 dynamic_array = dynamic_array +1;
	 *dynamic_array = element; //Dem obersten Element wird der Wert von der Einageb "element" zugeordnet      
}

//****************************************************************************************************************************************

int size() { //gibt die groesse des Stapels an	
	return stack_define.position; 
}

//****************************************************************************************************************************************

void clear() { //Loescht den ganzen Stapel
	delete [] dynamic_array;  
}

//****************************************************************************************************************************************

//Dieses Funktion implementiert eine Testumgebung f�r den Stack
void test() {
    cout << "The program has been startet without any arguments." << endl;
    cout << "The program enters the stack test mode:" << endl;
    cout << "Enter one of the commands: push, pop, end" << endl;
    string command;
    do{
      cin >> command;
      if (command == "pop"){
        cout << pop() << endl;
      } else if (command == "push"){
        cout << "element?";
        int elementToPush;
        cin >> elementToPush;
        push(elementToPush);
      } else if(command == "end"){
      } else {cout << "command not recognised"<< endl;};
    }while(command != "end");
}

//****************************************************************************************************************************************

int main(int argc, char * argv[]){
  init();   
  test();
  cout << "The stacksize is: "; //Gibt die groesse vom Stapel aus
  cout << stack_define.position;
  cout << "\n" << "The top element is: "; //gibt das oberste Element aus
  cout << *dynamic_array;
  clear();  
  return 0;

}

Du begibst dich hier auf das sehr rutschige Feld der manuellen Speicherverwaltung

: richtig

SeppJ schrieb:

etwas, was man in C++ übrigens nie braucht

: falsch

SeppJ schrieb:

wo selbst geübte Programmierer schnell schwer zu findende und Fehler einbauen

: richtig

SeppJ schrieb:

Du begibst dich hier auf das sehr rutschige Feld der manuellen Speicherverwaltung

: richtig

SeppJ schrieb:

etwas, was man in C++ übrigens nie braucht

: falsch

Ja und nein...

Was man in C++ selten braucht, oder zumindest kapselt bzw. die Verwaltung abgibt (z.B. unique_ptr...).

...

Kleinen Tip für den Anfang. Die einzige globale variable ist dabei stack.

#include <stdlib.h>
#include <iostream>
#include <string>
using namespace std;

struct stackdata
{
  int * array;  // Das Array, das die Daten hält
  int size;     // Die Größe des Arrays
  int position; // Die aktuelle Position im Array
} stack;

void init()
{
  // Noch sind keine Daten vorhanden
  // (Wie du hier auf Größe 2 gekommen bist ist mir unklar)
  stack.array = NULL; // Initial noch kein Array, da Größe < 1...
  stack.size = 0;
  stack.position = 0;
}

//...