Namespaces
Variants

std:: copysign, std:: copysignf, std:: copysignl

From cppreference.net
C++
Numerics library
Common mathematical functions
Nearest integer floating point operations
(C++11)
(C++11)
(C++11) (C++11) (C++11)
Floating point manipulation functions
(C++11) (C++11)
(C++11)
(C++11)
(C++11) (C++11)
copysign
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Definiert in Header <cmath>
(1)
float copysign ( float mag, float sgn ) ;

double copysign ( double mag, double sgn ) ;

long double copysign ( long double mag, long double sgn ) ;
(bis C++23)
constexpr /*floating-point-type*/

copysign ( /*floating-point-type*/ mag,

/*floating-point-type*/ sgn ) ;
(seit C++23)
float copysignf ( float mag, float sgn ) ;
(2) (seit C++11)
(constexpr seit C++23)
long double copysignl ( long double mag, long double sgn ) ;
(3) (seit C++11)
(constexpr seit C++23)
SIMD-Überladung (seit C++26)
Definiert in Header <simd>
template < class V0, class V1 >

constexpr /*math-common-simd-t*/ < V0, V1 >

copysign ( const V0 & v_mag, const V1 & v_sgn ) ;
(S) (seit C++26)
Definiert in Header <cmath>
template < class Integer >
double copysign ( Integer mag, Integer sgn ) ;
(A) (constexpr seit C++23)
1-3) Erzeugt einen Gleitkommawert mit dem Betrag von mag und dem Vorzeichen von sgn . Die Bibliothek stellt Überladungen von std::copysign für alle cv-unqualifizierten Gleitkommatypen als Parametertyp bereit. (seit C++23)
S) Die SIMD-Überladung führt eine elementweise std::copysign auf v_mag und v_sgn aus.
(Siehe math-common-simd-t für deren Definition.)
(seit C++26)
A) Zusätzliche Überladungen werden für alle Ganzzahltypen bereitgestellt, die als double behandelt werden.
(since C++11)

Inhaltsverzeichnis

Parameter

mag, sgn - Gleitkomma- oder Ganzzahlwerte

Rückgabewert

Wenn keine Fehler auftreten, wird der Gleitkommawert mit der Größe von mag und dem Vorzeichen von sgn zurückgegeben.

Wenn mag NaN ist, wird NaN mit dem Vorzeichen von sgn zurückgegeben.

Wenn sgn -0 ist, ist das Ergebnis nur dann negativ, wenn die Implementierung das vorzeichenbehaftete Null konsistent in arithmetischen Operationen unterstützt.

Fehlerbehandlung

Diese Funktion unterliegt keinen der in math_errhandling spezifizierten Fehlern.

Wenn die Implementierung IEEE-Gleitkommaarithmetik (IEC 60559) unterstützt,

Hinweise

std::copysign ist die einzige portable Methode, um das Vorzeichen eines NaN-Werts zu manipulieren (um das Vorzeichen eines NaN zu untersuchen, std::signbit kann ebenfalls verwendet werden).

Die zusätzlichen Überladungen müssen nicht exakt wie (A) bereitgestellt werden. Sie müssen lediglich sicherstellen, dass für ihr erstes Argument num1 und zweites Argument num2 :

  • Falls num1 oder num2 den Typ long double hat, dann hat std :: copysign ( num1, num2 ) die gleiche Wirkung wie std :: copysign ( static_cast < long double > ( num1 ) ,
    static_cast < long double > ( num2 ) )     .
  • Andernfalls, falls num1 und/oder num2 den Typ double oder einen Ganzzahltyp hat, dann hat std :: copysign ( num1, num2 ) die gleiche Wirkung wie std :: copysign ( static_cast < double > ( num1 ) ,
    static_cast < double > ( num2 ) )     .
  • Andernfalls, falls num1 oder num2 den Typ float hat, dann hat std :: copysign ( num1, num2 ) die gleiche Wirkung wie std :: copysign ( static_cast < float > ( num1 ) ,
    static_cast < float > ( num2 ) )     .
(bis C++23)

Falls num1 und num2 arithmetische Typen haben, dann hat std :: copysign ( num1, num2 ) die gleiche Wirkung wie std :: copysign ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
static_cast < /*common-floating-point-type*/ > ( num2 ) ) , wobei /*common-floating-point-type*/ der Gleitkommatyp mit dem höchsten Gleitkomma-Konvertierungsrang und dem höchsten Gleitkomma-Konvertierungsunterrang zwischen den Typen von num1 und num2 ist; Argumente vom Ganzzahltyp werden als mit dem gleichen Gleitkomma-Konvertierungsrang wie double betrachtet.

Falls kein solcher Gleitkommatyp mit dem höchsten Rang und Unterrang existiert, dann führt die Überladungsauflösung nicht zu einem verwendbaren Kandidaten aus den bereitgestellten Überladungen.

(seit C++23)

Beispiel

Diesen Code ausführen 
#include <cmath>
#include <iostream>
int main()
{
    std::cout << std::showpos
              << "copysign(1.0,+2.0) = " << std::copysign(1.0, +2.0) << '\n'
              << "copysign(1.0,-2.0) = " << std::copysign(1.0, -2.0) << '\n'
              << "copysign(inf,-2.0) = " << std::copysign(INFINITY, -2.0) << '\n'
              << "copysign(NaN,-2.0) = " << std::copysign(NAN, -2.0) << '\n';
}

Ausgabe: 

copysign(1.0,+2.0) = +1
copysign(1.0,-2.0) = -1
copysign(inf,-2.0) = -inf
copysign(NaN,-2.0) = -nan

Siehe auch

(C++11) (C++11)
Absolutwert eines Gleitkommawerts ( |x| )
(Funktion)
(C++11)
prüft, ob die gegebene Zahl negativ ist
(Funktion)
C-Dokumentation für copysign