Namespaces
Variants

std:: ceil, std:: ceilf, std:: ceill

From cppreference.net
C++
Numerics library
Common mathematical functions
Nearest integer floating point operations
ceil
(C++11) (C++11) (C++11)
(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>
(1)
float ceil ( float num ) ;

double ceil ( double num ) ;

long double ceil ( long double num ) ;
(jusqu'à C++23)
constexpr /*floating-point-type*/
ceil ( /*floating-point-type*/ num ) ;
(depuis C++23)
float ceilf ( float num ) ;
(2) (depuis C++11)
(constexpr depuis C++23)
long double ceill ( long double num ) ;
(3) (depuis C++11)
(constexpr depuis C++23)
Surcharge SIMD (depuis C++26)
Défini dans l'en-tête <simd>
template < /*math-floating-point*/ V >

constexpr /*deduced-simd-t*/ < V >

ceil ( const V & v_num ) ;
(S) (depuis C++26)
Défini dans l'en-tête <cmath>
template < class Integer >
double ceil ( Integer num ) ;
(A) (constexpr depuis C++23)
1-3) Calcule la plus petite valeur entière non inférieure à num . La bibliothèque fournit des surcharges de std::ceil pour tous les types à virgule flottante non qualifiés cv comme type du paramètre. (depuis C++23)
S) La surcharge SIMD effectue un std::ceil élément par élément sur v_num .
(Voir math-floating-point et deduced-simd-t pour leurs définitions.)
(depuis C++26)
A) Des surcharges supplémentaires sont fournies pour tous les types entiers, qui sont traités comme double .
(depuis C++11)

Table des matières

Paramètres

num - valeur à virgule flottante ou entière

Valeur de retour

Si aucune erreur ne se produit, la plus petite valeur entière non inférieure à num , c'est-à-dire ⌈num⌉ , est renvoyée.

Valeur de retour
math-ceil.svg
num

Gestion des erreurs

Les erreurs sont signalées comme spécifié dans math_errhandling .

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

  • Le mode d'arrondi actuel n'a aucun effet.
  • Si num est ±∞, il est retourné inchangé.
  • Si num est ±0, il est retourné inchangé.
  • Si num est NaN, NaN est retourné.

Notes

FE_INEXACT peut être (mais n'est pas obligatoirement) déclenchée lors de l'arrondi d'une valeur finie non entière.

Les plus grandes valeurs représentables en virgule flottante sont des entiers exacts dans tous les formats standard de virgule flottante, donc cette fonction ne déborde jamais par elle-même ; cependant le résultat peut déborder tout type entier (y compris std::intmax_t ), lorsqu'il est stocké dans une variable entière. C'est pour cette raison que le type de retour est en virgule flottante et non intégral.

Cette fonction (pour un argument de type double ) se comporte comme si (à l'exception de la liberté de ne pas lever FE_INEXACT ) elle était implémentée par le code suivant : 

#include <cfenv>
#include <cmath>
#pragma STDC FENV_ACCESS ON
double ceil(double x)
{
    int save_round = std::fegetround();
    std::fesetround(FE_UPWARD);
    double result = std::rint(x); // ou std::nearbyint
    std::fesetround(save_round);
    return result;
}

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 :: ceil ( num ) ait le même effet que std :: ceil ( static_cast < double > ( num ) ) .

Exemple

Exécuter ce code 
#include <cmath>
#include <iostream>
int main()
{
    std::cout << std::fixed
              << "ceil(+2.4) = " << std::ceil(+2.4) << '\n'
              << "ceil(-2.4) = " << std::ceil(-2.4) << '\n'
              << "ceil(-0.0) = " << std::ceil(-0.0) << '\n'
              << "ceil(-Inf) = " << std::ceil(-INFINITY) << '\n';
}

Sortie : 

ceil(+2.4) = 3.000000
ceil(-2.4) = -2.000000
ceil(-0.0) = -0.000000
ceil(-Inf) = -inf

Voir aussi

(C++11) (C++11)
entier le plus proche n'étant pas supérieur à la valeur donnée
(fonction)
(C++11) (C++11) (C++11)
entier le plus proche n'étant pas supérieur en magnitude à la valeur donnée
(fonction)
(C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11)
entier le plus proche, en arrondissant à l'opposé de zéro dans les cas médians
(fonction)
(C++11) (C++11) (C++11)
entier le plus proche utilisant le mode d'arrondi actuel
(fonction)
(C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11)
entier le plus proche utilisant le mode d'arrondi actuel avec
exception si le résultat diffère
(fonction)
Documentation C pour ceil

Liens externes

Plafond rapide d'une division entière — StackOverflow