| (1) | ||
explicit map( const Compare& comp = Compare(),
const Allocator& alloc = Allocator() );
| (until C++14) | |
map() : map( Compare() ) {}
explicit map( const Compare& comp,
const Allocator& alloc = Allocator() );
| (since C++14) | |
explicit map( const Allocator& alloc ); | (1) | (since C++11) |
| (2) | ||
template< class InputIterator >
map( InputIterator first, InputIterator last,
const Compare& comp = Compare(),
const Allocator& alloc = Allocator() );
| ||
template< class InputIterator >
map( InputIterator first, InputIterator last,
const Allocator& alloc );
| (since C++14) | |
map( const map& other ); | (3) | |
map( const map& other, const Allocator& alloc ); | (3) | (since C++11) |
map( map&& other ); | (4) | (since C++11) |
map( map&& other, const Allocator& alloc ); | (4) | (since C++11) |
| (5) | ||
map( std::initializer_list<value_type> init,
const Compare& comp = Compare(),
const Allocator& alloc = Allocator() );
| (since C++11) | |
map( std::initializer_list<value_type> init,
const Allocator& );
| (since C++14) |
Constructs new container from a variety of data sources and optionally using user supplied allocator alloc or comparison function object comp.
[first, last). if multiple elements in the range have keys that compare equivalent, it is unspecified which element is inserted (pending LWG2844)other. If alloc is not provided, allocator is obtained by calling std::allocator_traits<allocator_type>::select_on_container_copy_construction(other.get_allocator()).other using move semantics. If alloc is not provided, allocator is obtained by move-construction from the allocator belonging to other.init. if multiple elements in the range have keys that compare equivalent, it is unspecified which element is inserted (pending LWG2844)| alloc | - | allocator to use for all memory allocations of this container |
| comp | - | comparison function object to use for all comparisons of keys |
| first, last | - | the range to copy the elements from |
| other | - | another container to be used as source to initialize the elements of the container with |
| init | - | initializer list to initialize the elements of the container with |
| Type requirements | ||
-InputIterator must meet the requirements of InputIterator. |
||
-Compare must meet the requirements of Compare. |
||
-Allocator must meet the requirements of Allocator. |
||
N = std::distance(first, last) in general, linear in N if the range is already sorted by value_comp().other
alloc is given and alloc != other.get_allocator(), then linear.N = init.size()) in general, linear in N if init is already sorted by value_comp().After container move construction (overload (4)), references, pointers, and iterators (other than the end iterator) to other remain valid, but refer to elements that are now in *this. The current standard makes this guarantee via the blanket statement in §23.2.1[container.requirements.general]/12, and a more direct guarantee is under consideration via LWG 2321.
#include <iostream>
#include <string>
#include <iomanip>
#include <map>
template<typename Map>
void print_map(Map& m)
{
std::cout << '{';
for(auto& p: m)
std::cout << p.first << ':' << p.second << ' ';
std::cout << "}\n";
}
struct Point { double x, y; };
struct PointCmp {
bool operator()(const Point& lhs, const Point& rhs) const {
return lhs.x < rhs.x; // NB. intentionally ignores y
}
};
int main()
{
// (1) Default constructor
std::map<std::string, int> map1;
map1["something"] = 69;
map1["anything"] = 199;
map1["that thing"] = 50;
std::cout << "map1 = "; print_map(map1);
// (2) Range constructor
std::map<std::string, int> iter(map1.find("anything"), map1.end());
std::cout << "\niter = "; print_map(iter);
std::cout << "map1 = "; print_map(map1);
// (3) Copy constructor
std::map<std::string, int> copied(map1);
std::cout << "\ncopied = "; print_map(copied);
std::cout << "map1 = "; print_map(map1);
// (4) Move constructor
std::map<std::string, int> moved(std::move(map1));
std::cout << "\nmoved = "; print_map(moved);
std::cout << "map1 = "; print_map(map1);
// (5) Initializer list constructor
const std::map<std::string, int> init {
{"this", 100},
{"can", 100},
{"be", 100},
{"const", 100},
};
std::cout << "\ninit = "; print_map(init);
// Custom Key class option 1:
// Use a comparison struct
std::map<Point, double, PointCmp> mag = {
{ {5, -12}, 13 },
{ {3, 4}, 5 },
{ {-8, -15}, 17 }
};
for(auto p : mag)
std::cout << "The magnitude of (" << p.first.x
<< ", " << p.first.y << ") is "
<< p.second << '\n';
// Custom Key class option 2:
// Use a comparison lambda
// This lambda sorts points according to their magnitudes, where note that
// these magnitudes are taken from the local variable mag
auto cmpLambda = [&mag](const Point &lhs, const Point &rhs) { return mag[lhs] < mag[rhs]; };
//You could also use a lambda that is not dependent on local variables, like this:
//auto cmpLambda = [](const Point &lhs, const Point &rhs) { return lhs.y < rhs.y; };
std::map<Point, double, decltype(cmpLambda)> magy(cmpLambda);
//Various ways of inserting elements:
magy.insert(std::pair<Point, double>({5, -12}, 13));
magy.insert({ {3, 4}, 5});
magy.insert({Point{-8.0, -15.0}, 17});
std::cout << '\n';
for(auto p : magy)
std::cout << "The magnitude of (" << p.first.x
<< ", " << p.first.y << ") is "
<< p.second << '\n';
}Output:
map1 = {anything:199 something:69 that thing:50 }
iter = {anything:199 something:69 that thing:50 }
map1 = {anything:199 something:69 that thing:50 }
copied = {anything:199 something:69 that thing:50 }
map1 = {anything:199 something:69 that thing:50 }
moved = {anything:199 something:69 that thing:50 }
map1 = {}
init = {be:100 can:100 const:100 this:100 }
The magnitude of (-8, -15) is 17
The magnitude of (3, 4) is 5
The magnitude of (5, -12) is 13
The magnitude of (3, 4) is 5
The magnitude of (5, -12) is 13
The magnitude of (-8, -15) is 17| assigns values to the container (public member function) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/container/map/map