Namespaces
Variants

std:: abs (float) , std:: fabs, std:: fabsf, std:: fabsl

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)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Défini dans l'en-tête <cmath>
Défini dans l'en-tête <cstdlib>
(1)
float abs ( float num ) ;

double abs ( double num ) ;

long double abs ( long double num ) ;
(jusqu'à C++23)
constexpr /* floating-point-type */
abs ( /* floating-point-type */ num ) ;
(depuis C++23)
Défini dans l'en-tête <cmath>
(2)
float fabs ( float num ) ;

double fabs ( double num ) ;

long double fabs ( long double num ) ;
(jusqu'à C++23)
constexpr /* floating-point-type */
fabs ( /* floating-point-type */ num ) ;
(depuis C++23)
float fabsf ( float num ) ;
(3) (depuis C++11)
(constexpr depuis C++23)
long double fabsl ( long double num ) ;
(4) (depuis C++11)
(constexpr depuis C++23)
Défini dans l'en-tête <cmath>
template < class Integer >
double fabs ( Integer num ) ;
(A) (depuis C++11)
(constexpr depuis C++23)
1-4) Calcule la valeur absolue de la valeur en virgule flottante num . La bibliothèque fournit des surcharges de std::abs et std::fabs pour tous les types en virgule flottante non qualifiés cv comme type du paramètre num . (depuis C++23)
A) Des surcharges supplémentaires sont fournies pour tous les types entiers, qui sont traités comme double .
(depuis C++11)

Pour les arguments entiers, les surcharges entières de std::abs sont probablement de meilleurs choix. Si std::abs est appelé avec un argument entier non signé qui ne peut pas être converti en int par promotion entière , le programme est incorrect.

Table des matières

Paramètres

num - valeur à virgule flottante ou entière

Valeur de retour

En cas de succès, retourne la valeur absolue de arg ( |arg| ). La valeur retournée est exacte et ne dépend d'aucun mode d'arrondi.

Gestion des erreurs

Cette fonction n'est soumise à aucune des conditions d'erreur spécifiées dans math_errhandling .

Si l'implémentation prend en charge l'arithmétique à virgule flottante IEEE (IEC 60559),

  • Si l'argument est ±0, +0 est retourné.
  • Si l'argument est ±∞, +∞ est retourné.
  • Si l'argument est NaN, NaN est retourné.

Notes

Les surcharges supplémentaires ne sont pas requises d'être fournies exactement comme (A) . Elles doivent seulement être suffisantes pour garantir que pour leur argument num de type entier, std :: fabs ( num ) ait le même effet que std :: fabs ( static_cast < double > ( num ) ) .

Exemple

Exécuter ce code 
#include <cmath>
#include <iostream>
int main()
{
    std::cout << "abs(+3.0) = " << std::abs(+3.0) << '\n'
              << "abs(-3.0) = " << std::abs(-3.0) << '\n';
    // special values
    std::cout << "abs(-0.0) = " << std::abs(-0.0) << '\n'
              << "abs(-Inf) = " << std::abs(-INFINITY) << '\n'
              << "abs(-NaN) = " << std::abs(-NAN) << '\n';
}

Sortie possible : 

abs(+3.0) = 3
abs(-3.0) = 3
abs(-0.0) = 0
abs(-Inf) = inf
abs(-NaN) = nan

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 2192 C++98 les surcharges de std::abs étaient
déclarées de manière incohérente dans deux en-têtes 		déclaré ces surcharges
dans les deux en-têtes
LWG 2735 C++11 les surcharges de std::abs pour les types entiers
renvoyant double étaient erronément requises 		supprimé l'exigence

Voir aussi

(C++11)
calcule la valeur absolue d'une valeur entière ( |x| )
(fonction)
(C++11) (C++11) (C++11)
copie le signe d'une valeur à virgule flottante
(fonction)
(C++11)
vérifie si le nombre donné est négatif
(fonction)
renvoie la magnitude d'un nombre complexe
(modèle de fonction)
applique la fonction abs à chaque élément du valarray
(modèle de fonction)
Documentation C pour fabs