Höchsten Zahlenwert im Array suchen.



  • Hi Leute, ich befasse mich seit kurzem mit c++. Um sich mit der Materie besser auseinandere zusetzen, denke ich mir was aus und versuche es umzusetzen.

    So wollte ich gern ein vorgegebenes Array nach dem höchsten Wert durchsuchen und diese dann Ausgeben.

    Ich habe mir gedacht, dass ich den ersten Wert aus dem Array einer Pointervariabel übergeben und es dann mit den restlichen Werten vergleich.
    Das Funktioniert soweit. Allerdings bring ja dann mein erster Wert im Array durch den höchsten Wert überschrieben.

    Mein Fragen. Ist mein Ansatz grundlegend richtig? Wenn ja, wie kann ich mein Problem lösen, dass das erste Element im Array nicht überschrieben wird.

    int meng [] = {350, 15350, 5500, 500, 25, 230, 70200, 33, 4, 12000};
    int s2, max, k;
    int*sp1;			
    
    k = sizeof(meng)/sizeof(int);
    	
       for (int j=1; j<k; j++){
    
        s2 = meng [j];
    
        sp1 = & meng [0];			
    
    	if (*sp1 > s2){			
    
    	  max = *sp1;
                  }
    
    	else {
    
    		*sp1 = s2;		
    		max = *sp1;
    
    		}
    
    }
    

    Ist mein erste Beitrag. Hoffe ich habe nix großartig flasch gemacht.

    Hoffe sehr, dass ihr mir helfen könnte.

    Vg Jens



  • @zaro2020 sagte in Höchsten Zahlenwert im Array suchen.:

    Mein Fragen. Ist mein Ansatz grundlegend richtig?

    Warum zeigt der Zeiger nicht auf das bisher größte Element?

    Insgesamt sieht es eher so aus, als lerntest du C und nicht C++. Benutze std::vector, nicht C-Style Arrays. Damit kannst du dich später auseinandersetzen.



  • In C++ sähe das vermutlich so aus:

    #include <algorithm>
    #include <iostream>
    
    int main() {
        int meng[] = {350, 15350, 5500, 500, 25, 230, 70200, 33, 4, 12000};
        auto max = *std::max_element(std::begin(meng), std::end(meng));
        std::cout << "Das Maximum ist " << max << "\n";
    }
    

    (oder variabler, wenn wir auch annehmen müssen, dass die Menge leer sein kann:)

    #include <algorithm>
    #include <iostream>
    #include <vector>
    
    int main() {
        std::vector<int> meng = {350, 15350, 5500, 500, 25, 230, 70200, 33, 4, 12000}; // oder von Usereingabe
    
        auto maxIt = std::max_element(begin(meng), end(meng));
        if (maxIt == end(meng)) {
            std::cout << "Menge ist leer - kein größtes Element\n";
        } else {
            std::cout << "Das Maximum ist " << *maxIt << "\n";
        }
    }
    


  • Ich hätte es ohne std::-Funktionen so gemacht:

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct a_elem
    {
        int max, max_index;
        int *maxp;
    } A_Elem;
    
    /**
     * count must be greater 0.
     */
    A_Elem *search_max(int *const a, const int count)
    {
        A_Elem *ae = malloc(sizeof(A_Elem));
        int i = 0;
        int maxi = 0;
        for (; i < count; i++)
        {
            if (a[i] > a[maxi])
            {
                maxi = i;
            }
        }
        ae->max_index = maxi;
        ae->max = a[maxi];
        ae->maxp = &a[maxi];
        return ae;
    }
    
    int main()
    {
        int meng[] = {350, 15350, 5500, 500, 25, 230, 70200, 33, 4, 12000};
        A_Elem *max = search_max(meng, sizeof(meng) / sizeof(int));
        printf("%d\n", max->max_index);
        printf("%d\n", max->max);
        printf("%d\n", *max->maxp);
        free(max);
        max = 0;
        return 0;
    }
    


  • @EinNutzer0 sagte in Höchsten Zahlenwert im Array suchen.:

    Ich hätte es ohne std::-Funktionen so gemacht:

    1. das ist C, kein C++
    2. malloc in der search_max-Funktion? WTF?


  • @EinNutzer0 sagte in Höchsten Zahlenwert im Array suchen.:

    A_Elem *search_max(int *const a, const int count)
    {
        A_Elem *ae = malloc(sizeof(A_Elem));
    ...
    
    int main()
    {
        ...
        free(max);
    

    😱

    jetzt wissen wir wenigstens, warum wir den Server 4 mal täglich neu starten müssen, um as Programm am Leben zu halten 😉



  • @Finnegan Wie geht es besser? Die Frage des TEs ist ja auch so halb c. 😉



  • @EinNutzer0 sagte in Höchsten Zahlenwert im Array suchen.:

    @Finnegan Wie geht es besser? Die Frage des TEs ist ja auch so halb c. 😉

    @wob hat schon einen guten Ansatz gezeigt. Wenn @zaro2020 es selbst machen will, dann würde ich empfehlen, ein max_element selbst zu implementieren, dass sich wie std::max_element verhält, mit einer von diesen Signaturen:

    // C++20
    #include <iterator>
    
    template <std::forward_iterator I>
    I max_element(I begin, I end);
    
    // C++11
    template <typename I>
    I max_element(I begin, I end);
    

    oder ohne Templates erstmal zum üben, direkt eine Spezialisierung für int* - die Pointer verhalten sich genau so wie Iteratoren, der Code is quasi der selbe:

    int* max_element(const int* begin, const int* end);
    

    Ansatz:

    template <typename I>
    I max_element(const I begin, const I end)
    {
        if (begin == end)
            return end;
    
        I i = begin;
        I max = i++;
        
        for (; i != end; ++i)
        {
            ...
            max = i;
            ...
        }
    
        return max;
    }
    


  • Arrr, ich muss genauer fragen, wo war das Problem mit meinem Code?


  • Mod

    @EinNutzer0 sagte in Höchsten Zahlenwert im Array suchen.:

    Arrr, ich muss genauer fragen, wo war das Problem mit meinem Code?

    Eine Funktion hat gefälligst nie Speicher zu allokieren, den sie nicht selber frei gibt, außer sie ist eine Speicherallokationsfunktion! (Das gilt auch ganz allgemein für jede Art von Ressource: Derjenige, der anfordert, ist persönlich für Freigabe verantwortlich)

    Warum machst du das überhaupt, anstatt der "normalen" Methode ohne malloc? Das erschließt sich mir überhaupt nicht, wie man darauf kommen kann. Als Referenz, die normale Methode:

    A_Elem ae;
    ...
    ae.max = whatever;
    return ae;
    

    Siehe auch:
    @Finnegan sagte in Höchsten Zahlenwert im Array suchen.:

    😱

    jetzt wissen wir wenigstens, warum wir den Server 4 mal täglich neu starten müssen, um as Programm am Leben zu halten 😉

    Da ist zwar ein Smiley dran, aber das meint er schon ernst, dass das der Effekt deiner Programmierweise ist.



  • @SeppJ Ist es so besser und hättest du es auch so gemacht?

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct a_elem
    {
        int max, max_index, *maxp;
    } A_Elem;
    
    /**
     * count must be greater than 0.
     */
    A_Elem search_max(int *const a, const int count)
    {
        A_Elem ae;
        int i = 0;
        int max_index = 0;
        for (; i < count; i++)
        {
            if (a[i] > a[max_index])
            {
                max_index = i;
            }
        }
        ae.max_index = max_index;
        ae.max = a[max_index];
        ae.maxp = &a[max_index];
        return ae;
    }
    
    int main()
    {
        int meng[] = {350, 15350, 5500, 500, 25, 230, 70200, 33, 4, 12000};
        A_Elem max = search_max(meng, sizeof(meng) / sizeof(int));
        printf("%d\n", max.max_index);
        printf("%d\n", max.max);
        printf("%d\n", *max.maxp);
        return 0;
    }
    

    Ich wusste gar nicht, dass C Call By Value Result ist; also dass das return ae; bewirkt, dass eine Kopie von ae an den Caller gegeben wird.
    Oder liege ich jetzt ganz falsch?



  • @EinNutzer0 Bliebe noch die fehlende const correctness (was ich persönlich fast noch schlimmer finde).
    Und dann fällt natürlich noch auf, dass entweder der Index oder der Zeiger reicht (auch, um anschließend auf den Wert zu kommen).
    Für den Maximalwert könnte man einfach eine weitere Funktion schreiben.



  • @EinNutzer0
    Es muss also unbedingt eine C-Lösung sein? Ich hätte das so gemacht (im Prinzip wie deine Lösung, nur ohne den überflüssigen Rückgabetyp):

    int max_element( int const* ptr, unsigned int count )
    {
       if( count > 0 )
       {
          int candidate_index = 0;
          for( int i = 1; i < count; ++i )
          {
             if( ptr[i] > ptr[candidate_index] )
             {
                candidate_index = i;
             }
         }
         return candidate_index;
       }
       return -1;
    }
    

    Wenn der Rückgabewert -1 ist gab´s keinen Treffer, ansonsten ist er der Index des größten Elements. Dann braucht man auch keine Struktur für den Rückgabewert, die doch nur redundante Informationen enthält.


  • Mod

    @EinNutzer0 sagte in Höchsten Zahlenwert im Array suchen.:

    Ich wusste gar nicht, dass C Call By Value Result ist; also dass das return ae; bewirkt, dass eine Kopie von ae an den Caller gegeben wird.
    Oder liege ich jetzt ganz falsch?

    ???

    Bei

    int foo()
    {
        int i = 4;
        return i;
    }
    

    würdest du doch sicher nicht einmal mit der Wimper zucken, oder? Ist genau das gleiche. Zumal bei dir doch der Pointer selbst auch ein Wert ist, der irgendwie aus der Funktion heraus kommt…



  • Hi Leute, vielen Dank für euren Input.

    Laut den Kommentaren schweife ich wohl in den C-Style ab. Das war mir so nicht bewusst, ist auch nicht gewollt.
    Wie bereits geschrieben, habe ich erst vor kurzem Angefangen mich mit C++ zu beschäftigen, von C habe ich
    allerdings auch keine Ahnung. Programmieren ist relativ neu für mich. Als Lehrfaden hab ich mir eine Youtubereihe für C++ rausgesucht. Bisher wurden die Basics in der Programmierung behandelt wie Schleifen, Funktionen, Header, Datentype...

    <Vector> wurde allerdings bis jetzt noch nicht behandelt. Ich möchte nicht zu erste die Videoreihe durchschauen und dann los legen, sondern versuche kleine Sachen nach jeden Video zu "programmieren" und immer wieder etwas auszubauen, damit die Basics sitzen und ich nicht immer nach schauen muss, wie es nochmal mit den Grundstruckturen ist...

    Im Allgemeine habe ich bis jetzt nur <iostream> inkludiert und benutzen noch "using namespace std". Alles andere kenn ich noch nicht...

    Vg Jens



  • @zaro2020 sagte in Höchsten Zahlenwert im Array suchen.:

    mir eine Youtubereihe für C++ rausgesucht

    Das ist der Kardinalfehler

    @zaro2020 sagte in Höchsten Zahlenwert im Array suchen.:

    <Vector> wurde allerdings bis jetzt noch nicht behandelt

    Das Tutorial ist unbrauchbar



  • @SeppJ Sorry... Meine Frage ist: Wer räumt wann was weg?



  • @manni66 sagte in Höchsten Zahlenwert im Array suchen.:

    @zaro2020 sagte in Höchsten Zahlenwert im Array suchen.:

    mir eine Youtubereihe für C++ rausgesucht

    Das ist der Kardinalfehler

    @zaro2020 sagte in Höchsten Zahlenwert im Array suchen.:

    <Vector> wurde allerdings bis jetzt noch nicht behandelt

    Das Tutorial ist unbrauchbar

    Wie sonst? Lieber ein Lehrbuch? In eine Vorlesung zu gehen oder eine Kurs zu besuchen geht leider momentan nicht.

    Das Tutorial hat noch einiges an Videos und ich weis nicht was kommt... aber anscheident hätte die Sache mit Vector schon behandetl werden müssen...

    Kann jemand von euch ein Tutorail empfehlen?



  • @zaro2020 sagte in Höchsten Zahlenwert im Array suchen.:

    Lieber ein Lehrbuch?

    Ja



  • @zaro2020 sagte in Höchsten Zahlenwert im Array suchen.:

    Kann jemand von euch ein Tutorail empfehlen?

    Das scheint gut zu sein: https://www.youtube.com/watch?v=KJgsSFOSQv0 (ca. 4 Stunden, 5 Minuten hab ich aber nur zugehört)

    Aber nutze lieba ein Lehrbuch.


Log in to reply