std::valarray<T>:: operator[]
| 
           
            
             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) | |
检索数组中的单个元素或部分元素。
返回元素序列的 const 重载会创建一个新的 std::valarray 对象。 非 const 重载则返回持有数组元素引用的类。
| 目录 | 
参数
| pos | - | 要返回元素的位置 | 
| slicearr | - | 要返回元素的 slice | 
| gslicearr | - | 要返回元素的 gslice | 
| boolarr | - | 要返回元素的掩码 | 
| indarr | - | 要返回元素的索引 | 
返回值
异常
可能抛出实现定义的异常。
注释
对于合法的 std::valarray 值 a 、 b 以及合法的 std::size_t 值 i 、 j ,以下所有表达式始终求值为 true :
- 这意味着元素间不存在别名关系,该特性可用于实现某些类型的优化。
       引用会在
       
        
         resize()
        
       
       或数组被销毁时失效。
      
对于重载 (3,5,7,9) ,该函数的实现可以具有与 std::valarray 不同的返回类型。在这种情况下,替换类型具有以下特性:
- 
        - 提供了 const 成员函数的所有 std::valarray 。
- 可以从替换类型构造 std::valarray 、 std::slice_array 、 std::gslice_array 、 std::mask_array 和 std::indirect_array 。
- 对于每个接受 const std:: valarray < T > & 的函数(除 begin() 和 end() 外 (C++11 起) ),应添加接受替换类型的相同函数;
- 对于每个接受两个 const std:: valarray < T > & 参数的函数,应添加接受 const std:: valarray < T > & 与替换类型所有组合的相同函数。
- 返回类型不会在最深嵌套的参数类型基础上增加超过两层的模板嵌套。
 
切片/掩码/间接索引访问不可链式操作: v [ v == n ] [ std:: slice ( 0 , 5 , 2 ) ] = x ; 是错误的,因为 std::mask_array (即 v [ v == n ] 的类型)不具有 operator [ ] 。
示例
#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 << "初始 valarray: "; for (int n : data) std::cout << std::setw(3) << n; std::cout << '\n'; data[data > 5] = -1; // valarray<bool> 重载的 operator[] // data > 5 的类型是 std::valarray<bool> // data[data > 5] 的类型是 std::mask_array<int> std::cout << "执行 v[v > 5] = -1 后:"; for (std::size_t n = 0; n < data.size(); ++n) std::cout << std::setw(3) << data[n]; // 常规 operator[] std::cout << '\n'; }
输出:
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
缺陷报告
以下行为变更缺陷报告被追溯应用于先前发布的C++标准。
| 缺陷报告 | 适用范围 | 发布时行为 | 正确行为 | 
|---|---|---|---|
| LWG 389 | C++98 | 重载版本
         
          (1)
         
         的返回类型为 
          T
          | 修正为 const T & | 
| LWG 430 | C++98 | 对于重载版本 (3-10) ,若指定无效子集时的行为不明确 | 此情况下的行为 是未定义的 |