void sync(std::map<int, int> *map1, std::vector<int>* vec1) 
{
    std::map<int, int>::iterator it = map1->begin();
    std::map<int, int>::iterator endIter = map1->end();
    int cnt=0;
    for (; it != endIter; ) 
    {
        if ( find(vec1->begin(), vec1->end(), it->second) == vec1->end()) {
            it = map1->erase(it);
            cnt++;
        }
        else {
            ++it;
        }
        
    }
    for( std::vector<int>::iterator vi = vec1->begin(); vi != vec1->end(); )
    {
        if( find( map1->begin(), map1->end())  == map1->end() )
        {
            vi = vec1->erase( vi );
            cnt++;
        }
        else
            vi++;
    }
 
}

using Map = std::map<int, int>;
using Vec = std::vector<int>;

template<class Pred>
void keep_map_items_if(Map& m, Pred&& p) {
  // удаляющий способ
  for (Map::iterator i = m.begin(); i != m.end(); )
    if (p(*i))
      ++i;
    else
      i = m.erase(i);

  // копирующий способ
  Map tmp;
  std::copy_if(m.begin(), m.end(), p, std::inserter(tmp));
  tmp.swap(m);
}

template<class Pred>
void keep_vector_items_if(Vec& v, Pred&& p) {
  // удаляющий способ (вместо поштучного удаления, как в твоём коде)
  v.erase(
    std::remove_if(v.begin(), v.end(), std::not1(p)), // в С++17 будет std::not_fn
    v.end()
  );

  // копирующий способ - такой же!
  Vec tmp;
  std::copy_if(v.begin(), v.end(), p, std::inserter(tmp));
  tmp.swap(v);
}

using Set = std::unordered_set<int>;

Set values_of_map(const Map& m) {
  Set s(v.size());  // резервируем количество корзин наобум (заведомо достаточное)
  for (const Map::item_type& kv : m)
    s.insert(kv.second);
  return s;
}

Set values_of_vector(const Vec& v) {
  return Set(v.begin(), v.end(), v.size());
}

void keep_map_items_present_in_vector(Map& m, const Vec& v) {
  Set s = values_of_vector(v);
  keep_map_items_if(m, [&s](const Map::item_type kv) { return s.find(kv.second) != s.end(); });
}

void keep_vector_items_present_in_map(Vec& v, const Map& m) {
  Set s = values_of_map(m);
  keep_vector_items_if(v, [&s](int e) { return s.find(e) != s.end(); });
}

// ну а теперь всё вместе (и ещё позволим себе алгоритмическую оптимизацию)
void keep_same_items(Map& m, Vec& v) {
  if (v.size() < m.size()) {
    keep_map_items_present_in_vector(m, v);
    keep_vector_items_present_in_map(v, m);
  } else {
    keep_vector_items_present_in_map(v, m);
    keep_map_items_present_in_vector(m, v);
  }
}

#include "stdafx.h"
#include <map>
#include <vector>
#include <algorithm>
using namespace std;

void sync(std::map<int, int> *map1, std::vector<int>* vec1)
{
    std::map<int, int>::iterator it = map1->begin();
    std::map<int, int>::iterator endIter = map1->end();
    int cnt = 0;
    for (; it != endIter; )
    {
        if (find(vec1->begin(), vec1->end(), it->second) == vec1->end()) {
            it = map1->erase(it);
            cnt++;
        }
        else {
            ++it;
        }

    }
    for (std::vector<int>::iterator vi = vec1->begin(); vi != vec1->end(); )
    {
        bool bFlag = false;
        for (auto& pair : *map1)
        {
            if (pair.second == *vi)
            {
                bFlag = true;
                break;
            }
        }
        if (!bFlag)
        {
            vi = vec1->erase(vi);
            cnt++;
        }
        else
            vi++;
    }

}


int main()
{
    vector<int> vectInt{ 0,2,8,3,7 };
    map<int, int> mapInt;
    mapInt[0] = 5;
    mapInt[1] = 7;
    mapInt[2] = 9;
    mapInt[3] = 8;
    mapInt[4] = 6;
    sync(&mapInt, &vectInt);

    return 0;
}

            it = map1->erase(it);

GK>        if( find( map1->begin(), map1->end())  == map1->end() )
GK>

find_if(map1->cbegin(), map1->cend(), [vi](const std::pair<int, int> &p) {
  return p.second == *vi;
})

W>            it = map1->erase(it);
W>

23.1.2/8
The insert members shall not affect the validity of iterators and references to the container, and the erase members shall invalidate only iterators and references to the erased elements.