Namespaces
Variants

std:: midpoint

From cppreference.net
C++
Numerics library
Definido en el encabezado <numeric>
template < class T >
constexpr T midpoint ( T a, T b ) noexcept ;
(1) (desde C++20)
template < class T >
constexpr T * midpoint ( T * a, T * b ) ;
(2) (desde C++20)

Calcula el punto medio de los enteros, números de punto flotante o punteros a y b .

1) Esta sobrecarga participa en la resolución de sobrecarga solo si T es un tipo aritmético distinto de bool .
2) Esta sobrecarga participa en la resolución de sobrecarga solo si T es un tipo objeto. El uso de esta sobrecarga está mal formado si T es un tipo incompleto .

Contenidos

Parámetros

a, b - valores enteros, de punto flotante o punteros

Valor de retorno

1) La mitad de la suma de a y b . No se produce desbordamiento. Si a y b tienen tipo entero y la suma es impar, el resultado se redondea hacia a . Si a y b tienen tipo de punto flotante, se produce como máximo una operación inexacta.
2) Si a y b apuntan, respectivamente, a x [ i ] y x [ j ] del mismo objeto array x (para el propósito de aritmética de punteros ), retorna un puntero a x [ i + ( j - i ) / 2 ] (o, equivalentemente x [ std :: midpoint ( i, j ) ] ) donde la división redondea hacia cero. Si a y b no apuntan a elementos del mismo objeto array, el comportamiento es indefinido.

Excepciones

No lanza excepciones.

Notas

La sobrecarga (2) puede implementarse simplemente como return a + ( b - a ) / 2 ; en plataformas comunes. Sin embargo, dicha implementación no está garantizada de ser portable, porque puede haber algunas plataformas donde crear un array con un número de elementos mayor que PTRDIFF_MAX es posible, y b - a puede resultar en comportamiento indefinido incluso si tanto b como a apuntan a elementos en el mismo array.

Macro de prueba de características Valor Estándar Característica
__cpp_lib_interpolate 201902L (C++20) std::lerp , std::midpoint

Ejemplo

Ejecutar este código 
#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);
}

Salida: 

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'

Referencias

  • Estándar C++23 (ISO/IEC 14882:2024):
  • 27.10.16 Punto medio [numeric.ops.midpoint]
  • Estándar C++20 (ISO/IEC 14882:2020):
  • 25.10.15 Midpoint [numeric.ops.midpoint]

Véase también

(C++20)
función de interpolación lineal
(función)