Используя станд.:: карта <K, V>, где V не имеет никакого применимого конструктора по умолчанию

Если тип значения не может быть сконструирован по умолчанию, тогда оператор [] просто не будет работать для вас.

Что вы можете сделать, так это предоставить бесплатные функции, которые для удобства получают и устанавливают значения на карте.

Например:

template <class K, class V>
V& get(std::map<K, V>& m, const K& k)
{
    typename std::map<K, V>::iterator it = m.find(k);
    if (it != m.end()) {
        return it->second;
    }
    throw std::range_error("Missing key");
}

template <class K, class V>
const V& get(const std::map<K, V>& m, const K& k)
{
    typename std::map<K, V>::const_iterator it = m.find(k);
    if (it != m.end()) {
        return it->second;
    }
    throw std::range_error("Missing key");
}

template <class K, class V>
void set(std::map<K, V>& m, const K& k, const V& v)
{
    std::pair<typename std::map<K, V>::iterator,bool> result = m.insert(std::make_pair(k, v));
    if (!result.second) {
        result.first->second = v;
    }
}

Вы также можете рассмотреть такой геттер, как dict.get (key [ , default]) в Python (который возвращает предоставленное значение по умолчанию, если ключ отсутствует (но при этом возникает проблема удобства использования в том, что значение по умолчанию всегда должно быть создано, даже если вы знаете, что этот ключ находится на карте).

Ваш V не имеет конструктора по умолчанию, поэтому вы не можете ожидать, что std :: map std :: map :: operator [] для использования.

A std :: map > имеет ли ] mapped_type , который может быть сконструирован по умолчанию и, вероятно, имеет желаемую семантику. За подробностями обращайтесь к документации Boost.Optional (вы должны знать о них).

Не уверен, почему он компилируется для вас, я думаю, компилятор должен был обнаружить ваш отсутствующий конструктор.

как насчет использования

map<K,V*>

вместо

map<K,V> ?

Когда вы используете переопределение оператора в C ++, лучше придерживаться семантики оператора как можно точнее. в случае по умолчанию. Семантика по умолчанию. operator [] заменяет существующий член в массиве. Казалось бы, std :: map немного меняет правила. Это прискорбно, поскольку приводит к путанице подобного рода.

Обратите внимание, что документация ( http://www.sgi.com/tech/stl/Map.html ) для оператора [] под std :: map говорит: «Возвращает ссылку на объект, связанный с конкретным ключом. Если карта еще не содержит такого объекта, operator [] вставляет объект по умолчанию data_type ()».

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

вы можете специализировать std :: map для вашего типа значения. Я не говорю, что это хорошая идея, но это возможно. Я настроил dtor scoped_ptr на fclose вместо delete .

Что-то вроде:

 template<class K, class Compare, class Allocator>
 my_value_type& std::map<K,my_value_type,Compare,Allocator>::operator[](const K& k) 
 {
   //...
 }

Это должно позволить вам вставить код вы хотите в operator [] для вашего типа. К сожалению, в текущем C ++ я не знаю способа вернуть только r значений. В c ++ 0x вы можете использовать:

 template<class K, class Compare, class Allocator>
 my_value_type&& std::map<K,my_value_type,Compare,Allocator>::operator[](const K& k) 
 {
   //...
 }

Это вернет ссылку на R-значение (&&).

Это немного некрасиво, но один из способов обойти это - добавить переменную-член, которая отслеживает, действителен ли экземпляр или нет. Конструктор по умолчанию помечает экземпляр как недопустимый, но все остальные конструкторы помечают этот экземпляр как допустимый.

Убедитесь, что ваш оператор присваивания правильно передает новую переменную-член.

Измените свой деструктор, чтобы игнорировать недопустимые экземпляры.

Измените все остальные функции-члены так, чтобы они генерировали / ошибались / утверждали, когда они работают с недопустимым экземпляром.

Затем вы можете использовать свой объект на карте, и пока вы используете только объекты, которые были правильно сконструированы, ваш код будет работать нормально .

Опять же, это обходной путь, если вы хотите использовать карту STL и не хотите использовать вставку и поиск вместо оператора [].

Получите новый класс из std :: map и создайте свой собственный оператор [] . Пусть он вернет ссылку на константу, которую нельзя использовать как l-значение.