3. Probleme mit Referenzen und Inline Swap

Probleme mit Referenzen und Inline Swap

  • O

    ICh habe ein Programm geschrieben das verschiedenen Zahlen generiert und dann mit bubbelsort sortiert jetzt versuche ich das zu kopilieren und habe Probleme mit Call by Referenz(heist doch wert aufrufen ud verändern) und mit inline swap ich weiß nicht wie ich die integrieren soll.

    Hier der code:

    #include <iostream>
#include <cstdlib>
#include <new>

using namespace std;

long eingabe();
float *erzeuge_feld(long anzahl);
void bubbleSort(float*& erzeugtes_feld, long anzahl);
void swap(float*& erzeugtes_feld[k], float*& erzeugtes_feld[k+1]);
void ausgabe(float *sortiertes_feld, long anzahl);

long eingabe()
{
	//Einlesen der Anzahl der einzulesenden Zahlen
	long zahl;

	cout <<""<<endl;
	cout <<"Geben Sie die Anzahl der Zahlen ein die sortiert werden sollen: ";
	cin >> zahl; 

	return zahl;
}

float *erzeuge_feld(long anzahl)
{
	//temporäres Feld wird erzeugt
	float *feld;

	//Benötigtes Feld erzeugen
	try
	{
		feld=new float[anzahl];
	}
	//Überprüfe ob Fehler vorhanden falls ja Abbruch 
	catch(bad_alloc)
	{
		cout<<"Fehler bei der Speicherreservierung!" << endl; 
		exit(1);
	}

	//Größte Zahl soll 1.000.000(=1.0E6) sein 
	const float skala =1.0E6;

	//Anfangswert setzen für das Erzeugen
	srand(45822);

	//Schleife für das Ablegen der erzeugten Werte
	for(long i=0; i<anzahl; i++)
	{
		//erzeugete Zahl wird an der i-ten stelle abgelegt
		feld[i]=rand()/(static_cast<double>(RAND_MAX)) *skala;
				//Wert zw. 0.0 und 1.0 Skalieren auf 1000000.
	}
	//Feld an die Main-Funktion zurückgeben
	return feld;
}

void bubbleSort(float*& erzeugtes_feld, long anzahl)
{
	//Schleife für die Passes (Bubble-Sort Prinzip)
	for(long i=1;i<anzahl;i++)
	{
		//Schleife für jeden Pass (Jede Zahl wird vergleichen ob > oder <)
		for(long k=0;k<(anzahl-1);k++)
		{
			//Wenn Zahl an der i-ten Stelle > dann soll die Zahl nach unten rutschen
			//und die kleinere nach oben
			if(erzeugtes_feld[k]>erzeugtes_feld[k+1])
			{
				//Vertauschen der beiden Zahlen falls Bedingung erfüllt
				swap(erzeugtes_feld[k], erzeugtes_feld[k+1]);
			}
		}
	}	
}

void swap(float*& erzeugtes_feld[k], float*& erzeugtes_feld[k+1])
{
	//Funktion zum vertauschen von werten
	float temp=erzeugtes_feld[k]; 		// zahl1 wird temporär gespeichert
	erzeugtes_feld[k]=erzeugtes_feld[k+1]; 	// zahl1 kann nun den Wert von zahl2 übernehmen
	erzeugtes_feld[k+1]=temp; 		// zahl2 erhälten den temporär, gespeicherten Wert
}

void ausgabe(float *erzeugtes_feld, long anzahl)
{
	//Schleife für die Ausgabe des Feldinhalts
	for(long position=0; position<anzahl;position++)
	{
		//Ausgabe der Zahl an der i-ten Stelle
		cout << erzeugtes_feld[position] << endl;
	}
}

int main ()
{
	//Variable für die Anzahl der zu erstellendne Zahlen
	long anzahl;
	//Einlesen der Variable anzahl
	anzahl = eingabe();

	//Variable für das zu erzeugende Feld
	float *erzeugtes_feld;
	//Feld wird erstellt mit den unsortierten Zahlen
	erzeugtes_feld=erzeuge_feld(anzahl);

	//Feld wird sortiert
	bubbleSort(erzeugtes_feld,anzahl);

	//erzeugtes Feld wird ausgegeben
	ausgabe(erzeugtes_feld, anzahl);

	return 0;
}
    0
  • E

    olimlad schrieb:

    void swap(float*& erzeugtes_feld[k], float*& erzeugtes_feld[k+1]);

    Kannst du mal erklären was du dir hierbei gedacht hast?
    Erstmal macht float*& für mich überhaupt keinen Sinn. Du schreibst was von Referenzen, du willst doch nicht ein Array (einen Zeiger) als Referenz übergeben, oder?
    Zwei mal den gleichen Variablennamen in in der der Parameterliste, soll sich dein Compiler dann später den richtigen aussuchen?
    Was bezweckst du mit der Indexangabe im Funktionskopf?

    Also ich schlage vor du überdenkst das nochmal ein wenig.

    Gruß
    Entyl Sa

    0
  • O

    Mein Problem liegt darin das ich die beiden Werte von erzeugtes_feld[k] und [k+1] vertauschen will wie mache ich das wenn ich Referenzparameter in Swap verwenden muß und swap eine inline sein soll?

    0
  • J

    Soviel ist garnicht verkehrt.

    1.)
    im Prototype statt

    void swap(float*& erzeugtes_feld[k], float*& erzeugtes_feld[k+1]);

    muss es heissen

    void swap(float& first, float& second);

    2.)
    in der Definition entsprechend statt

    void swap(float*& erzeugtes_feld[k], float*& erzeugtes_feld[k+1]) 
{
...

    muss es heissen

    inline void swap(float& first, float& second) 
{
  float temp = first;
  first = second;
  second = temp;
}

    Das wars. Ich denke du solltest einfach nochmal über die Bedeutung von Referenzen nachdenken, dann findest du die Fehler bestimmt auch.

    mfg JJ

    0
  • O

    und wie mache ich das mit inline? das swap eine inline ist? Habe es soweit hinbekommen das es funktioniert...

    0
  • D

    der compiler wird es sowieso inline machen, wenn er kann und lust hat, oder nicht.
    du könntest allerdings auf dein eigenes swap vollkommen verzichten und das swap aus der standardbibliothek verwenden:

    #include <algorithm>
//...
std::swap(wert1,wert2);

    außerdem solltest du deinen zufallszahlengenerator jedesmal mit einer anderen zahl initialisieren, z.b. so

    srand(time(0));
    0
  • O

    Das ist mir schon klar aber ich sollte das nochmal mit referenzen machen...
    Wie kann ich eigentlich großbuchstaben in kleinbustaben verwandeln und umgekehrt?
    Und gibt es sowas wie case bei C++?

    0
  • C

    Guck mal hier:
    http://www.c-plusplus.net/forum/viewtopic.php?t=57478&highlight=gro�buchstaben

    Und ich denke es ist besser, sowas in nem extra Thread zu fragen statt das irgendwo mittendrin zu tun. Achja, und die Suchfunktion nutzen. 😉

    0
  • V

    bubblesort (mit swap): http://www.volkard.de/vcppkold/bubble_sort.html
    case in c++: http://www.volkard.de/vcppkold/bubble_sort.html
    kleinbuchstaben: http://www.volkard.de/vcppkold/zeichen.html

    0
  • O

    Danke das hat geholfen!

    0
Anmelden zum Antworten