Почему карта пропускает первый символ? [Дубликат]

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

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

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

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

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

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

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

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

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

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

Рассмотрим такой вход - 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 и инициализировал значение на ноль, если ключ не присутствовал на карте. А также он увеличил значение, несмотря на то, что элемент был на карте или нет.

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

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

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

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

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

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