Почему std :: map operator [] создает объект, если ключ не существует?

Поскольку operator[] возвращает ссылку на само значение, и поэтому единственный способ указать на проблему - это вызвать исключение (и в целом STL редко генерирует исключения).

Если вам не нравится такое поведение, вы можете использовать вместо него map::find. Он возвращает итератор вместо значения. Это позволяет ему возвращать специальный итератор, когда значение не найдено (он возвращает map::end), но также требует, чтобы вы разыменовали итератор, чтобы получить значение.

Стандарт говорит (23.3.1.2/1), что оператор [] возвращает (*((insert(make_pair(x, T()))).first)).second. Вот в чем причина. Возвращает ссылку T&. Невозможно вернуть недействительную ссылку. И он возвращает ссылку, потому что, я думаю, это очень удобно, не так ли?

Чтобы ответить на ваш настоящий вопрос: нет убедительного объяснения того, почему это было сделано именно так. "Просто так".

Поскольку std::map является ассоциативным контейнером, нет четкого предопределенного диапазона ключей, который должен существовать (или не существовать) на карте (в отличие от совершенно другой ситуации с std::vector). Это означает, что с std::map вам понадобятся функции поиска как без вставки, так и без вставки. Можно перегрузить [] способом без вставки и предоставить функцию для вставки. Или можно было бы сделать наоборот: перегрузить [] как оператор вставки и предоставить функцию для поиска без вставки. Итак, кто-то когда-то решил последовать второму подходу. Вот и все.

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

Это для целей назначения:

void test()
{
   std::map<std::string, int >myMap;
   myMap["hello"] = 5;
}

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

Также есть фундаментальная разница в том, как обычно используется карта. С вектором обычно есть четкое разграничение между вещами, которые добавляют к вектору, и вещами, которые работают с тем, что уже есть в векторе. С картой это гораздо менее верно - гораздо чаще можно увидеть код, который управляет существующим элементом, если он есть, или добавляет новый элемент, если его еще нет. Дизайн оператора [] для каждого отражает это.

Он позволяет вставлять новые элементы с operator[], например:

std::map<std::string, int> m;
m["five"] = 5;

5 присваивается значению, возвращаемому m["five"], которое является ссылкой на вновь созданный элемент. Если operator[] не будет вставлять новые элементы, это не сработает.

map.insert (ключ, элемент); проверяет наличие ключа на карте, но не перезаписывает существующее значение.

map.operator [ключ] = элемент; проверяет наличие ключа на карте и заменяет любое существующее значение элементом.

Обе эти операции достаточно важны, чтобы оправдать единственную строчку кода. Разработчики, вероятно, выбрали, какая операция более интуитивно понятна для operator [], и создали вызов функции для другой.

Разница здесь в том, что карта хранит «индекс», то есть значение, хранящееся в карте (в ее базовом дереве RB), является std::pair, а не просто «индексированным» значением. Всегда есть map::find(), который сообщит вам, существует ли пара с данным ключом.

Ответ в том, что им нужна была и удобная, и быстрая реализация.

Базовая реализация вектора - это массив. Итак, если в массиве 10 записей, а вам нужна запись 5, функция T & vector :: operator [] (5) просто возвращает headptr + 5. Если вы запросите ввод 5400, он вернет headptr + 5400.

Базовая реализация карты обычно представляет собой дерево. Каждый узел выделяется динамически, в отличие от вектора, который по стандарту должен быть непрерывным. Итак, nodeptr + 5 ничего не означает, а map ["некоторая строка"] не означает rootptr + offset ("некоторая строка").

Как и в случае поиска с картами, у вектора есть функция getAt (), если вы хотите проверить границы. В случае векторов проверка границ считалась ненужной платой для тех, кто этого не хотел. В случае с картами единственный способ не возвращать ссылку - это создать исключение, и это также считалось ненужными затратами для тех, кто этого не хотел.

Рассмотрим такой ввод - 3 блока, в каждом блоке 2 строки, первая строка - количество элементов во втором:

5
13 20 22 43 146
4
13 22 43 146
5
13 43 67 89 146

Задача: подсчитать количество целых чисел, которые присутствуют во вторых строках всех трех блоков. (Для этого примера ввода вывод должен быть 3, поскольку 13, 43 и 146 присутствуют во вторых строках всех трех блоков)

Посмотрите, насколько хорош этот код:

int main ()
{
    int n, curr;
    map<unsigned, unsigned char> myMap;
    for (int i = 0; i < 3; ++i)
    {
        cin >> n;
        for (int j = 0; j < n; ++j)
        {
            cin >> curr;
            myMap[curr]++;
        }

    }

    unsigned count = 0;
    for (auto it = myMap.begin(); it != myMap.end(); ++it)
    {
        if (it->second == 3)
            ++count;
    }

    cout << count <<endl;
    return 0;
}

По стандарту operator[] возвращает ссылку на (*((insert(make_pair(key, T()))).first)).second. Вот почему я мог написать:

myMap[curr]++;

и он вставил элемент с ключом curr и инициализировал значение нулем, если ключ отсутствовал на карте. А также увеличивало значение вне зависимости от того, был ли элемент на карте или нет.

Видишь, как просто? Приятно, правда? Это хороший пример того, что это действительно удобно.

Я знаю, что это старый вопрос, но, похоже, никто не ответил на него, ИМО. Пока я не видел упоминания об этом:

Следует избегать возможности неопределенного поведения! Если есть какое-либо разумное поведение, помимо UB, то, думаю, нам следует с этим согласиться.

std::vector/array демонстрирует неопределенное поведение с плохим operator[] индексом, потому что на самом деле нет разумного варианта, поскольку это одна из самых быстрых и фундаментальных вещей, которые вы можете сделать в c / c ++, и было бы неправильно пытаться что-либо проверить. Проверка - это то, для чего нужен at().

std::*associative_container* уже проделал работу по поиску того, куда будет помещен индексированный элемент, поэтому имеет смысл создать его там и вернуть. Это очень полезное поведение, и альтернативы operator[] выглядят гораздо менее аккуратно, но даже если создание и вставка нового элемента не то, что вы хотели или бесполезно для вас, это все равно гораздо лучший результат, чем неопределенное поведение.

Я думаю, что operator[] является наиболее предпочтительным синтаксисом для использования ассоциативного контейнера для удобства чтения, и для меня это очень интуитивно понятно и точно соответствует концепции operator[] для массивов: возвращает ссылку на элемент в этой позиции, чтобы использовать или назначить.

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

Потом однажды я узнал, что могу вставить элемент с _8 _... жизнь стала лучше.

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

myMap["apple"] = "green";

or

char const * cColor = myMyp["apple"];

Я предлагаю в контейнер карты добавить такую ​​функцию, как

if( ! myMap.exist( "apple")) throw ...

читать намного проще и лучше, чем

if( myMap.find( "apple") != myMap.end()) throw ...