[C] sgn-Funktion verhält sich komisch (falsche Rückgabe)

[fkerber]

Hi!

Entweder stehe ich mächtig auf dem Schlauch oder irgendwas ist hier faul.
Es geht um die Implementierung der SGN-Funktion. Folgender Versuch scheitert ganz massiv:

Code:

int sgn(float p)
{
   if(p=0) 
   return 0;

   if(p>0)
   return 1;

   if(p<0) 
   return -1;
}

Es kommt folgendes bei raus:

Code:

sgn(-9)  --> -1
sgn(0)   --> 7842
sgn(6)   --> 7842

Lasse ich das letzte if weg (also immer -1 returnen, wenn er an die stelle kommt) oder schreibe noch irgendein return dahinter ist alles in Butter.

Meine Vermutung ist, dass es irgendwas mit undefiniertem Funktionswert zu tun haben könnte, aber ich verstehe nicht wieso. Es sind ja alle Eingaben eigentlich abgedeckt...


Ciao, Frederic

[Dax]

[edit]snip, desregard that :/[/edit]

[3_of_8]

Ähem!

Code:

   if(p=0) 
   return 0;

Wie heißt der Gleichheitsoperator in C? ;)

[Florian H]

Zitat:

Zitat von 3_of_8

Ähem!
Wie heißt der Gleichheitsoperator in C? ;)

Joah, böse Falle für Pascal'er :)
Wie kommt allerdings das seltsame Ergebnis dann zustande?
(p=0) ergibt doch eigentlich immer true, sodass eine 0 zurückgegeben wird und p danach 0 ist ?

[3_of_8]

p=0 gibt 0 zurück, 0 wird als false interpretiert, der Rückgabewert ist daher undefiniert. (Also Stackmüll)

[fkerber]

ARGH :wall: :wall: :wall: :wall: :wall: :wall:

Es ist nicht mein Code, aber ich habe ihn jetzt bestimmt 2h angeschaut und kam nicht drauf woran es hängt.
Dann ist der Fehler aber klar.
Es wird 0 zu gewiesen, dann gibt es dafür aber keinen Else-Fall mehr und somit undef. irgendwas als Ergebnis...

Danke!

[3_of_8]

Das passiert jedem mal, vor allem, wenn man nicht allzu viel mit C macht, und selbst wenn... Da ist eine strenge Sprache wie Java doch von Vorteil, da kann sowas nur passieren, wenn man Booleans vergleicht, und wann macht man das schon. :mrgreen:

Im übrigen, die übersichtliche Version wäre ja die folgende:

Code:

int sgn(float x) {
  return (x<0)?-1:((x>0)?1:0));
}

[fkerber]

Ob ein Programmieranfänger dir da zustimmen würde?
Aber grundsätzlich hast du recht!

[3_of_8]

Da war auch eine gewisse Ironie dabei. ;)

[Der Jan]

Zitat:

Zitat von 3_of_8

Im übrigen, die übersichtliche Version wäre ja die folgende:

Code:

int sgn(float x) {
  return (x<0)?-1:((x>0)?1:0));
}

Ich bezweifle, dasss das ein Pascaler für übersichtlich halten wird, aber ich liebe diesen Operator :) *sich duckt und wegschleicht*

[Dax]

Zitat:

Zitat von 3_of_8

Im übrigen, die übersichtliche Version wäre ja die folgende:

Code:

int sgn(float x) {
  return (x<0)?-1:((x>0)?1:0));
}

Was macht das mit nicht finiten Werten? ;)

[Der Jan]

float wird nicht infinit :)

ok, mormalerweise nicht. bei diesem definierten infinit-Value müßte man es testen.

[3_of_8]

Naja, das kann schon passieren. 1/0 liefert infinty, -1/0 liefert -infinity (die 0 ist hier eine +0)

Wie sich das jetzt verhält, hängt davon ab, wie sich die FPU bei Vergleichen von Infinity-Werten verhält, das müsste ich jetzt ausprobieren...

[himitsu]

Zitat:

Zitat von Der Jan

Ich bezweifle, dasss das ein Pascaler für übersichtlich halten wird, aber ich liebe diesen Operator :) *sich duckt und wegschleicht*

nja, für die Programmieranfänger dann halt irgendwie so :angel2:

Code:

int sgn(float p)
{
   if (p < 0) {
     return -1;
   }
   else
   if (p > 0) {
     return +1;
   }
   else 
     return 0;
}

ich hoff das sieht nicht all zu schlimm aus (kommt ja nur von 'nem Pascaler)

[fkerber]

Das nenne ich dann, das Problem elegant "umschifft"... ;)


Ciao, Frederic

[Apollonius]

Unendlich große Werte sind kein Problem, aber NaNs, denn mit diesen schlagen alle Vergleiche fehl.

Edit: Oder auch nicht. Vermutlich ist das Ergebnis vom C-Standard nicht definiert.

[Der Jan]

Was mir grad noch einfällt, es gibt auch in Delphi eine Funktion für den trinären Operator: "ifthen", die ist (glaube ich) in der Unit Math.

[Apollonius]

Dort werden allerdings beide Argumente in jedem Fall ausgewertet, was die Nützlichkeit drastisch reduziert. Hier geht es natürlich, weil es sich um Konstanten handelt.

[Der Jan]

Damit hast du natürlich recht. Außerdem ist IfThen AFAIR nur für Zahlen definiert, man kann sich allerdings seilbst ein paar zusätzliche Funktionen definieren, um andere Typen wie String oder Variant abzudecken, so etwa:

Delphi-Quellcode:

unit MyIfThen;
//-----------------------------------------------------------------------------
interface

function IfThen(i_bl: boolean; i_sTrue: string; i_sFalse: string = '0'): string;
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
implementation

function IfThen(i_bl: boolean; i_sTrue: string; i_sFalse: string = '0'): string;
begin
  if(i_bl) then
    Result := i_sTrue
  else
    Result := i_sFalse;
end;
//-----------------------------------------------------------------------------
end.

Aber langsam wirds OT :)

[Dax]

Müsste ein trinärer Operator unter neuen Delphis nicht mit einer generischen Funktion (bool, TFunc<T>, TFunc<T>): T und anonymen Funktionen recht eklig zu machen sein? ;)

[Der Jan]

Also unter C++ mache ich regen Gebrauch davon (Generics/Templates siehe STL bzw. Standard C++ Library, wie es ja jetzt heißt, obwohl ich niemanden kenne der nicht STL sagt), aber unter Delphi hab ich da keine Ahnung von. Aber vermutlich ginge das. Und eklig ist so was garnicht :)