Array, Speicherverwaltung, Zeiger und kein Durchblick mehr...

[Windalf]

Dazu müssen Sie das Array, in dem die Daten gespeichert werden, dynamisch erzeugen

ist ja glatt gelogen von dem lehrer... gibts schon fertige klassen die das machen also muss man das nicht machen... wenn er das wünscht soll er doch hinschreiben das man das verwenden soll...

hier hast du mehr oder weniger 2 möglichkeiten... entweder liest du am anfang ein wieviele datensätze der user eingeben möchte und allokierst dann entsprechend speicher oder merkst dir vor wieviel speicher du reserviert hast und immer wenns der allokierte speicher nicht ausreicht allokierst du nach...

an sonsten um die globale variable loszuwerden musst du deinen funktionen einen zeiger auf den arrayanfang übergeben und die grösse des arrays...

und wenn du eh sortieren sollst brauchst du den grössten und den kleinsten wert ja nicht mehr suchen der steht dann ja am ende bzw anfang des arrays...

[kleine kylie]

Erstmal danke, dass so schnell schon Antworten kamen.

zu ProgChild: Das hab ich doch, wenn ich mich nicht recht irre, in dem unteren Code schon drin... ?!

Was mir fehlt und wo ich nicht weiter komme ist, die Sortierung, und das wegkriegen der globalen Variablen. Und am Ende dann irgendwie, ob das, was ich da schon geschrieben habe, in etwa überhaupt stimmt....

Danke an die, die noch antworten bzw. schon geantwortet haben.

Eure kleine kylie (Ich will doch endlich weiter kommen... Aber die Aufgabe muss ich erst abgeben... Vorher geht's nich weiter... Dabei hab ich, was viele Bücher schon weit vorne behandeln, von Klassen z.b. noch nix gehabt... Naja... hab ja erst angefangen...)

[Gast]

kleine kylie schrieb:

zu ProgChild: Das hab ich doch, wenn ich mich nicht recht irre, in dem unteren Code schon drin... ?!

Also so wie ich das sehe reservierst du dir keinen Speicher. Du musst erst wissen, wie viel Speicher du benötigst. Dann kannst du dir erst den Speicher mit new reservieren. Wenn ich mich nicht irre, dann reserviert dein new[] genau gar keinen Speicher. Also entweder erst den Benutzer fragen, wie viel Speicher er braucht und dann reservieren oder std::vector benutzen.

[life]

guck mal hier:

http://www.c-plusplus.net/forum/viewtopic.php?t=101506

[Caipi]

Bzg. den globalen Variablen:
Du könntest z.B. die Variablen in main() definieren, und sie dann an jede andere Funktion per parameter übergeben:

Beispiel:

void function(int* arr, size)
{
     cout << "\n Ausgabe des Vektors:\t";
     for(unsigned int i = 0; i < size; ++i)
           cout << arr[i] << ", ";
}

int main()
{
     int* zahlen = new int[anzahl_der_zahlen];

     ...

     // Funktionsaufruf. Die Parameter aus main an die Funktion function uebergeben
     function(zahlen, anzahl_der_zahlen);

     ...

     return 0;
}

Bzg. deinem Sortierproblem, such mal allgemein nach Sortieralgorithmen, (Oder in deinem Fall nach BubbleSort. IMHO ist dieser Algo am besten für deine Aufgabenstellung geeigenet). (z.B. in Google, oder in der Wikipedia)

Und nun noch ein paar eigene (recht primitive) Worte zum Bubble-Sort Algorithmus:
Dieser Algorithmus durchläuft einen Vektor immer wieder, wobei benachbarte Elemente gegebenfalls vertauscht werden. Sobald bei einem Durchlauf keine Elemente mehr vertauscht wurden, bricht das Verfahren ab.

Wird es nun klarer?

Caipi

[enno-tyrant]

das hätten wir doch mal ein paar

// BubbleSort
template <class bS>
void bubbleSort(bS *array, int SIZE)
{
	for(int obereGrenze = SIZE-1; obereGrenze > 0; --obereGrenze)
	{
		for(int position = 0; position < obereGrenze; ++position)
		{
			if(array[position]>array[position+1])
				tauscheArray(&array[position],&array[position+1]);
		};
	};
};

oder

// Shell Sort
template <class sS>
void shellSort(sS *array, int SIZE)
{
	int step = SIZE;
	do
	{
		step=step/2;
		for(int start = 0; start<step; ++start)
		{
			for(int index = start+1;index<SIZE; index+=step)
			{
				for(int index2 = index-1; index2>=0; index2 -= step)
					if(array[index2]>array[index2+step])
						tauscheArray(&array[index2],&array[index2+step]);
						else
							break;
			};
		};
	}while(step>0);
};

ach, das reicht

[kleine kylie]

Ich finde es super lieb, dass so viele Vorschläge kamen. Nur leider kamen in den Lektionen die bis zu dieser Aufgabe behandelt wurden weder vectoren, noch templates noch parameter oder klassen vor...

Kurz und gut: ich muß es so wie es aussieht auf 'nem viel simpleren Weg hinbekommen...

Hab mittlerweile noch ein paar Bücher mir ausgeliehen und komme einfach nicht weiter... Wie 'n Blackout... Keinen besch... Schritt weiter...

Vielleicht hat ja noch jemand so viel Herz wie Ihr, oder ihr selber sogar, und schaut nochmal über meinen Code, was da nicht stimmt bzw. fehlt...

DANKE an alle, die sich die Mühe machen!!!
Die kleine kylie

PS: das mit dem Speicher und wieviel ich brauche etc. werde ich mal schauen ob ich das hinbekomme... Danke schonmal...

[enno-tyrant]

wenn du templates nicht nutzen kannst/darfst dann laß sie doch einfach weg, guckst du:

void bubbleSort(int *array, int SIZE)
{
    for(int obereGrenze = SIZE-1; obereGrenze > 0; --obereGrenze)
    {
        for(int position = 0; position < obereGrenze; ++position)
        {
            if(array[position]>array[position+1])
                tauscheArray(&array[position],&array[position+1]);
        };
    };
};

in diesem fall muß dein array eben ein 'integer' sein

[Windalf]

oder ruf einfach qsort oder std::sort auf

[Caipi]

Hier mal ein compilierbares Beispiel:

#include <iostream>
using namespace std;

// Diese Parameter werden beim (korrekten) Aufruf mit den entsprechenden 
// Argumenten initialisiert. D.h. im Beispiel die Startadresse von arr (&arr[0])
// wird dem Int-Zeiger v als Wert übergeben. Der Parameter size bekommt im
// Beispiel den Wert von sizeofArr zugewiesen.
int greatestNr(int* v, const unsigned int size)
{
        int max = v[0]; // Am Anfang davon ausgehen, dass der Wert von v[0] die größte Zahl enthält.
        for(unsigned int i = 1; i < size; ++i)
                if(v[i] > max)
                        max = v[i];

        return max; // Größte Zahl zurückgeben
}

int main()
{
        cout << "\n Anzahl der einzugebenden Daten: ";
        unsigned int sizeofArr;
        cin >> sizeofArr;
        int* arr = new int[sizeofArr]; // Array dynamisch reservieren.

        // Werte einlesen
        for(unsigned int i = 0; i < sizeofArr; ++i)
        {
                cout << "\n Bitte Wert fuer arr[" << i << "] eingeben: ";
                int tmp;
                cin >> tmp;
                arr[i] = tmp;
        }

        // Groesste Zahl ermitteln
        // Hier wird die Startadresse von arr, also &arr[0], und die Größe von arr an die Funktion übergeben.
        int nr = greatestNr(arr, sizeofArr);

        cout << "\n Groesste Nummer im Array arr: " << nr;

        delete[] arr; // Speicher freigeben
        return 0;
}

Ich hoffe das hilft dir weiter bzg. Dynamische Speicherreservierung und Parameterübergabe. (Das ist AFAIK die einzige Möglichkeit Lokale Variablen, etc. in anderen Funktionen bekannt zu machen)

Caipi

[kleine kylie]

Das mit dem Sortieren hab ich noch nicht, auch nicht die Sache mit den Variablen. Aber ich HOFFE und GLAUBE das mit dem Speicher ist jetzt so, wie es sollte...

anzdat ist bei mir übrigens kein int, da der Lehrer Nachkommastellen will...

Hier meine aktuelle Version:

//summe[0], groesste[1], kleinste[2], zaehler[3], zahl[4]

#include <iostream>
#include <cstring>

int fabfrage();
int fberechnung_summe();
int fberechnung_kleinste();
int fberechnung_groesste();

int *zahlen;
double mittelw, anzdat;

int main()
{

	fabfrage();

	for (zahlen[3]=1; zahlen[3]<anzdat; zahlen[3]++) 
	{
		std::cout << "\nBitte eine weitere Zahl eingeben: ";
		std::cin >> zahlen[4];

		fberechnung_kleinste();

		fberechnung_summe();		
	}

	mittelw = zahlen[0] / anzdat;

	std::cout << "\nSumme aller Zahlen ist: " << zahlen[0];
	std::cout << "\nMittelwert ist        : " << mittelw;
	std::cout << "\nKleinste Zahl ist     : " << zahlen[2];
	std::cout << "\nGroesste Zahl ist     : " << zahlen[1];
	std::cout << "\n";
	getchar();
	return 0;
}

int fabfrage()
{

	std::cout << "\nBitte geben Sie die Anzahl der Daten ein: \n>";
	std::cin >> anzdat;

	zahlen = new int[anzdat];

	std::cout << "\nBitte eine Zahl eingeben        : ";
	std::cin >> zahlen[4];

	zahlen[2] = zahlen[4];
	zahlen[1] = zahlen[4];
	zahlen[0] = zahlen[4];
	return 0;
}

int fberechnung_summe()
{

	zahlen[0] = zahlen[0] + zahlen[4];
	return 0;
}

int fberechnung_kleinste()
{

	if (zahlen[4] < zahlen[2])
	{
		zahlen[2] = zahlen[4];
	}
	else
		fberechnung_groesste();
	return 0;
}

int fberechnung_groesste()
{

	if (zahlen[4] > zahlen[1])
	{
		zahlen[1] = zahlen[4];
	}
	return 0;
}

[Caipi]

Ok, Speicher reservierst du jetzt dynamisch.
Aber einlesen tust du immernoch 4 Werte, das ist doch Statisch. => Daher, zum einlesen der Werte eine Schleife benutzen.

Desweiteren du gibst deinen dynamisch reservierten Speicher nich frei! => Spätestens am Ende von main() solltest du delete[] zahlen; schreiben.

//Edit:
Achso und nochwas. Ich finde dein Array-Design und deine Vergleichs-Funktionen _sehr_ strange. Sieh dir lieber mal die Funktion von mir an. Sie liefert die kleinste Zahl auch wenn du z.B. 10 Zahlen zum vergleichen hast

Caipi

[kleine kylie]

int main()
{

	fabfrage();

	for (zahlen[3]=1; zahlen[3]<anzdat; zahlen[3]++) 
	{
		std::cout << "\nBitte eine weitere Zahl eingeben: ";
		std::cin >> zahlen[4];

		fberechnung_kleinste();

		fberechnung_summe();		
	}

	mittelw = zahlen[0] / anzdat;

	std::cout << "\nSumme aller Zahlen ist: " << zahlen[0];
	std::cout << "\nMittelwert ist        : " << mittelw;
	std::cout << "\nKleinste Zahl ist     : " << zahlen[2];
	std::cout << "\nGroesste Zahl ist     : " << zahlen[1];
	std::cout << "\n";
	delete[] zahlen;
	return 0;
}

Der fällt mir mit dem delete[] zahlen (Der Pointer heißt bei mir zahlen, nich anzdat) nach der Anzeige auf die Nase... Hab ich da was falsch??

[MFK]

"Er fällt auf die Nase" ist eine schlechte Fehlerbeschreibung.

Du kannst nicht einfach mit festen Indizes auf ein Array zugreifen, von dem du zur Compilezeit noch gar nicht weißt, wie groß es ist. Was ist, wenn der Benutzer 2 eingibt? Dein Schreibzugriff auf zahlen[4] schreibt dann in nicht reservierten Speicher. Nirgendwo in deinem Code darf als Index eine feste Zahl stehen.

[enno-tyrant]

@kleine...
ich finde schon du solltest dir den code von caipi zu gemüte führen (ich weiß: schleimer ), andernfalls ändere mal deinen rückgabetyp deiner funktionen (wozu 'integer' wenn sie nichts zurückgeben?)...

[kleine kylie]

Genau das tue ich gerade... Ich führe mir den Code von Caipi zu Gemühte... und zwischendurch schaue ich, was es an neuen Beiträgen und Hilfestellungen gibt...

Bin aber noch nicht wirklich viel weiter, aber sobald es einen neuen Code von mir gibt, werde ich ihn eurer Kritik und Hilfe aussetzten Dank Euch!!

[@all]

Hallo an alle

erstmal nur der Ausführlichkeit halber und zum besseren Verständnis, den Code, wie er bisher aussieht und wie weit ich bis heute gekommen bin, danach meine Frage:

#include <iostream>
#include <cstring>

int fberechnung_groesste(int *tmp, int sizeofArrZahlen)
{
	int max = tmp[0];
	for (int i = 1; i < sizeofArrZahlen; i++)
	{
		if (tmp[i] > max)
		{
			max = tmp[i];
		}
	}

	return max;
}

int fberechnung_kleinste(int *tmp, int sizeofArrZahlen)
{
	int min = tmp[0];
	for (int i = 1; i < sizeofArrZahlen; i++)
	{
		if (tmp[i] < min)
		{
			min = tmp[i];
		}
	}

	return min;
}

int fberechnung_summe(int *zahlen, int sizeofArrZahlen)
{
	int sum = 0;
	for (int i = 0; zahlen[i] > 0; i++)
	{
		sum = sum + zahlen[i];
	}

	return sum;
}

void ftausche(int &zahl1, int &zahl2)
{
    int backup = zahl1;
    zahl1 = zahl2;
    zahl2 = backup;
}

int main()
{
	int tmp, mittelw;

	std::cout << "\nAnzahl der einzugebenden Zahlen: "; 
    int sizeofArrZahlen;

	std::cin >> sizeofArrZahlen; 
    int *zahlen = new int[sizeofArrZahlen]; 

    for (int i = 0; i < sizeofArrZahlen; ++i) 
    { 
		std::cout << "\nBitte Wert fuer " << i+1 << ". Zahl eingeben: "; 
		std::cin >> tmp; 
        zahlen[i] = tmp;
	}

	int gr = fberechnung_groesste(zahlen, sizeofArrZahlen);
    int kl = fberechnung_kleinste(zahlen, sizeofArrZahlen);
	int sum = fberechnung_summe(zahlen, sizeofArrZahlen);

	mittelw = sum / sizeofArrZahlen;

	std::cout << "\nDie Summe aller Zahlen ist      : " << sum;
	std::cout << "\nDer Mittelwert aller Zahlen ist : " << mittelw;
	std::cout << "\nDie Groesste Zahl ist           : " << gr;
	std::cout << "\nDie Kleinste Zahl ist           : " << kl;
	std::cout << "\n\n";

	std::cout << "\nDie Ergebnisse in sortierter Reihenfolge (groesster Wert zuerst): ";
	std::cout << "\n\n";

	int arrsort[5] = {sum, mittelw, gr, kl};
	int max = sizeof(arrsort) / sizeof(int);
    bool sorted = true;
    int k;

    do
    {
		sorted = true;
        for (k = 0; k < max-1; k++)
        {
            if (arrsort[k] < arrsort[k+1])
            {
                ftausche(arrsort[k], arrsort[k+1]);
                sorted = false;
            }
        }
    } while (!sorted);

    for (k=0; k < max-1; k++)
    {
    	std::cout << k+1 << ". Wert: "
	              << arrsort[k]
				  << std::endl;
    }

	getchar();

	delete[] zahlen;
	return 0;
}

Der Mittelwert muß mit 2 Nachkommastellen ausgegeben werden!! Ich weiß nich, ob ich zu blöd bin, ich hab keine Ahnung wie...

Kann mir jemand helfen?????? Bitte, bitte....

Schonmal Danke an alle, die vielleicht Zeit und Lust haben zu helfen...
Eure kleine kylie

[Caipi]

@all schrieb:

Der Mittelwert muß mit 2 Nachkommastellen ausgegeben werden!! Ich weiß nich, ob ich zu blöd bin, ich hab keine Ahnung wie...

Kann mir jemand helfen?????? Bitte, bitte....

Schonmal Danke an alle, die vielleicht Zeit und Lust haben zu helfen...
Eure kleine kylie

Um dies zu bewerkstelligen solltest du statt:

int mittelw;

lieber

double mittelw; // oder float

schreiben

//edit: Habe den Code jetzt kurz überflogen.
Warum liest du die einzelnen Zahlen zuerst in tmp ein? Du kannst doch auch direkt folgendes schreiben:

cin >> zahlen[i];

Dein Array 'arrsort' braucht nur Speicher für 4 Elemente zu reservieren. (Und demnach in der letzten for-Schleife auch nicht '< max - 1' sondern einfach nur '< max');

Ansonsten siehts doch schon viel besser aus.

Caipi

[@all]

hm... also in der ausgabe der ergebnisse bekomme ich den mittelwert jetzt nach dem ich es so:

int main()
{
	int tmp; 
	double mittelw;

	std::cout << "\nAnzahl der einzugebenden Zahlen: "; 
    int sizeofArrZahlen;

	std::cin >> sizeofArrZahlen; 
    int *zahlen = new int[sizeofArrZahlen]; 

    for (int i = 0; i < sizeofArrZahlen; ++i) 
    { 
		std::cout << "\nBitte Wert fuer " << i+1 << ". Zahl eingeben: "; 
		std::cin >> tmp; 
        zahlen[i] = tmp;
	}

	int gr = fberechnung_groesste(zahlen, sizeofArrZahlen);
    int kl = fberechnung_kleinste(zahlen, sizeofArrZahlen);
	int sum = fberechnung_summe(zahlen, sizeofArrZahlen);

	mittelw = sum / (double)sizeofArrZahlen;

abgeändert habe mit nachkommastellen ausgegeben. aber weiter unten werden die ergebnisse im code (siehe oben gesamtcode) ja noch sortiert. und da bekomme ich den wert dann in der ausgabe wieder nur ohne nachkommastellen...

wieso?

danke die kleine kylie

[Caipi]

Das liegt daran, dass dein Array 'arrsort' vom Typ int ist. Folglich kann es auch nur Elemente vom Typ int beinhalten. (Andere Datentypen werden - sofern möglich - nach int konvertiert).

Caipi