Как создать карту с ключами / значениями внутри тела класса один раз (не каждый раз, когда функции из класса вызываются)

Question

Я хотел бы создать класс C ++, который позволял бы возвращать значение по заданному ключу из карты и ключ по заданному значению. Я также хотел бы сохранить свою предопределенную карту в содержании класса. Методы для получения значения или ключа будут статическими. Как предопределить карту статически, чтобы предотвратить создание карты каждый раз, когда я вызываю функцию getValue (str)?

class Mapping
{
  static map<string, string> x;

  Mapping::Mapping()
  {
    x["a"] = "one";
    x["b"] = "two";
    x["c"] = "three";
  }

  string getValue(string key)
  {
    return x[key];
  }

  string getKey(string value)
  {
    map<string, string>::const_iterator it;

    for (it = x.begin(); it < x.end(); ++it)
      if (it->second == value)
        return it->first;

    return "";
  }
};

string other_func(string str)
{
  return Mapping.getValue(str);  // I don't want to do:  new Mapping().getValue(str);
}

Функция other_func вызывается часто, поэтому я бы предпочел использовать карту, которая создается только один раз (не каждый раз, когда вызывается other_func). Нужно ли создавать экземпляр Mapping в main (), а затем использовать его в other_func (возвращать instance.getValue (str)) или возможно определить карту в теле класса и использовать ее статическими функциями?

Answer 1

Это то, что вы хотите?

#include <map>
#include <string>

class Mapping
{
    private:
        // Internally we use a map.
        // But typedef the class so it is easy to refer too.
        // Also if you change the type you only need to do it in one place.
        typedef std::map<std::string, std::string>  MyMap;
        MyMap   x; // The data store.

        // The only copy of the map
        // I dont see any way of modifying so declare it const (unless you want to modify it)
        static const Mapping myMap;

        // Make the constructor private.
        // This class is going to hold the only copy.
        Mapping()
        {
            x["a"]  =       "one";
            x["b"]  =       "two";
            x["c"]  =       "three";
        }


    public:
        // Public interface.
        //    Returns a const reference to the value.
        //    The interface use static methods (means we dont need an instance)
        //    Internally we refer to the only instance.
        static std::string const& getValue(std::string const& value)
        {
            // Use find rather than operator[].
            // This way you dont go inserting garbage into your data store.
            // Also it allows the data store to be const (as operator may modify the data store
            // if the value is not found).

            MyMap::const_iterator   find    = myMap.x.find(value);
            if (find != myMap.x.end())
            {
                // If we find it return the value.
                return find->second;
            }

            // What happens when we don;t find anything.
            // Your original code created a garbage entry and returned that.
            // Could throw an exception or return a temporary reference.
            // Maybe ->  throw int(1);
            return "";
        }

};

Answer 2

Прежде всего, вы можете поискать Boost :: MultiIndex и / или Boost :: bimap .Любой из них, вероятно, немного поможет в вашей ситуации, когда вы захотите использовать один из парных элементов для поиска другого (bimap - это более прямое, чем вы хотите, но если вам может понадобиться добавить третий, четвертый и т. Д. Ключ, тогдаMultiIndex может работать лучше).В качестве альтернативы вы можете просто использовать пару отсортированных векторов.В таких ситуациях, когда данные остаются постоянными после их заполнения, они, как правило, позволяют быстрее выполнять поиск и потреблять меньше памяти.

Оттуда (даже если вам не нужно делать это явно), вы можетеобрабатывать инициализацию самого объекта карты немного как синглтон - поместите данные в первый раз, когда это необходимо, и с тех пор просто используйте их:

class Mapping { 
    static map<string, string> x;
    static bool inited;
public:
    Mapping() { 
        if (!inited) { 
            x["a"] = "one";
            x["b"] = "two";
            x["c"] = "three";
            inited = true;
        }
    }
    string getValue(string const &key) { return x[key]; }
};

// This initialization is redundant, but being explicit doesn't hurt.
bool Mapping::inited = false; 
map<string, string> Mapping::x;

С этим ваш some_func может выглядеть как-токак это:

string some_func(string const &input) {
    return Mapping().getValue(input);
}

Это все еще имеет небольшие издержки по сравнению с предварительным созданием и использованием объекта, но это должно быть намного меньше, чем повторное создание и повторная инициализациякарта (или что угодно) каждый раз.

Answer 3

Вам не нужно создавать статическую карту, особенно если вы хотите создать несколько Mapping объектов. Вы можете создать объект в main () там, где он вам нужен, и передать его по ссылке, как в:

string other_func(Mapping &mymap, string str)
{
   return mymap.getValue(str);
}

Конечно, это поднимает вопросы об эффективности, так как копируется множество string, поэтому вы можете просто позвонить getValue напрямую без дополнительных затрат на other_func.

Кроме того, если вы знаете что-нибудь о библиотеках Boost, то вы можете прочитать о Boost.Bimap, что-то вроде того, что вы здесь реализуете.

http://www.boost.org/doc/libs/1_42_0/libs/bimap/doc/html/index.html

Answer 4

Статика плохая.Не.Также, бросить или вернуть NULL указатель на not found, не вернуть пустую строку.Other_func должен быть методом-членом объекта Mapping, а не статическим методом.Все это отчаянно должно быть объектом.

template<typename Key, typename Value> class Mapping {
    std::map<Key, Value> primmap;
    std::map<Value, Key> secmap;
public:
    template<typename Functor> Mapping(Functor f) {
        f(primmap);
        struct helper {
            std::map<Value, Key>* secmapptr;
            void operator()(std::pair<Key, Value>& ref) {
                (*secmapptr)[ref.second] = ref.first;
            }
        };
        helper helpme;
        helpme.secmapptr = &secmap;
        std::for_each(primmap.begin(), primmap.end(), helpme);
    }
    Key& GetKeyFromValue(const Value& v) {
        std::map<Value,Key>::iterator key = secmap.find(v);
        if (key == secmap.end())
            throw std::runtime_error("Value not found!");
        return key->second;
    }
    Value& GetValueFromKey(const Key& k) {
        std::map<Key, Value>::iterator key = primmap.find(v);
        if (key == primmap.end())
            throw std::runtime_error("Key not found!");
        return key->second;
    }
    // Add const appropriately.
};

Этот код использует функциональный объект для инициализации карты, переворачивает его для вас, а затем предоставляет методы доступа к содержимому.Что касается того, почему вы используете такую ​​вещь, в отличие от необработанной пары std :: maps, я не знаю.

Глядя на часть написанного вами кода, я предполагаю, что выпроисходят из Java.В Java есть много вещей, которые пользователи C ++ не используют (если они не знают язык), такие как одиночные игры, статика и тому подобное.

Answer 5

Если вы много раз ищете значение ключа, вам будет проще и эффективнее поддерживать вторую карту параллельно с первой.