std::valarray<T>::operator[]

 

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)

 

std::valarray

Memberfunktionen
valarray::valarray valarray::~valarray valarray::operator= valarray::operator[] valarray::swap valarray::size valarray::resize valarray::sum valarray::min valarray::max valarray::shift valarray::cshift valarray::apply	valarray::operator+valarray::operator-valarray::operator~valarray::operator! valarray::operator+=valarray::operator-=valarray::operator*=valarray::operator/=valarray::operator%=valarray::operator&=valarray::operator|=valarray::operator^=valarray::operator<<=valarray::operator>>=
Nicht-Member-Funktionen
swap(C++11) begin(C++11)   end(C++11) abs exp log log10 pow sqrt sin cos tan asin acos atan atan2 sinh cosh tanh	operator*operator/operator%operator+operator-operator^operator&operator|operator<<operator>>operator&&operator|| operator==operator!=operator<operator>operator<=operator>=
Hilfsklassen
slice_array gslice_array indirect_array	slice gslice mask_array
Deduktionsanleitungen (seit C++17)

 

const T&               operator[]( std::size_t pos ) const;	(1)
T&                     operator[]( std::size_t pos );	(2)
std::valarray<T>       operator[]( std::slice slicearr ) const;	(3)
std::slice_array<T>    operator[]( std::slice slicearr );	(4)
std::valarray<T>       operator[]( const std::gslice& gslicearr ) const;	(5)
std::gslice_array<T>   operator[]( const std::gslice& gslicearr );	(6)
std::valarray<T>       operator[]( const std::valarray<bool>& boolarr ) const;	(7)
std::mask_array<T>     operator[]( const std::valarray<bool>& boolarr );	(8)
std::valarray<T>       operator[]( const std::valarray<std::size_t>& indarr ) const;	(9)
std::indirect_array<T> operator[]( const std::valarray<std::size_t>& indarr );	(10)

Ruft einzelne Elemente oder Teile des Arrays ab.

Die const-Überladungen, die Elementsequenzen zurückgeben, erstellen ein neues std::valarray-Objekt. Die nicht-const-Überladungen geben Klassen zurück, die Referenzen auf die Array-Elemente enthalten.

Die ausgewählten Elemente müssen existieren.

• für Überladungen (1,2), wenn pos kleiner als size() ist, ist das Verhalten undefiniert; und
• für Überladungen (3-10), wenn das Argument keine gültige Teilmenge von *this angibt, ist das Verhalten undefiniert.

Parameter

pos	-	Position des zurückzugebenden Elements
slicearr	-	slice der zurückzugebenden Elemente
gslicearr	-	gslice der zurückzugebenden Elemente
boolarr	-	Maske der zurückzugebenden Elemente
indarr	-	Indizes der zurückzugebenden Elemente

Rückgabewert

1,2) Eine Referenz auf das entsprechende Element.

3,5,7,9) Ein std::valarray-Objekt, das Kopien der ausgewählten Elemente enthält.

4,6,8,10) Die entsprechende Datenstruktur, die Referenzen auf die ausgewählten Elemente enthält.

Exceptions

Kann implementierungsdefinierte Ausnahmen auslösen.

Hinweise

Für korrekte std::valarray-Werte a, b und korrekte std::size_t-Werte i, j, sind alle folgenden Ausdrücke immer true

1) (a[i] = q, a[i]) == q für nicht-const a

2) &a[i + j] == &a[i] + j

• Dies bedeutet, dass die Elemente von std::valarray im Speicher nebeneinander liegen.

3) &a[i] != &b[j] für alle Objekte a und b, die keine Aliase voneinander sind.

• Dies bedeutet, dass es keine Aliase in den Elementen gibt und diese Eigenschaft zur Durchführung einiger Optimierungen genutzt werden kann.

Referenzen werden ungültig bei resize() oder wenn das Array zerstört wird.

Für Überladungen (3,5,7,9) kann die Funktion mit einem anderen Rückgabetyp als std::valarray implementiert werden. In diesem Fall hat der Ersatztyp folgende Eigenschaften:

• Alle const-Mitgliedsfunktionen von std::valarray sind vorhanden.
• std::valarray, std::slice_array, std::gslice_array, std::mask_array und std::indirect_array können aus dem Ersatztyp konstruiert werden.
• Für jede Funktion, die ein const std::valarray<T>& als Argument nimmt (außer begin() und end())(seit C++11), werden identische Funktionen hinzugefügt, die die Ersatztypen nehmen;
• Für jede Funktion, die zwei Argumente vom Typ const std::valarray<T>& annimmt, werden identische Funktionen hinzugefügt, die jede Kombination aus const std::valarray<T>& und Ersatztypen annehmen.
• Der Rückgabetyp fügt nicht mehr als zwei Ebenen von Template-Verschachtelung über den am tiefsten verschachtelten Argumenttyp hinaus hinzu.

Slice-/Masken-/Indirekte Indexzugriffe sind nicht verkettet: v[v == n][std::slice(0, 5, 2)] = x; ist ein Fehler, da std::mask_array (der Typ von v[v == n]) keine operator[] hat.

Beispiel

Führen Sie diesen Code aus

#include <cstddef>
#include <iomanip>
#include <iostream>
#include <valarray>
 
int main() 
{
    std::valarray<int> data = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 
    std::cout << "Initial valarray:   ";
    for (int n : data)
        std::cout << std::setw(3) << n;
    std::cout << '\n';
 
    data[data > 5] = -1; // valarray<bool> overload of operator[]
    // the type of data > 5 is std::valarray<bool>
    // the type of data[data > 5] is std::mask_array<int>
 
    std::cout << "After v[v > 5] = -1:";
    for (std::size_t n = 0; n < data.size(); ++n) 
        std::cout << std::setw(3) << data[n]; // regular operator[]
    std::cout << '\n';
}

Ausgabe

Initial valarray:     0  1  2  3  4  5  6  7  8  9
After v[v > 5] = -1:  0  1  2  3  4  5 -1 -1 -1 -1

Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 389	C++98	Der Rückgabetyp von Überladung (1) war T	korrigiert zu const T&
LWG 430	C++98	Das Verhalten war unklar für Überladungen (3-10), wenn eine ungültige Teilmenge angegeben wird	Das Verhalten ist in diesem Fall nicht definiert.