Почему стандарт C ++ запрещает контейнеры элементов const? [Дубликат]

В дополнение к другим ответам, другой подход заключается в том, чтобы использовать:

vector<unique_ptr<const T>> vec;

Если это так, когда вы хотите обеспечить, чтобы только vec владел своими элементами. Или, если вы хотите, чтобы динамические перемещения элементов в vec и в какой-то момент их вытеснили.

Как указывалось, семантика указателя const может быть запутанной, но shared_ptr и unique_ptr aren «т. const unique_ptr<T> является указателем const, а unique_ptr<const T> является константой, как и следовало ожидать.

Обновить

В соответствии с принятым (и правильным) ответом я прокомментировал в 2011 году:

Нижняя строка: мы не создавали контейнеры для хранения const T. Хотя я и подумал. И мы пришли очень близко к тому, чтобы сделать это случайно. Насколько мне известно, текущая точка привязки - это пара перегруженных функций address-члена в распределителе по умолчанию: Когда T - const, эти две перегрузки имеют одну и ту же подпись. Легкий способ исправить это было бы специализацией std::allocator<const T> и удалением одной из перегрузок.

С предстоящим проектом C ++ 17 мне кажется, что мы теперь легализованы vector<const T>, и я также считаю, что мы это сделали случайно . : -)

P0174R0 удаляет address перегрузки с std::allocator<T>. P0174R0 не упоминает о поддержке std::allocator<const T> как части его обоснования.

Коррекция

В комментариях ниже T.C. правильно отмечает, что перегрузки address являются устаревшими , а не удалены. Виноват. Устаревшие члены не отображаются в 20.10.9, где std::allocator определен, но вместо этого отнесены к разделу D.9. Я забыл просканировать главу D для этой возможности, когда я разместил это.

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

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

Так что это не работает:

vector<const T> vec; 

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

vector<const shared_ptr<T>> vec;

T больше не const, но vector удерживает shared_ptr s, а не T s.

С другой стороны, это работает :

vector<const T *> vec;
vector<T const *> vec;  // the same as above

Но в этом случае const указывает объект, на который указывает, а не самого указателя (что и хранит вектор). Это было бы равнозначно:

vector<shared_ptr<const T>> vec;

Что хорошо.

Но если мы положим const в конец выражения, теперь он превращает указатель в const, поэтому следующее не будет компилироваться:

vector<T * const> vec;

Немного сбивает с толку, согласен, но вы привыкли к этому.