std::midpoint

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Numerik-Bibliothek

Allgemeine mathematische Funktionen
Mathematische Spezialfunktionen (C++17)
Mathematische Konstanten (C++20)
Grundlegende lineare Algebra-Algorithmen (C++26)
Datenparallele Typen (SIMD) (C++26)
Gleitkomma-Umgebung (C++11)
Komplexe Zahlen
Numerische Arrays (valarray)
Pseudozufallszahlengenerierung
Bit-Manipulation (C++20)
Faktoroperationen
gcd (C++17)	lcm (C++17)
Interpolationen
midpoint (C++20)	lerp (C++20)
Sättigungsarithmetik
add_sat (C++26) sub_sat (C++26) saturate_cast (C++26)	mul_sat (C++26) div_sat (C++26)
Generische numerische Operationen
iota (C++11) ranges::iota (C++23) accumulate inner_product adjacent_difference    partial_sum	reduce (C++17) transform_reduce (C++17) inclusive_scan (C++17) exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)

 

Definiert in der Header-Datei <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, Fließkommazahlen oder Zeiger a und b.

1) Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn T ein arithmetischer Typ außer bool ist.

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.

Parameter

a, b

-

Ganzzahlen, Fließkommazahlen oder Zeigerwerte

Rückgabewert

1) Die Hälfte der Summe von a und b. Es tritt kein Überlauf auf. Wenn a und b einen ganzzahligen Typ haben und die Summe ungerade ist, wird das Ergebnis in Richtung a gerundet. Wenn a und b einen Fließkommatyp 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), wird ein Zeiger auf x[i + (j - i) / 2] zurückgegeben (oder äquivalent x[std::midpoint(i, j)]), wobei die Division gegen Null rundet. Wenn a und b nicht auf Elemente desselben Array-Objekts zeigen, ist das Verhalten undefiniert.

Ausnahmen

Löst keine Ausnahmen aus.

Hinweise

Die Ü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 Plattformen geben kann, auf denen die Erstellung eines Arrays mit mehr als PTRDIFF_MAX Elementen möglich ist, und b - a zu undefiniertem Verhalten führen kann, selbst wenn sowohl b als auch a auf Elemente desselben Arrays zeigen.

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

Beispiel

Führen Sie diesen Code aus

#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 Midpoint [numeric.ops.midpoint]

• C++20 Standard (ISO/IEC 14882:2020)

• 25.10.15 Midpoint [numeric.ops.midpoint]

Siehe auch

lerp (C++20)

Lineare Interpolationsfunktion (Funktion)