Асоциативна карта на ключ към ключ в C++

Когато публикувах първия си отговор, не бях наясно, че нещо като boost::bimap съществува. Съгласен съм, че преобръщането на вашата собствена двупосочна карта вероятно е по-лошо от използването на предполагаемо много висококачествено изпълнение на Boost. Още повече, ако вашият проект вече има зависимост от Boost. Ако най-голямото ви притеснение е липсата на конструктор на списък на инициализатор за boost::bimap, можете лесно да добавите тази функционалност като фабрична функция.

#include <initializer_list>
#include <iostream>
#include <stdexcept>
#include <string>
#include <utility>

#include <boost/bimap.hpp>

template<typename T1, typename T2>
boost::bimap<T1, T2>
make_bimap(const std::initializer_list<std::pair<T1, T2>> initlist)
{
  using bimap_type = boost::bimap<T1, T2>;
  using value_type = typename bimap_type::value_type;
  bimap_type bimap {};
  for (const auto& iter : initlist)
    {
      if (!bimap.insert(value_type {iter.first, iter.second}).second)
        throw std::invalid_argument {"already mapped"};
    }
  return bimap;
}

int
main()
{
  using namespace std::literals;
  const auto bimap = make_bimap<int, std::string>({
      {0, "zero"s},
      {1, "one"s},
      {2, "two"s},
   // {1, "zero"s},  // would throw
   // {9, "one"s},   // would throw
  });
  std::cout << bimap.left.at(1) << std::endl;
  std::cout << bimap.right.at("one") << std::endl;
  return 0;
}

Изход:

one
1

Заслугата за първоначалното споменаване на boost::bimap е на @Pradhan.

Можете лесно да приложите това, като използвате две std::maps.

#include <iostream>
#include <map>
#include <stdexcept>
#include <string>

template<typename T1, typename T2>
class BidirectionalMap
{

private:

  std::map<T1, T2> lhs2rhs_ {};
  std::map<T2, T1> rhs2lhs_ {};

public:

  BidirectionalMap()
  {
  }

  // This is not thread-safe, if you need thread-safety, use a mutex.
  void
  insert(const T1& lhs, const T2& rhs)
  {
    if (this->lhs2rhs_.count(lhs) || this->rhs2lhs_.count(rhs))
      throw std::invalid_argument {"already mapped"};
    this->lhs2rhs_[lhs] = rhs;
    this->rhs2lhs_[rhs] = lhs;
  }

  T2
  lookupLeft(const T1& lhs) const
  {
    return this->lhs2rhs_.at(lhs);
  }

  T1
  lookupRight(const T2& rhs) const
  {
    return this->rhs2lhs_.at(rhs);
  }
};

template<typename T1, typename T2>
void
demo_insert(BidirectionalMap<T1, T2>& mymap, const T1& lhs, const T2& rhs)
{
  try
    {
      mymap.insert(lhs, rhs);
    }
  catch (const std::exception& e)
    {
      std::cerr << "cannot insert (" << lhs << ", " << rhs << "): "
                << e.what() << std::endl;
    }
}


int
main()
{
  using namespace std::literals;
  BidirectionalMap<int, std::string> mymap {};
  demo_insert(mymap, 0, "zero"s);
  demo_insert(mymap, 1, "one"s);
  demo_insert(mymap, 2, "two"s);
  demo_insert(mymap, 1, "zero"s);
  demo_insert(mymap, 9, "one"s);
  std::cout << mymap.lookupLeft(1) << std::endl;
  std::cout << mymap.lookupRight("one") << std::endl;
  return 0;
}

Изход:

cannot insert (1, zero): already mapped
cannot insert (9, one): already mapped
one
1