Home | History | Annotate | Download | only in array
      1 //===----------------------------------------------------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is dual licensed under the MIT and the University of Illinois Open
      6 // Source Licenses. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 // <array>
     11 
     12 // reference operator[] (size_type)
     13 // const_reference operator[] (size_type); // constexpr in C++14
     14 // reference at (size_type)
     15 // const_reference at (size_type); // constexpr in C++14
     16 
     17 #include <array>
     18 #include <cassert>
     19 
     20 #include "test_macros.h"
     21 
     22 // std::array is explicitly allowed to be initialized with A a = { init-list };.
     23 // Disable the missing braces warning for this reason.
     24 #include "disable_missing_braces_warning.h"
     25 
     26 #if TEST_STD_VER > 14
     27 constexpr bool check_idx( size_t idx, double val )
     28 {
     29     std::array<double, 3> arr = {1, 2, 3.5};
     30 	return arr.at(idx) == val;
     31 }
     32 #endif
     33 
     34 int main()
     35 {
     36     {
     37         typedef double T;
     38         typedef std::array<T, 3> C;
     39         C c = {1, 2, 3.5};
     40         C::reference r1 = c.at(0);
     41         assert(r1 == 1);
     42         r1 = 5.5;
     43         assert(c.front() == 5.5);
     44 
     45         C::reference r2 = c.at(2);
     46         assert(r2 == 3.5);
     47         r2 = 7.5;
     48         assert(c.back() == 7.5);
     49 
     50 #ifndef TEST_HAS_NO_EXCEPTIONS
     51         try
     52         {
     53             (void) c.at(3);
     54             assert(false);
     55         }
     56         catch (const std::out_of_range &) {}
     57 #endif
     58     }
     59     {
     60         typedef double T;
     61         typedef std::array<T, 3> C;
     62         const C c = {1, 2, 3.5};
     63         C::const_reference r1 = c.at(0);
     64         assert(r1 == 1);
     65 
     66         C::const_reference r2 = c.at(2);
     67         assert(r2 == 3.5);
     68 
     69 #ifndef TEST_HAS_NO_EXCEPTIONS
     70         try
     71         {
     72             (void) c.at(3);
     73             assert(false);
     74         }
     75         catch (const std::out_of_range &) {}
     76 #endif
     77     }
     78 
     79 #if TEST_STD_VER > 11
     80     {
     81         typedef double T;
     82         typedef std::array<T, 3> C;
     83         constexpr C c = {1, 2, 3.5};
     84 
     85         constexpr T t1 = c.at(0);
     86         static_assert (t1 == 1, "");
     87 
     88         constexpr T t2 = c.at(2);
     89         static_assert (t2 == 3.5, "");
     90     }
     91 #endif
     92 
     93 #if TEST_STD_VER > 14
     94     {
     95         static_assert (check_idx(0, 1), "");
     96         static_assert (check_idx(1, 2), "");
     97         static_assert (check_idx(2, 3.5), "");
     98     }
     99 #endif
    100 }
    101