map - заполнение и удаление

std::map <int, int> myMap;
std::map <int, int> :: iterator it = myMap.begin();

while (it != myMap.end())
    myMap.begin() = generateRandomNumber();

for (myMap.begin(); it != myMap.end(); it++)
    std::cout << myMap[it] << " ";

#include <iostream>
#include <map>
#include <vector>
#include <algorithm>
#include <iterator>
#include <cstdlib>
#include <ctime>
 
int main()
{
   const size_t iterations = 10;
   const size_t max = 20;
   srand(time(0));
   std::map<int, int> values;
   std::vector<int> vec;
   for (size_t i = 0; i < iterations; ++i)
   {
      auto pos = values.insert(std::make_pair(rand() % max, rand() % max));
      if (!pos.second)
      {
         --i;
         continue;
      }
      vec.push_back(rand() % max);
   }
   std::cout << "map keys: ";
   std::for_each(values.begin(), values.end(), [](const std::pair<int, int>& p)
   {
      std::cout << p.first << " ";
   });
   std::cout << std::endl;
   std::cout << "vector: ";
   std::copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, " "));
   std::cout << std::endl;
   std::vector<int> original(vec);
   vec.erase(std::remove_if(vec.begin(), vec.end(), [&values](int v)
   {
      return values.find(v) == values.end();
   }), vec.end());
   for (std::map<int, int>::const_iterator pos = values.begin(); pos != values.end();)
   {
      if (std::find(original.begin(), original.end(), pos->first) == original.end())
      {
         pos = values.erase(pos);
      }
      else
      {
         ++pos;
      }
   }
   std::cout << "map keys: ";
   std::for_each(values.begin(), values.end(), [](const std::pair<int, int>& p)
   {
      std::cout << p.first << " ";
   });
   std::cout << std::endl;
   std::cout << "vector: ";
   std::copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, " "));
   std::cout << std::endl;
}

#include <iostream>
#include <random>
#include <functional>
#include <vector>
#include <algorithm>
#include <iterator>
 
template <typename ForwardIterator, typename T>
bool notUnique(ForwardIterator first, ForwardIterator last, T val)
{
    ForwardIterator it = std::find(first, last, val);
    if (it != last)
    {
        return std::find(++it, last, val) != last;
    }
    return false;
}
 
template <typename ForwardIterator, typename Generator>
void generateUnique(ForwardIterator first, ForwardIterator last, Generator gen)
{
    for (ForwardIterator it = first; it != last; ++it)
    {
        do
        {
            *it = gen();
        } while (notUnique(first, last, *it));
    }
}
 
int main()
{
    const size_t N = 10;
    std::vector<int> v(N);
    std::mt19937 gen {std::random_device()() };
    std::uniform_int_distribution<int> uid(0, N);
    auto roll = std::bind(uid, gen);
 
    generateUnique(std::begin(v), std::end(v), roll);
    std::sort(v.begin(), v.end());
    std::copy(std::begin(v), std::end(v), std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;
}

#include <iostream>
#include <random>
#include <functional>
#include <chrono>
#include <vector>
#include <cstddef>
 
using std::chrono::duration_cast;
using std::chrono::microseconds;
using std::chrono::steady_clock;
 
int main()
{
    const size_t N = 1000000;
    std::mt19937 gen {std::random_device()() };
    std::uniform_int_distribution<int> uid(0, N);
    auto roll = std::bind(uid, gen);
    steady_clock::time_point start, end;
 
    // part 1
    std::vector<int> v(N);
    start = steady_clock::now();
    for (auto it = v.begin(); it != v.end(); ++it)
        *it = roll();
    end = steady_clock::now();
    std::cout << "First: "
              << duration_cast<microseconds>(end - start).count() << std::endl;
 
    // part 2
    std::vector<int> v2(N);
    start = steady_clock::now();
    for (auto it = v2.begin(); it != v2.end(); it++)
        *it = roll();
    end = steady_clock::now();
    std::cout << "Second: "
              << duration_cast<microseconds>(end - start).count() << std::endl;
}

#include <iostream>
#include <random>
#include <functional>
#include <map>
 
template <typename Map, typename KeyGenerator, typename ValGenerator>
void generateUnique(Map& m, const size_t N, KeyGenerator keygen, ValGenerator valgen)
{
    typedef typename Map::key_type Key;
    typedef typename Map::mapped_type Type;
    for (size_t i=0; i < N; i++)
    {
        Key k;
        do
        {
            k = keygen();
        } while (m.find(k) != m.end());
        Type val = valgen();
        m.emplace(k, val);
    }
}
 
int main()
{
    const size_t N = 10;
    std::map<int, int> m;
 
    std::mt19937 gen {std::random_device()() };
    std::uniform_int_distribution<> uid(0, N);
    auto roll = std::bind(uid, gen);
 
    generateUnique(m, N, roll, roll);
    for (auto &p: m)
        std::cout << p.first << " => " << p.second << std::endl;
}