I have a `vector` of `pair` like such:

    vector&lt;pair&lt;string,double&gt;&gt; revenue;

I want to add a string and a double from a map like this:

    revenue[i].first = &quot;string&quot;;
    revenue[i].second = map[i].second;

But since revenue isn&#39;t initialized, it comes up with an out of bounds error. So I tried using `vector::push_back` like this:

    revenue.push_back(&quot;string&quot;,map[i].second);

But that says cannot take two arguments. So how can I add to this `vector` of `pair`?

Adding to a vector of pair

I just discovered that at one point, the C++11 draft had `std::begin`/`std::end` overloads for `std::pair` that allowed treating a pair of iterators as a range suitable for use in a range-based for loop (N3126, section 20.3.5.5), but this has since been removed.

Does anyone know why it was removed?

I find the removal very unfortunate, because it seems there is no other way to treat a pair of iterators as a range. Indeed:

- The lookup rules for begin/end in a range-based for loop say that begin/end are looked for in 1) as member functions of the range object 2) as free functions in &quot;associated namespaces&quot;
- `std::pair` does not have begin/end member functions
- The only associated namespace for `std::pair&lt;T, U&gt;` in general is namespace std
- We are not allowed to overload `std::begin`/`std::end` for `std::pair` ourselves
- We cannot specialize `std::begin`/`std::end` for `std::pair` (because the specialization would have to be partial and that&#39;s not allowed for functions)

Is there some other way that I am missing?

Why was pair range access removed from C++11?

What is the difference between `std::list&lt;std::pair&gt;` and `std::map`? Is there a `find` method for the list, too?

What is the difference between std::list&lt;std::pair&gt; and std::map in C++ STL?

What is the purpose of `std::make_pair`?

Why not just do `std::pair&lt;int, char&gt;(0, &#39;a&#39;)`?

Is there any difference between the two methods?

What is the purpose of std::make_pair vs the constructor of std::pair?

Is there a good reason why there is no `Pair&lt;L,R&gt;` in Java? What would be the equivalent of this C++ construct? I would rather avoid reimplementing my own.

It seems that **1.6** is providing something similar (`AbstractMap.SimpleEntry&lt;K,V&gt;`), but this looks quite convoluted.

What is the equivalent of the C++ Pair&lt;L,R&gt; in Java?

I have identified four different ways of inserting elements into a `std::map`:

    std::map&lt;int, int&gt; function;

    function[0] = 42;
    function.insert(std::map&lt;int, int&gt;::value_type(0, 42));
    function.insert(std::pair&lt;int, int&gt;(0, 42));
    function.insert(std::make_pair(0, 42));

Which of those is the preferred/idiomatic way? (And is there another way I have not thought of?)

What is the preferred/idiomatic way to insert into a map?

Is there a difference between an `std::pair` and an `std::tuple` with only two members? (Besides the obvious that `std::pair` requires two and only two members and `tuple` may have more or less...)

Difference between std::pair and std::tuple with only two members?

I have a `map` like this:

    map&lt;string, pair&lt;string,string&gt; &gt; myMap;

And I&#39;ve inserted some data into my map using:

    myMap.insert(make_pair(first_name, make_pair(middle_name, last_name)));

How can I now print out all the data in my map?

How can I print out C++ map values?

The following program does not compile an unordered set of pairs of integers, but it does for integers. Can `unordered_set` and its member functions be used on user-defined types, and how can I define it? 

    #include &lt;unordered_set&gt;
    ...
    
    class A{
    ...
    private: 
        std::unordered_set&lt; std::pair&lt;int, int&gt; &gt; u_edge_;
    };

Compiler error:

&gt; error: no matching function for call to &#39;std::unordered_set&lt;std::pair&lt;unsigned int, unsigned int&gt; &gt;::unordered_set()&#39;

How can I make an unordered set of pairs of integers in C++?

I have a map where I&#39;d like to perform a call on every data type object member function. I yet know how to do this on any sequence but, is it possible to do it on an associative container?

The closest answer I could find was this: [Boost.Bind to access std::map elements in std::for_each][1]. But I cannot use boost in my project so, is there an STL alternative that I&#39;m missing to boost::bind?

If not possible, I thought on creating a temporary sequence for pointers to the data objects and then, call for_each on it, something like this:

    class MyClass
    {
    public:
     void Method() const;
    }
    
    std::map&lt;int, MyClass&gt; Map;
    //...
    
    std::vector&lt;MyClass*&gt; Vector;
    std::transform(Map.begin(), Map.end(), std::back_inserter(Vector), std::mem_fun_ref(&amp;std::map&lt;int, MyClass&gt;::value_type::second));
    std::for_each(Vector.begin(), Vector.end(), std::mem_fun(&amp;MyClass::Method));

It looks too obfuscated and I don&#39;t really like it. Any suggestions?

  [1]: https://stackoverflow.com/questions/2311752/boost-bind-to-access-stdmap-elements-in-stdfor-each


Use of for_each on map elements

I&#39;m interested: What is C#&#39;s analog of `std::pair` in C++? I found `System.Web.UI.Pair` class, but I&#39;d prefer something template-based.

Thank you!


All Std Pair Solutions on Gang of Coders

Total of 11 Std Pair Solutions