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// <unordered_map> 11 12// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, 13// class Alloc = allocator<pair<const Key, T>>> 14// class unordered_map 15 16// mapped_type& at(const key_type& k); 17// const mapped_type& at(const key_type& k) const; 18 19#include <unordered_map> 20#include <string> 21#include <cassert> 22 23#include "../../../MoveOnly.h" 24#include "min_allocator.h" 25 26int main() 27{ 28 { 29 typedef std::unordered_map<int, std::string> C; 30 typedef std::pair<int, std::string> P; 31 P a[] = 32 { 33 P(1, "one"), 34 P(2, "two"), 35 P(3, "three"), 36 P(4, "four"), 37 P(1, "four"), 38 P(2, "four"), 39 }; 40 C c(a, a + sizeof(a)/sizeof(a[0])); 41 assert(c.size() == 4); 42 c.at(1) = "ONE"; 43 assert(c.at(1) == "ONE"); 44 try 45 { 46 c.at(11) = "eleven"; 47 assert(false); 48 } 49 catch (std::out_of_range&) 50 { 51 } 52 assert(c.size() == 4); 53 } 54 { 55 typedef std::unordered_map<int, std::string> C; 56 typedef std::pair<int, std::string> P; 57 P a[] = 58 { 59 P(1, "one"), 60 P(2, "two"), 61 P(3, "three"), 62 P(4, "four"), 63 P(1, "four"), 64 P(2, "four"), 65 }; 66 const C c(a, a + sizeof(a)/sizeof(a[0])); 67 assert(c.size() == 4); 68 assert(c.at(1) == "one"); 69 try 70 { 71 c.at(11); 72 assert(false); 73 } 74 catch (std::out_of_range&) 75 { 76 } 77 assert(c.size() == 4); 78 } 79#if __cplusplus >= 201103L 80 { 81 typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, 82 min_allocator<std::pair<const int, std::string>>> C; 83 typedef std::pair<int, std::string> P; 84 P a[] = 85 { 86 P(1, "one"), 87 P(2, "two"), 88 P(3, "three"), 89 P(4, "four"), 90 P(1, "four"), 91 P(2, "four"), 92 }; 93 C c(a, a + sizeof(a)/sizeof(a[0])); 94 assert(c.size() == 4); 95 c.at(1) = "ONE"; 96 assert(c.at(1) == "ONE"); 97 try 98 { 99 c.at(11) = "eleven"; 100 assert(false); 101 } 102 catch (std::out_of_range&) 103 { 104 } 105 assert(c.size() == 4); 106 } 107 { 108 typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, 109 min_allocator<std::pair<const int, std::string>>> C; 110 typedef std::pair<int, std::string> P; 111 P a[] = 112 { 113 P(1, "one"), 114 P(2, "two"), 115 P(3, "three"), 116 P(4, "four"), 117 P(1, "four"), 118 P(2, "four"), 119 }; 120 const C c(a, a + sizeof(a)/sizeof(a[0])); 121 assert(c.size() == 4); 122 assert(c.at(1) == "one"); 123 try 124 { 125 c.at(11); 126 assert(false); 127 } 128 catch (std::out_of_range&) 129 { 130 } 131 assert(c.size() == 4); 132 } 133#endif 134} 135