Namespaces
Variants

std:: midpoint

From cppreference.net
C++
Numerics library
Definiert im Header <numeric>
template < class T >
constexpr T midpoint ( T a, T b ) noexcept ;
(1) (seit C++20)
template < class T >
constexpr T * midpoint ( T * a, T * b ) ;
(2) (seit C++20)

Berechnet den Mittelpunkt der Ganzzahlen, Gleitkommazahlen oder Zeiger a und b .

1) Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn T ein arithmetischer Typ ist, außer bool .
2) Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn T ein Objekttyp ist. Die Verwendung dieser Überladung ist fehlerhaft, wenn T ein unvollständiger Typ ist.

Inhaltsverzeichnis

Parameter

a, b - Ganzzahlen, Gleitkommazahlen oder Zeigerwerte

Rückgabewert

1) Die Hälfte der Summe von a und b . Es tritt kein Überlauf auf. Wenn a und b ganzzahligen Typ haben und die Summe ungerade ist, wird das Ergebnis in Richtung a gerundet. Wenn a und b Gleitkommatyp haben, tritt höchstens eine ungenaue Operation auf.
2) Wenn a und b jeweils auf x [ i ] und x [ j ] desselben Array-Objekts x zeigen (für die Zwecke der Zeigerarithmetik ), gibt einen Zeiger auf x [ i + ( j - i ) / 2 ] zurück (oder äquivalent x [ std :: midpoint ( i, j ) ] ), wobei die Division in Richtung Null rundet. Wenn a und b nicht auf Elemente desselben Array-Objekts zeigen, ist das Verhalten undefiniert.

Exceptions

Wirft keine Ausnahmen.

Hinweise

Überladung (2) kann auf gängigen Plattformen einfach als return a + ( b - a ) / 2 ; implementiert werden. Eine solche Implementierung ist jedoch nicht garantiert portabel, da es möglicherweise Plattformen gibt, auf denen die Erstellung eines Arrays mit mehr Elementen als PTRDIFF_MAX möglich ist, und b - a undefiniertes Verhalten verursachen könnte, selbst wenn sowohl b als auch a auf Elemente im selben Array zeigen.

Feature-Test Makro Wert Standard Funktion
__cpp_lib_interpolate 201902L (C++20) std::lerp , std::midpoint

Beispiel

Diesen Code ausführen 
#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);
}

Ausgabe: 

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'

Referenzen

  • C++23-Standard (ISO/IEC 14882:2024):
  • 27.10.16 Mittelpunkt [numeric.ops.midpoint]
  • C++20-Standard (ISO/IEC 14882:2020):
  • 25.10.15 Mittelpunkt [numeric.ops.midpoint]

Siehe auch

(C++20)
Lineare Interpolationsfunktion
(Funktion)