Ergebnis in Array speichern

Hey..

ich habe in einer Schleife eine Berechnung. Am Ende jedes Durchlaufs habe ich ein Ergebnis.
Jetzt will ich die 3 besten Ergebnisse in einem Array hinterlegen... Wie mache ich das. Dazu kommt noch, dass zu jedem Ergebnis eine ID gehört, die auch mit abgespeichert werden soll.

Hilfe!

Caipi

Hallo:welt schrieb:

Jetzt will ich die 3 besten Ergebnisse in einem Array hinterlegen...

Was meinst du konkret mit "die 3 besten Ergebnisse"?

Bzg. der Sache mit der Id, empfehle ich dir eine Struktur zu verwenden. Z.B.:

struct result
{
    int value; //  ergebnis wert
    int id; // ergebnis id.
};

Jetzt definierst du ein c-Array (oder noch besser einen std::vector), der Elemente vom Typ result beeinhalten kann.

result arr[10] = { ... }; // Array mit 10 Elementen vom Typ result.
std::vector<result> vec(10); // gleiches mit std::vector.

In der Schleife machst du nun folgendes:

for(size_t i = 0; i < ABRUCH_BEDINGUNG; ++i) // eventuell sieht der Kopf natürlich anders aus ;-)
{
    if(eines_der_besten_ergebnisse) // deine Bedingung für die drei besten Ergebnisse.
    {
        arr[i].value = ...; // dem i-ten Element von arr die Berechnung zuweisen.
        arr[i].id = ...; // dem i-ten Element von arr eine id zuweisen.

        // bzw. mit std::vector
        vec[i].value = ...;
        vec[i].id = ...;
    }
}

Falls du genauere Hilfe haben möchtest, sag uns doch einfach ein bischen genauer, was du machen willst

Gruß Caipi

ohne nähere informationen zu deinem problem, z. bsp. was die bewertungsfunktion, die berechnung, oder die werte und ids der ergebnisse angeht, ist es wirklich nicht einfach was zu sagen. hier trotzdem ein funktionierendes beispiel:

#include <iostream>
#include <algorithm>
using std::cout;
using std::endl;
using std::cin;

template <typename T>
struct Ergebnis
{
	int dieID;
	T derWert;

	bool istBesserAls(const Ergebnis &anderesErgebnis) const
	{
	    return derWert > anderesErgebnis.derWert;
	}
};

template <typename T>
T dieBerechnung(T wert) { return wert; }

int main()
{
    const int NBESTE = 3;
    Ergebnis<int> dieBesten[NBESTE];
    Ergebnis<int> dieWerte[] = {
        {0, 321},
        {1, 4321},
        {2, 51},
        {3, 21},
        {4, 5312}};
    const int NGESAMT = sizeof(dieWerte)/sizeof(Ergebnis<int>);
    int i, j, k;
    Ergebnis<int> dasBerechnungsErgebnis;

    for (i=0; i<NGESAMT; ++i)
    {
        //...
        dasBerechnungsErgebnis = dieBerechnung(dieWerte[i]);

        j=0;
    	while(j<i)
    	{
    	    if(!dieBesten[j].istBesserAls(dasBerechnungsErgebnis))
    	    {
                for(k=std::min(i,NBESTE-1); k>j; --k)
                    dieBesten[k] = dieBesten[k-1];
                dieBesten[j] = dasBerechnungsErgebnis;
                break;
    	    }
            ++j;
    	}
    	if(j==i && j<NBESTE)
            dieBesten[j] = dasBerechnungsErgebnis;
    }

    for (i=0; i<NBESTE; ++i)
        cout << dieBesten[i].derWert << endl;

    cin.get();
}

ups schon einen fehler gefunden! die while-schleife muss so aussehen:

while(j<i && j<NBESTE)

sonst kann es mit dem zugriff auf dieBesten schiefgehen

CStoll

Warum selber schreiben, wenn man vorgegebene Algorithmen nutzen kann?

partial_sort_copy(dieWerte,dieWerte+NGESAMT,dieBesten,NBESTE,mem_fun_ref(Ergebnis<int>::istBesserAls));

Hmm vielen Dank.

Und wie baue ich das ganze ein.

Ich will eine Funktion schreiben.

void storeResult(int result,int id);

Das Programm von Schorsch verstehe ich nicht so ganz... Geht das nicht einfacher?

Die Id muss quasi die ganze Zeit mit dem Result evrknüpft sein. Wahrscheinlich mit Zeigern.

Ganz Basic habe ich eine Funktion geschrieben, die die Vergleiche für den Inhalt eines Arrays ausführt.

void Ausgabe (int Array[]) {
    for(int i=0; i<3; i++) 
      cout << i << ". Zahl im Array: " << Array [i] << endl;
}

void putinArray (int Array [], int zahl){

if (zahl > Array [0]) {
      Array[2] = Array [1];
      Array[1] = Array [0];
      Array[0] = zahl;
      Ausgabe  (Array);}
else if ( zahl > Array [1]) {
      Array[2] = Array [1];
      Array[1] = zahl;
      Ausgabe (Array); }
else if (zahl > Array[2]) {
      Array[2] = zahl;
      Ausgabe (Array); }
else
 cout << " Zahl ist kleiner als alle anderen Zahlen" << endl;
}

void main {

int Array [3];

Array [0] = 8;
Array [1] = 5;
Array [2] = 2;

int zahl = 6;
putinArray (Array,zahl);
system ("PAUSE");
}

}

Und wie gehe ich jetz weiter vor?

Danke

CStoll

hallo:Welt schrieb:

Die Id muss quasi die ganze Zeit mit dem Result evrknüpft sein. Wahrscheinlich mit Zeigern.

Nein, da ist eine struct besser geeignet, siehe bei schorch "Ergebnis" - die fasst Wert und ID zusammen und verarbeitet sie als eine Einheit.

Ansonsten schlage ich mal vor, statt blanken Arrays lieber STL-Container zu verwenden (z.B. vector).
(... und dich mal etwas intensiver mit C++ zu beschäftigen ;))

ich beschäftige doch gerade sehr intensiv mit c++. Sorry, aber es braucht halt alles seine Zeit.

Also du meinst ich sollte das so machen wir schorsch das vorgeschlagen hat....

Nur versteh ich nicht, wie ich dann auf die einzelnen Elemente zugreifen kann und z.B. den Vektor speziell nach dem Wert sortieren lassen kann.

Das mit dem putinArray brauchst du nicht. Wie CStoll schon vorgeschlagen hat: Warum selber machen, wenn die STL es kann! Mit partial_sort_copy sieht das beispiel schon viel übersichtlicher aus:

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

template <typename T>
struct Ergebnis
{
    int dieID;
    T derWert;
};

template <typename T>
bool istBesserAls(const Ergebnis<T> &a, const Ergebnis<T> &b)
{
	return a.derWert > b.derWert;
}

template <typename T>
T dieBerechnung(T wert) { return wert; }

int main()
{
    const int NBESTE = 3;
    Ergebnis<int> dieBesten[NBESTE];
    Ergebnis<int> dieWerte[] = {
        {0, 321},
        {1, 4321},
        {2, 51},
        {3, 21},
        {4, 5312}};
    const int NGESAMT = sizeof(dieWerte)/sizeof(Ergebnis<int>);

    partial_sort_copy(
		dieWerte,
		dieWerte+NGESAMT,
		dieBesten,
		dieBesten+NBESTE,
		istBesserAls<int>);

	for (int i=0; i<NBESTE; ++i)
        cout << dieBesten[i].derWert << endl;

    cin.get();
}

achso.

template <typename T>
T dieBerechnung(T wert) { return wert; }

wird da natürlich nicht verwendet.

Kurz mal ne Frage:

was bedeutet denn immer das

template <typename T>

?
Sorry für die blöde Frage.

Und könntest du eventuell mal ein paar Kommentare dazuschreiben???

Sorry

das sind templates

geheimtipp: mein alter kumpel google.de weiß mehr über das thema

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

//template <typename T> bedeutet, dass das struct Ergebnis
//später mit einem Typ T konfiguriert werden kann
//z. Bsp. bedeutet dann Ergebnis<int>, dass derWert vom Typ int sein wird.
template <typename T>
struct Ergebnis
{
    int dieID;
    T derWert;
};

//template <typename T> bedeutet, dass die Funktion istBesserAls
//Werte verschiedener Ergebnis-Typen vergleichen können soll.
//Im Beispiel wird sie für Werte vom Typ Ergebnis<int> verwendet.
template <typename T>
bool istBesserAls(const Ergebnis<T> &a, const Ergebnis<T> &b)
{
    return a.derWert > b.derWert;
}

int main()
{
    const int NBESTE = 3;
    Ergebnis<int> dieBesten[NBESTE];
    Ergebnis<int> dieWerte[] = {
        {0, 321}, //erster Wert: dieID wird mit 0 initialisiert, derWert wird mit 321 initialisiert
        {1, 4321},//zweiter Wert: ...
        {2, 51},
        {3, 21},
        {4, 5312}};
    const int NGESAMT = sizeof(dieWerte)/sizeof(Ergebnis<int>);

    //sortiert die N besten heraus
    partial_sort_copy(
        dieWerte, //Anfangsadresse der Werte
        dieWerte+NGESAMT,  //Endadresse der Werte
        dieBesten, //Anfangsadresse der N besten
        dieBesten+NBESTE, //Endadresse der N besten
        istBesserAls<int> //Vergleichsfunktion für Ergebnis<int>
        );

    for (int i=0; i<NBESTE; ++i)
        cout << (i+1) << ".er ist id: " << dieBesten[i].dieID << "; wert:" << dieBesten[i].derWert << endl;

    cin.get();
}

super,vielen Dank.

Noch 2 Fragen:

1. Und wie fülle ich den Vector jetzt wenn eine ID und ein Wert reinkommt?
2. Wie bekomme ich für den besten Wert die ID zurück?

Danke