Namespaces
Variants

std:: midpoint

From cppreference.net
C++
Numerics library
Défini dans l'en-tête <numeric>
template < class T >
constexpr T midpoint ( T a, T b ) noexcept ;
(1) (depuis C++20)
template < class T >
constexpr T * midpoint ( T * a, T * b ) ;
(2) (depuis C++20)

Calcule le point médian des entiers, nombres à virgule flottante ou pointeurs a et b .

1) Cette surcharge participe à la résolution de surcharge uniquement si T est un type arithmétique autre que bool .
2) Cette surcharge participe à la résolution de surcharge uniquement si T est un type objet. L'utilisation de cette surcharge est mal formée si T est un type incomplet .

Table des matières

Paramètres

a, b - entiers, nombres à virgule flottante, ou valeurs de pointeur

Valeur de retour

1) La moitié de la somme de a et b . Aucun dépassement de capacité ne se produit. Si a et b sont de type entier et que la somme est impaire, le résultat est arrondi vers a . Si a et b sont de type virgule flottante, au plus une opération inexacte se produit.
2) Si a et b pointent respectivement vers x [ i ] et x [ j ] du même objet tableau x (à des fins d' arithmétique des pointeurs ), retourne un pointeur vers x [ i + ( j - i ) / 2 ] (ou, de manière équivalente x [ std :: midpoint ( i, j ) ] ) où la division arrondit vers zéro. Si a et b ne pointent pas vers des éléments du même objet tableau, le comportement est indéfini.

Exceptions

Ne lance aucune exception.

Notes

La surcharge (2) peut être simplement implémentée comme return a + ( b - a ) / 2 ; sur les plateformes courantes. Cependant, une telle implémentation n'est pas garantie d'être portable, car il peut exister des plateformes où la création d'un tableau avec un nombre d'éléments supérieur à PTRDIFF_MAX est possible, et b - a peut entraîner un comportement indéfini même si b et a pointent vers des éléments dans le même tableau.

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_interpolate 201902L (C++20) std::lerp , std::midpoint

Exemple

Exécuter ce code 
#include <cstdint>
#include <iostream>
#include <limits>
#include <numeric>
int main()
{
    std::uint32_t a = std::numeric_limits<std::uint32_t>::max();
    std::uint32_t b = std::numeric_limits<std::uint32_t>::max() - 2;
    std::cout << "a: " << a << '\n'
              << "b: " << b << '\n'
              << "Incorrect (overflow and wrapping): " << (a + b) / 2 << '\n'
              << "Correct: " << std::midpoint(a, b) << "\n\n";
    auto on_pointers = [](int i, int j)
    {
        char const* text = "0123456789";
        char const* p = text + i;
        char const* q = text + j;
        std::cout << "std::midpoint('" << *p << "', '" << *q << "'): '"
                  << *std::midpoint(p, q) << "'\n";
    };
    on_pointers(2, 4);
    on_pointers(2, 5);
    on_pointers(5, 2);
    on_pointers(2, 6);
}

Sortie : 

a: 4294967295
b: 4294967293
Incorrect (overflow and wrapping): 2147483646
Correct: 4294967294
std::midpoint('2', '4'): '3'
std::midpoint('2', '5'): '3'
std::midpoint('5', '2'): '4'
std::midpoint('2', '6'): '4'

Références

  • Norme C++23 (ISO/IEC 14882:2024) :
  • 27.10.16 Point médian [numeric.ops.midpoint]
  • Norme C++20 (ISO/CEI 14882:2020) :
  • 25.10.15 Milieu [numeric.ops.midpoint]

Voir aussi

(C++20)
fonction d'interpolation linéaire
(fonction)