Rückgabewert einer Funktion

[Schraubt G. (g-schraubt)]

Hallo Freunde!
Ich bin gerade etwas am Verzweifeln.
Mein Ziel ist es ein Array zu sortieren (funktioniert bereits und lässt 
sich auch sortiert über ein LCD anzeigen) und dann aus diesem sortiertem 
Array den größten Wert anzeigen. jedoch klappt das nicht wie gewünscht.
Kann mir jemand sagen, was ich hierbei falsch mache?
Schöne Grüße!

hier mein bereits gekürztes Projekt:

#include <avr/io.h>
#include <stdio.h>

//aufsteigend sortieren (funktioniert wie gewollt)
char sortiere (char zahlen[], uint8_t anzahl)
{
  uint8_t i = 0, j = 0, tmp;
  
  for (i = 0; i < anzahl; i++) {
    for (j = 0; j < anzahl - i -1; j++) {
      if (zahlen[j] > zahlen[j + 1]) {
        tmp = zahlen[j];
        zahlen[j] = zahlen[j + 1];
        zahlen[j + 1] = tmp;
      }
    }
  }
}

//den letzten wert vom array auf max_wert schreiben
uint8_t finde_max_wert (char zahlen[], uint8_t max_wert)
{
  max_wert = zahlen[4];
  return max_wert;
}



int main(void)
{
    uint8_t anzahl = 5;
  uint8_t max_wert = 0;
  
  char zahlen[]= {1, 12, 23, 12, 4};

  sortiere(zahlen,anzahl);
  
  finde_max_wert (zahlen,max_wert);


//xxxxxx__Ausgabe am LCD__xxxxxx
char erstezeile[16];
sprintf(erstezeile, "%d",max_wert);
LCDTEXT(erstezeile, 1, 1);

    while (1) 
    {
    }
}

[Rufus Τ. F. (rufus)]

Schraubt G. schrieb:
> //aufsteigend sortieren (funktioniert wie gewollt)
> char sortiere (char zahlen[], uint8_t anzahl)

Diese Funktion ist zwar so deklariert, als würde sie etwas vom Typ 
"char" zurückgeben, sie tut es aber nicht -- nirgendwo in ihr taucht das 
Schlüsselwort "return" auf.

Dein Compiler sollte deswegen mindestens eine Warnung ausgeben.

> uint8_t finde_max_wert (char zahlen[], uint8_t max_wert)

Diese Funktion gibt zwar einen Wert zurück, den aber wirfst Du beim 
Aufruf der Funktion unbesehen weg. Obendrein verwirrst Du Dich selbst, 
indem Du ein und den selben Variablennamen innerhalb und außerhalb der 
Funktion verwendest.

[Dirk B. (dirkb2)]

Der Rückgabewert einer Funktion wird mit return zurück gegeben.

Dieser muss allerdings auch verarbeitet (Zuweisung) werden.

C kennt bei Funktionsaufrufen nur call -by-value

[Mick (Gast)]

Dein Sortieralgorithmus funktioniert so nicht. Der gibt nämlich 
folgendes zurück:

0
1
4
12
12

[Schraubt G. (g-schraubt)]

Hallo Rufus, Danke für deine Antwort.

wenn ich jetzt das sortierte Array "zahlen" in meiner Funktion mittels 
"return zahlen;" zurückgebe ist es jetzt auch außerhalb der Funktion 
sortiert gespeichert. -richtig?
denn wenn ich es am LCD ausgebe, wird es auch sortiert ausgegeben.

woran liegt es, dass der return-Wert weggeworfen wird?
diesen Teil verstehe ich nicht. Der Inhalt des 4. Feldes vom Array 
"zahlen" sollte jetzt doch der Variable max_wert zugewiesen sein oder 
irre ich mich?

Schöne Grüße und schonmal Danke für die Antwort

[zitter_ned_aso (Gast)]

warum nicht einfach beim gleichen Datentyp bleiben? (statt char und 
uint... zu mischen)

[c-hater (Gast)]

Schraubt G. schrieb:

> Mein Ziel ist es ein Array zu sortieren (funktioniert bereits

Nicht wirklich. Das ist ein FALSCH implementiertes Bubble-Sort. Nur 
unter gewissen günstigen Umständen liefert es das gewünschte Resultat.

->Lerne Programmieren. Ja, man darf dazu auch fremde Quelltexte lesen. 
Ich würde mal grob schätzen, dass es 10^4..10^5 Quelltexte im Internet 
gibt, die ein Bubble-Sort korrekt umsetzen. Allerdings wohl auch kaum 
eine Größenordnung weniger, die es falsch umsetzen.

Damit du unterscheiden kannst, was richtig und was falsch ist, musst du 
wohl am Ende doch verstehen lernen, wie der (korrekte) Algorithmus 
funktioniert...

[zitter_ned_aso (Gast)]

Bei Funktion "sortieren" kannst du ruhig "void" als Rückgabetyp nehmen.


Dein Originalarray wird ja in der Runktion verändert.

[Rufus Τ. F. (rufus)]

Schraubt G. schrieb:
> wenn ich jetzt das sortierte Array "zahlen" in meiner Funktion mittels
> "return zahlen;" zurückgebe ist es jetzt auch außerhalb der Funktion
> sortiert gespeichert. -richtig?

Das Array existiert nur einmal, außerhalb Deiner Sortierfunktion. Der 
wird nur ein Pointer auf das Array übergeben, auch wenn Du dort die 
Array-Notation verwendet hast.

Es ist also überflüssig, hier das Array zurückzugeben.

Dein Sortierfunktion muss vielleicht einfach --- gar nichts zurückgeben?

Dann solltest Du sie so deklarieren, daß sie "void", also nichts, 
zurückgibt.

Schraubt G. schrieb:
> woran liegt es, dass der return-Wert weggeworfen wird?

Eine Funktion gibt einen Wert zurück, der an der Stelle des Aufrufers 
verarbeitet werden muss, z.B. mit einer Zuweisung. Das aber machst Du 
nicht.

Ein Beispiel:

int funktion(void)
{
  return 37;
}

void main(void)
{
  funktion();
}

Mit der von der Funktion zurückgebenen 37 passiert nichts.

Und genauso sieht Dein Aufruf von "finde_max_wert" aus.

Damit mein Beispiel etwas weniger sinnlos ist, kann es so abgeändert 
werden:

void main(void)
{
  int ergebnis;

  ergebnis = funktion();
}

Und schon steht in "ergebnis" das drin, was die Funktion zurückgegeben 
hat.


--

All' das ist elementares C und steht in den ersten Kapiteln jedes 
ernstzunehmenden Buches über die Sprache drin, es wird auch in den 
ersten paar Lehrveranstaltungen in egal welchen Lehreinrichtungen 
vermittelt.

[Schraubt G. (g-schraubt)]

c-hater schrieb:
> Schraubt G. schrieb:
>
>> Mein Ziel ist es ein Array zu sortieren (funktioniert bereits
>
> Nicht wirklich. Das ist ein FALSCH implementiertes Bubble-Sort. Nur
> unter gewissen günstigen Umständen liefert es das gewünschte Resultat.
>
> ->Lerne Programmieren. Ja, man darf dazu auch fremde Quelltexte lesen.
> Ich würde mal grob schätzen, dass es 10^4..10^5 Quelltexte im Internet
> gibt, die ein Bubble-Sort korrekt umsetzen. Allerdings wohl auch kaum
> eine Größenordnung weniger, die es falsch umsetzen.
>
> Damit du unterscheiden kannst, was richtig und was falsch ist, musst du
> wohl am Ende doch verstehen lernen, wie der (korrekte) Algorithmus
> funktioniert...

Danke dir! Ich werde mir diesen Teil nochmal genauer ansehen. Ich habe 
ihn aus einem anderen Projekt von mir, welches funktionierte -Machte bis 
heute keine Probleme. Aber ich sehe es mir an. Danke!

[zitter_ned_aso (Gast)]

Schraubt G. schrieb:
> uint8_t finde_max_wert (char zahlen[], uint8_t max_wert)
> {
>   max_wert = zahlen[4];
>   return max_wert;
> }



Was machst du da mit dem zweiten Parameter? Im Prinzip würde auch

return zahlen[4];

reichen. Aber wozu?

Wenn Array (aufsteigend) sortiert ist und du die Länge des Array kennst, 
dann brauchst du keine solche Funktion.

Außerdem ist der Name der Funktion irritierend. Da wird kein max. Wert 
gesucht, sondert das 4. Arrayelement zurückgegeben.

[Schraubt G. (g-schraubt)]

Besser hätte man es nicht erklären können! Danke!
Ich hatte da wohl eine dummen Verständnisfehler.

[Dirk B. (dirkb2)]

Für den Maximalwert muss man das Array nicht sortieren.

Einmal durchsuchen reicht aus.

[Schraubt G. (g-schraubt)]

zitter_ned_aso schrieb:
> Schraubt G. schrieb:
>> uint8_t finde_max_wert (char zahlen[], uint8_t max_wert)
>> {
>>   max_wert = zahlen[4];
>>   return max_wert;
>> }
>
>
>
> Was machst du da mit dem zweiten Parameter? Im Prinzip würde auch
>

> return zahlen[4];
>

> reichen. Aber wozu?
>
> Wenn Array (aufsteigend) sortiert ist und du die Länge des Array kennst,
> dann brauchst du keine solche Funktion.
>
> Außerdem ist der Name der Funktion irritierend. Da wird kein max. Wert
> gesucht, sondert das 4. Arrayelement zurückgegeben.


Da hast du vollkommen recht. Ich hätte mich besser ausdrücken müssen. 
Das hier ist nur ein kleiner Teil von meinem Projekt. in der Funktion 
finde_max_wert wird im "richtigen" Projekt sehrwohl der Maximalwert 
ermittelt. Dieser muss jedoch bestimte Bedingungn erfüllen um als 
Maximalwert gültig gemacht zu werden.  das

return zahlen[4];

sollte natürlich auch nur als Beispiel dienen.

Schöne Grüße

[Schraubt G. (g-schraubt)]

Dirk B. schrieb:
> Für den Maximalwert muss man das Array nicht sortieren.
>
> Einmal durchsuchen reicht aus.

Hallo Dirk,
habe vergessen zu erwähnen dass dies nur eine kleiner Teil eines anderen 
Projektes ist. Im "richtigen" Projekt wird unteranderem noch ermittelt 
wie oft Welche Zahl vorkommt usw. Das hier diente nur als Beispiel.

LG

[Yalu X. (yalu) (Moderator)]

c-hater schrieb:
> Nicht wirklich. Das ist ein FALSCH implementiertes Bubble-Sort. Nur
> unter gewissen günstigen Umständen liefert es das gewünschte Resultat.

Dann nenne doch mal ein Beispiel für einen ungünstigen Umstand.

[c-hater (Gast)]

Schraubt G. schrieb:

> Danke dir! Ich werde mir diesen Teil nochmal genauer ansehen. Ich habe
> ihn aus einem anderen Projekt von mir, welches funktionierte

...welches bestenfalls scheinbar funktionierte. Wenn überhaupt, dann 
weil halt dort wohl die besonderen Umstände gegeben waren, unter denen 
es das gewünschte Resultat liefern konnte...

Sehr viel wahrscheinlicher ist aber: Niemand hat je bemerkt, dass da 
Müll rauskommt, weil es niemals systematisch getestet wurde...

[Schraubt G. (g-schraubt)]

Kai k. schrieb im Beitrag #5782085:
> oje...der Fehler ist offensichtlich..schau mal
> #include <avr/io.h>
> #include <stdio.h>
>
> das klingt mega nach C..
> Der Fehler: falsche Programmiersprache..damit passiert sowas sehr
> schnell

Hallo Kai,
was stimmt deiner Meinung nach hierbei nicht bzw. was ist das Problem?
LG

[Rufus Τ. F. (rufus)]

Kai k. schrieb im Beitrag #5782085:
> Der Fehler: falsche Programmiersprache..

Der eine Programmiersprachentroll in diesem Thread reicht.

[Skeptiker (Gast)]

Der Bubble-Sort ist korrekt programmiert. Wo soll das Problem sein?

[Stefan F. (Gast)]

Quick Sort ist bei größeren Arrays viel schneller und nicht viel 
komplizierter. Schau dir den Algorithmus mal an, nachden dein aktuelles 
Problen gelöst ist.

[Schraubt G. (g-schraubt)]

Stefanus F. schrieb:
> Quick Sort ist bei größeren Arrays viel schneller und nicht viel
> komplizierter. Schau dir den Algorithmus mal an, nachden dein aktuelles
> Problen gelöst ist.

Das aktuelle Problem ist gelöst!
Danke für deinen Tip. Von Quick Sort habe ich noch nichts gehört. Werde 
mich mal schlau machen (:

[Tim T. (tim_taylor)]

Stefanus F. schrieb:
> Quick Sort ist bei größeren Arrays viel schneller und nicht viel
> komplizierter. Schau dir den Algorithmus mal an, nachden dein aktuelles
> Problen gelöst ist.

Und auf Systemen mit kleinem Stack nicht unbedingt die cleverste Idee.

[Yalu X. (yalu) (Moderator)]

Schraubt G. schrieb:
> Danke für deinen Tip. Von Quick Sort habe ich noch nichts gehört.

Die gibt es bereits fix und fertig in der C-Standardbibliothek:

  https://linux.die.net/man/3/qsort

Skeptiker schrieb:
> Der Bubble-Sort ist korrekt programmiert. Wo soll das Problem sein?

Ich glaube, das Hauptproblem ist, dass einer, der C abgrundtief hasst,
es unmöglich beherrschen kann :)

Auf meine Aufforderung weiter oben kam (evtl. genau aus diesem Grund)
noch keine Antwort:

Yalu X. schrieb:
> c-hater schrieb:
>> Nicht wirklich. Das ist ein FALSCH implementiertes Bubble-Sort. Nur
>> unter gewissen günstigen Umständen liefert es das gewünschte Resultat.
>
> Dann nenne doch mal ein Beispiel für einen ungünstigen Umstand.

[Tim T. (tim_taylor)]

Naja, ich würde i nur bis kleiner Anzahl - 1 laufen lassen...