dynamische Speicher erstellen und sortieren (Konsolen-Anwendung)

[Animal21]

hallo leute,
da ich nicht ganz weis wo das thema hin soll, post ich es einfach mal allgemein zu c++ XD

wir haben in der schule gerade dynamische Speicherverwaltung in c++ und haben die Grundlagen bekommen (also wie man es deklariert und im groben verwendet)
nun sollen wir als hausaufgabe versuchen ein programm zu schreiben mit:
- einfachen Menü mit folgenden punkten:
* Speicher erzeugen und füllen
* Eine bestimmte gespeicherte Zahl suchen
* alle gespeicherten Zahlen anzeigen
* Speicher wieder freigeben
* Ende

das mit dem speicher erzeugen und füllen, und anzeigen lassen und dann so aufbereiten, das man ans ende wieder speicher erzeugen und füllen kann ist einfach, womit ich probleme hab, ist, die speicherinhalte zu sotieren, also nach größe aufsteigend zum beispiel.
hier mal mein programm:

int main(int argc, char* argv[])
{
struct LE
	{
		int i_Inhalt;
		LE *p_next;
	};

int i_Zahl,i_Menu,i,j,i_temp,i_count=0,i_Such,i_Zaehler=0,i_oben,i_unten=0,i_Index,again;
LE *p_first=NULL, *p_aktuell=NULL;
bool blnagain, b_gefunden=false;

		cout<<"Bitte gib die erste Zahl ein: ";
		cin>>i_Zahl;
		p_first=new LE;
		p_first->i_Inhalt=i_Zahl;
		p_first->p_next=NULL;
		p_aktuell=p_first;
		i_count=1;
		cout<<endl;

Mainmenu:
	cout<<"Bitte einen Menupunkt auswaehlen:"<<endl
		<<"(1) Speicher erzeugen und fuellen"<<endl
		<<"(2) Eine bestimmte gespeicherte Zahl suchen"<<endl
		<<"(3) weitere Speicher anlegen und fuellen"<<endl
		<<"(4) alle gespeicherten Zahlen anzeigen"<<endl
		<<"(5) Speicher wieder freigeben"<<endl
		<<"(6) Ende"<<endl<<endl;
	cin>>i_Menu;

	switch (i_Menu)
	{
	case 1:
		//############### - Case 1 - ###############
		//Ende suchen
		if (p_first->p_next!=NULL)
		{
			p_aktuell=p_first;	
			do
			{
				p_aktuell=p_aktuell->p_next;
			}
			while(p_aktuell->p_next!=NULL);
		}		
		//Ende gefunden
		do
		{
			cout<<endl<<"Gib bitte die Zahl ein die du speichern moechtest: ";
			cin>>i_Zahl;
			p_aktuell->p_next=new LE;
			p_aktuell=p_aktuell->p_next;
			p_aktuell->i_Inhalt=i_Zahl;
			p_aktuell->p_next=NULL;
			i_count++;

			cout<<endl<<"Noch eine Zahl Speichern?"
				<<endl<<"(1) Ja"
				<<endl<<"(0) Nein"<<endl;
			cin>>again;
			if (again==1)
			{
				blnagain=true;
			}
			else
			{
				blnagain=false;
			}

		}
		while(blnagain==true);

		cout<<endl;
		break;

	case 2:
		//############### - Case 2 - ###############
            /*hier sollen nun eigentlich mit bubblesort die inhalte der speicher aufsteigend (also größtes zuletzt) sortiert werden und anschießden
     soll man eine bestimmte zahl eingeben können, welche dann mit einer binären suche gesucht und ausgegeben wird falls sie vorhanden ist.*/

//Sortieren (aufsteigend)

		p_aktuell=p_first;
		/*for(i = 0; i <= i_count; i++)
		{
			for (j=0; j < (i_count-1); j++)
			{
				if (p_aktuell[j+1]->i_Inhalt < p_aktuell[j]->i_Inhalt)     
				{ 
					i_temp = p_aktuell[j]->i_Inhalt;             
					p_aktuell[j]->i_Inhalt = p_aktuell[j+1]->i_Inhalt;
					p_aktuell[j+1]->i_Inhalt = i_temp; 
				}
			}
		}
		//Sortieren fertig (aufsteigend)

		//Ausgabe (aufsteigend)

		cout<<"Deine Zahlen sehen aufsteigend sortiert wie folgt aus:"<<endl;
		for (i=0;i<=i_count;i++)
		{
			if ((i+1)%10==0)
			{
				cout<<p_aktuell[i]->i_Inhalt<<" ";
				cout<<endl;
			}
			else
			{
				cout<<p_aktuell[i]->i_Inhalt<<" ";
			}
		}*/

		//Binäresuche
		/*
		cout<<"Bitte die 'Such-Zahl' eingeben: ";
		cin>>i_Such;
                i_oben=i_count;

		while ((b_gefunden==false)&&(i_oben>=i_unten))
		{
			i_Zaehler++;
			if (Feldvariable[i_Index]==i_Such)
			{
				b_gefunden=true;
			}
			else
			{
				if (Feldvariable[i_Index]<=i_Such)
				{
					i_unten=i_Index+1;
				}
				else
				{
					i_oben=i_Index-1;
				}
				i_Index=(i_oben+i_unten)/2;
			}
		}

		if (b_gefunden==false)
		{
			cout<<"Nicht gefunden!"<<endl;
		}
		else
		{
			cout<<"Gefunden!"<<endl;
		}

		cout<<i_Zaehler<<" Zugriffe benoetigt!";
		*/		
break;
	case 3:
		//############### - Case 4 - ###############
		if (p_first->p_next!=NULL)
		{
			p_aktuell=p_first;	
			cout<<endl<<p_aktuell->i_Inhalt<<endl;
			do
			{
				p_aktuell=p_aktuell->p_next;
				cout<<p_aktuell->i_Inhalt<<endl;
			}
			while(p_aktuell->p_next!=NULL);
		}
		else
		{
			cout<<endl<<p_first->i_Inhalt<<endl;
		}
		break;

	case 4:
		//############### - Case 5 - ###############		
		break;
	case 5:
		//############### - Case 6 - ###############
		return 0;
		break;

	default:
		//############### - Default - ###############
		goto Mainmenu;
		break;
	}
	cout<<endl;
	goto Mainmenu;		

	return 0;
}

so wie ich das bei Case 2 gemacht hab geht es leider nicht :<
könnt ihr mir bitte helfen?

mfg
Ani

[drakon]

Ich habe jetzt nicht deinen ganzen Code angeschaut, aber schau dir mal std::vector an. Die gehört zur STL (Standard Template Library) und stellt dir sehr mächtige Werkzeuge zur Verfügung. Unter anderem auch sortieren.

Und falls ihr die nicht benutzen dürft ist das Stichwort für einen einfachen sortier Algo: Bubblesort.

PS: goto ist etwas sehr verpöntes. (siehe aktuelle posts) SOLLTE man nicht unbedingt für sie triviale Aufgaben benutzen, wie du es benutz. Hier sollte man eher eine Schleife nutzen.

[*D*Evil]

=> "goto" rausnehmen!

Also, das ist ja nicht generell dynamisch Speicher füllen sondern schon ein Bestimmtes Designpattern der OOP. List(en auf deutsch ;)).

Man nehme std::list<int> data. Zum suchen std::find(data.begin(), data.end(), such_wert);
std::copy(data.begin(), data.end(), std::ostream_iterator<int>(std::cout, " ")); zum anzeigen und ist fertig

[Animal21]

@ drakon lies ma das bei case 2, ich versuchs ma mit bubblsort, geht aber nich so wie ich gedacht hatte

und ich würde es gern ohne vector hinbekommen...

PS: warum is goto verpönt? gilt das nur für triviale sachen?

[drakon]

Animal21 schrieb:

@ drakon lies ma das bei case 2, ich versuchs ma mit bubblsort, geht aber nich so wie ich gedacht hatte

und ich würde es gern ohne vector hinbekommen...

PS: warum is goto verpönt? gilt das nur für triviale sachen?

Na, dann machst du irgenwas falsch. Am besten du machst den Sortier Alorithmus einfach nochmal neu.

goto macht ein Programm sehr schnell unübersichtlich. Ist eine ewige Diskussion, ob und wann man es benutzen soll. Aber sagen wir es so, man kommt ganz gut ohne aus. Gilt hald bei vielen (finde ich auch) als schlechter Stil. Es gibt viele Sachen, die eleganter gelöst werden könne, als mit goto.

EDIT:

Die Dekleration und Definition einer Variabel solltest du so weit vermeiden, bis sie gebraucht wird.

for (int i = 0; .. ){..} //i sollte erst hier deklariert und definiert werden.

[Animal21]

Die Dekleration und Definition einer Variabel solltest du so weit vermeiden, bis sie gebraucht wird.

for (int i = 0; .. ){..} //i sollte erst hier deklariert und definiert werden.

weist was geil ist? ich hab des mal so gemacht, und mein lehrer meinte, dass dies nicht so toll wäre und ich lieber alles vorher deklarieren sollte -.-'

naja zu bubblesort: der algo is richtig, hab ihn ja schon wo andern benutzt, nur meckert der eben bei folgendem rum:

for(i = 0; i <= i_count; i++)
		{
			for (j=0; j < (i_count-1); j++)
			{
				if (p_aktuell[j+1]->i_Inhalt < p_aktuell[j]->i_Inhalt)     
				{ 
					i_temp = p_aktuell[j]->i_Inhalt;             
					p_aktuell[j]->i_Inhalt = p_aktuell[j+1]->i_Inhalt;
					p_aktuell[j+1]->i_Inhalt = i_temp; 
				}
			}
		}

Fehlermeldung:
DynSpeicher.cpp(104) : Der Typ 'main::LE' hat keinen ueberladenen Elementoperator '->'
DynSpeicher.cpp(11) : Siehe Deklaration von 'LE'
DynSpeicher.cpp(104) : Der linke Teil von '->i_Inhalt' muss auf Klasse/Struktur/Union zeigen

das mit p_aktuell[j+1]->i_Inhalt < p_aktuell[j]->i_Inhalt ... ist irgendwie falsch, weis halt nicht wies richtig aussehn muss :<

[drakon]

Animal21 schrieb:

Die Dekleration und Definition einer Variabel solltest du so weit vermeiden, bis sie gebraucht wird.

for (int i = 0; .. ){..} //i sollte erst hier deklariert und definiert werden.

weist was geil ist? ich hab des mal so gemacht, und mein lehrer meinte, dass dies nicht so toll wäre und ich lieber alles vorher deklarieren sollte -.-'

naja zu bubblesort: der algo is richtig, hab ihn ja schon wo andern benutzt, nur meckert der eben bei folgendem rum:

for(i = 0; i <= i_count; i++)
		{
			for (j=0; j < (i_count-1); j++)
			{
				if (p_aktuell[j+1]->i_Inhalt < p_aktuell[j]->i_Inhalt)     
				{ 
					i_temp = p_aktuell[j]->i_Inhalt;             
					p_aktuell[j]->i_Inhalt = p_aktuell[j+1]->i_Inhalt;
					p_aktuell[j+1]->i_Inhalt = i_temp; 
				}
			}
		}

Fehlermeldung:
DynSpeicher.cpp(104) : Der Typ 'main::LE' hat keinen ueberladenen Elementoperator '->'
DynSpeicher.cpp(11) : Siehe Deklaration von 'LE'
DynSpeicher.cpp(104) : Der linke Teil von '->i_Inhalt' muss auf Klasse/Struktur/Union zeigen

das mit p_aktuell[j+1]->i_Inhalt < p_aktuell[j]->i_Inhalt ... ist irgendwie falsch, weis halt nicht wies richtig aussehn muss :<

Dann sag deinem Lehrer, dass er programmieren lernen soll. Was hat den das für Vorteile, wenn man das am Anfang schreibt? Am besten noch global, oder? Dann können schön alle, die nichts mit dieser Variabel zu tun haben darauf zugreifen und machen, was sie wollen.

Naja.. Siehst du ja, dass du keinen -> Operator hast, der was machen soll. Wenn du p_aktuell[j+1] schreibst, hast du gleich das Objekt, das dort drin ist. Also mal . Operator versuchen.

[Animal21]

p_aktuell=p_first;

		for(i = 0; i <= i_count; i++)
		{
			for (j=0; j < (i_count-1); j++)
			{
				if (p_aktuell[j+1].i_Inhalt < p_aktuell[j].i_Inhalt)     
				{ 
					i_temp = p_aktuell[j].i_Inhalt;             
					p_aktuell[j].i_Inhalt = p_aktuell[j+1].i_Inhalt;
					p_aktuell[j+1].i_Inhalt = i_temp; 
				}
			}
		}
		//Sortieren fertig (aufsteigend)

		//Ausgabe (aufsteigend)

		cout<<"Deine Zahlen sehen aufsteigend sortiert wie folgt aus:"<<endl;
		for (i=0;i<=i_count;i++)
		{
			if ((i+1)%10==0)
			{
				cout<<p_aktuell[i].i_Inhalt<<" ";
				cout<<endl;
			}
			else
			{
				cout<<p_aktuell[i].i_Inhalt<<" ";
			}
		}

mit dem "." gehts ^^

aber bei der ausgabe kommt da nur datenmüll raus :<

[drakon]

Ja, dann ran an den Debugger und schauen, was du falsch machst.