Warum abs() oder fabs() anstelle der bedingten Negation verwenden?

Warum sollte man in C/C++ verwenden abs() oder fabs() um den absoluten Wert einer Variablen zu finden, ohne den folgenden Code zu verwenden?

int absoluteValue = value < 0 ? -value : value;

Hat es etwas mit weniger Anweisungen auf niedrigerem Niveau zu tun?

Der von Ihnen vorgeschlagene “bedingte Bauchmuskel” ist nicht äquivalent std::abs (oder fabs) für Fließkommazahlen, siehe zB

#include <iostream>
#include <cmath>

int main () {
    double d = -0.0;
    double a = d < 0 ? -d : d;
    std::cout << d << ' ' << a << ' ' << std::abs(d);
}

Ausgang:

-0 -0 0

Gegeben -0.0 und 0.0 dieselbe reelle Zahl ‘0’ darstellen, kann dieser Unterschied von Bedeutung sein oder auch nicht, je nachdem, wie das Ergebnis verwendet wird. Die abs-Funktion, wie sie von IEEE754 spezifiziert ist, verlangt jedoch, dass das Vorzeichen des Ergebnisses 0 ist, was das Ergebnis verbieten würde -0.0. Ich persönlich denke, dass alles, was zur Berechnung eines “absoluten Werts” verwendet wird, diesem Verhalten entsprechen sollte.

Für Integer sind beide Varianten sowohl in Laufzeit als auch Verhalten gleichwertig. (Live-Beispiel)

Aber std::abs (oder die passenden C-Äquivalente) sind bekanntermaßen korrekt und leichter zu lesen, Sie sollten diese einfach immer bevorzugen.

Das erste, was mir in den Sinn kommt, ist die Lesbarkeit.

Vergleichen Sie diese beiden Codezeilen:

int x = something, y = something, z = something;
// Compare
int absall = (x > 0 ? x : -x) + (y > 0 ? y : -y) + (z > 0 ? z : -z);
int absall = abs(x) + abs(y) + abs(z);

Der Compiler wird höchstwahrscheinlich für beide auf der untersten Ebene dasselbe tun – zumindest ein moderner kompetenter Compiler.

Zumindest für Gleitkommazahlen werden Sie jedoch am Ende ein paar Dutzend Zeilen schreiben, wenn Sie alle Sonderfälle von unendlich, keine Zahl (NaN), negative Null usw. behandeln möchten.

Außerdem ist es einfacher, das zu lesen abs nimmt den absoluten Wert, als zu lesen, dass, wenn er kleiner als Null ist, er negiert wird.

Wenn der Compiler “dumm” ist, kann er am Ende schlechteren Code für a = (a < 0)?-a:aweil es eine erzwingt if (auch wenn es versteckt ist), und das könnte durchaus schlimmer sein als der eingebaute Gleitkomma-ABS-Befehl auf diesem Prozessor (abgesehen von der Komplexität spezieller Werte).

Sowohl Clang (6.0-Vorabversion) als auch gcc (4.9.2) generieren SCHLECHTEREN Code für den zweiten Fall.

Ich habe dieses kleine Beispiel geschrieben:

#include <cmath>
#include <cstdlib>

extern int intval;
extern float floatval;

void func1()
{
    int a = std::abs(intval);
    float f = std::abs(floatval);
    intval = a;
    floatval = f;
}


void func2()
{
    int a = intval < 0?-intval:intval;
    float f = floatval < 0?-floatval:floatval;
    intval = a;
    floatval = f;
}

clang macht diesen Code für func1:

_Z5func1v:                              # @_Z5func1v
    movl    intval(%rip), %eax
    movl    %eax, %ecx
    negl    %ecx
    cmovll  %eax, %ecx
    movss   floatval(%rip), %xmm0   # xmm0 = mem[0],zero,zero,zero
    andps   .LCPI0_0(%rip), %xmm0
    movl    %ecx, intval(%rip)
    movss   %xmm0, floatval(%rip)
    retq

_Z5func2v:                              # @_Z5func2v
    movl    intval(%rip), %eax
    movl    %eax, %ecx
    negl    %ecx
    cmovll  %eax, %ecx
    movss   floatval(%rip), %xmm0   
    movaps  .LCPI1_0(%rip), %xmm1 
    xorps   %xmm0, %xmm1
    xorps   %xmm2, %xmm2
    movaps  %xmm0, %xmm3
    cmpltss %xmm2, %xmm3
    movaps  %xmm3, %xmm2
    andnps  %xmm0, %xmm2
    andps   %xmm1, %xmm3
    orps    %xmm2, %xmm3
    movl    %ecx, intval(%rip)
    movss   %xmm3, floatval(%rip)
    retq

g++ func1:

_Z5func1v:
    movss   .LC0(%rip), %xmm1
    movl    intval(%rip), %eax
    movss   floatval(%rip), %xmm0
    andps   %xmm1, %xmm0
    sarl    $31, %eax
    xorl    %eax, intval(%rip)
    subl    %eax, intval(%rip)
    movss   %xmm0, floatval(%rip)
    ret

g++ func2:

_Z5func2v:
    movl    intval(%rip), %eax
    movl    intval(%rip), %edx
    pxor    %xmm1, %xmm1
    movss   floatval(%rip), %xmm0
    sarl    $31, %eax
    xorl    %eax, %edx
    subl    %eax, %edx
    ucomiss %xmm0, %xmm1
    jbe .L3
    movss   .LC3(%rip), %xmm1
    xorps   %xmm1, %xmm0
.L3:
    movl    %edx, intval(%rip)
    movss   %xmm0, floatval(%rip)
    ret

Beachten Sie, dass beide Fälle in der zweiten Form deutlich komplexer sind und im gcc-Fall eine Verzweigung verwendet wird. Clang verwendet mehr Anweisungen, aber keine Verzweigung. Ich bin mir nicht sicher, was auf welchen Prozessormodellen schneller ist, aber mehr Anweisungen sind selten besser.

Warum abs() oder fabs() anstelle der bedingten Negation verwenden?

Verschiedene Gründe wurden bereits genannt, dennoch betrachten Sie die Vorteile des bedingten Codes als abs(INT_MIN) sollte vermieden werden.

Es gibt einen guten Grund, den Bedingungscode anstelle von zu verwenden abs() wenn der Negativ Absolutwert einer ganzen Zahl gesucht

// Negative absolute value

int nabs(int value) {
  return -abs(value);  // abs(INT_MIN) is undefined behavior.
}

int nabs(int value) {
  return value < 0 ? value : -value; // well defined for all `int`
}

Wenn eine positive absolute Funktion benötigt wird und value == INT_MIN ist eine reale Möglichkeit, abs(), trotz all seiner Klarheit und Geschwindigkeit, scheitert an einem Eckfall. Diverse Alternativen

unsigned absoluteValue = value < 0 ? (0u - value) : (0u + value);

Bei einer bestimmten Architektur kann es eine effizientere Low-Level-Implementierung als eine bedingte Verzweigung geben. Zum Beispiel könnte die CPU eine haben abs Anweisung oder eine Möglichkeit, das Vorzeichenbit ohne den Overhead einer Verzweigung zu extrahieren. Angenommen, eine arithmetische Rechtsverschiebung kann ein Register füllen r mit -1, wenn die Zahl negativ ist, oder 0, wenn sie positiv ist, abs x könnte werden (x+r)^r (und wenn man die Antwort von Mats Petersson sieht, tut g++ dies tatsächlich auf x86).

Andere Antworten haben die Situation für IEEE-Gleitkomma behandelt.

Der Versuch, den Compiler anzuweisen, eine bedingte Verzweigung durchzuführen, anstatt der Bibliothek zu vertrauen, ist wahrscheinlich eine verfrühte Optimierung.

Bedenken Sie, dass Sie einen komplizierten Ausdruck eingeben könnten abs(). Wenn Sie es mit codieren expr > 0 ? expr : -exprmüssen Sie den gesamten Ausdruck dreimal wiederholen, und er wird zweimal ausgewertet.
Außerdem könnten sich die beiden Ergebnisse (vor und nach dem Doppelpunkt) als unterschiedliche Typen herausstellen (wie z signed int / unsigned int), wodurch die Verwendung in einer return-Anweisung deaktiviert wird. Natürlich könnten Sie eine temporäre Variable hinzufügen, aber das löst nur Teile davon und ist auch in keiner Weise besser.

…und würden Sie es in ein Makro machen, können Sie mehrere Auswertungen haben, die Sie möglicherweise nicht möchten (Nebenwirkungen). In Betracht ziehen:

#define ABS(a) ((a)<0?-(a):(a))

und verwenden:

f= 5.0;
f=ABS(f=fmul(f,b));

was sich erweitern würde

f=((f=fmul(f,b)<0?-(f=fmul(f,b)):(f=fmul(f,b)));

Funktionsaufrufe haben diese unbeabsichtigten Nebeneffekte nicht.