Использование оператора [] на пустом std :: vector

Question

Мне было сообщено некоторое время назад, что было обычным явлением использовать std :: vector как исключающий безопасный динамический массив в C++ вместо выделения необработанных массивов ... например

{ 
    std::vector<char> scoped_array (size); 
    char* pointer = &scoped_array[0]; 

    //do work 

} // exception safe deallocation 

Я использовал настоящую Конвенцию в несколько раз без каких-либо проблем, однако я недавно портирован код для Win32 VisualStudio2010 (ранее это было только на MacOS/Linux) и мои модульных тестов ломаются (STDLIB бросает assert), когда размер вектора равен нулю.

Я понимаю, что запись в такой массив будет проблемой, но это предположение нарушает это решение как замену исходным указателям. Рассмотрим следующие функции с п = 0

void foo (int n) { 
    char* raw_array = new char[n]; 
    char* pointer = raw_array; 
    file.read (pointer , n); 
    for (int i = 0; i < n; ++i) { 
     //do something 
    } 
    delete[] raw_array; 
} 

Хотя, возможно, излишним, приведенный выше код является совершенно законным (я считаю), в то время как ниже код будет сгенерировано утверждение на VisualStudio2010

void foo (int n) { 
    std::vector<char> scoped_array (n); 
    char* pointer = &scoped_array[0]; 
    file.read (pointer , n); 
    for (int i = 0; i < n; ++i) { 
    //do something 
    } 
} 

Был Я использую неопределенное поведение? Я был под оператором показов [] не проверял ошибок, и это было действительное использование std :: vector <>. Кто-нибудь еще столкнулся с этой проблемой?

--edit: Благодарим за все полезные ответы в ответ людям, говорящим, что это неопределенное поведение. Есть ли способ заменить выделение массивного массива выше, которое будет работать с n = 0?

Говоря, что проверка на n = 0 как исключительный случай решит проблему (она будет). Есть много паттернов, где не требуется специальный случай (например, пример необработанного указателя выше), поэтому может понадобиться что-то, кроме std :: vector <>?

Answer 1

См. LWG issue 464. Это известная проблема. C++ 0x (который частично реализован MSVC 2010) решает его путем добавления члена .data().

Answer 2

MVS делает проверку диапазона в operator[] даже в выпусках. Я не знаю, соответствует ли он стандарту. (Я действительно нашел отладочный код в своей реализации, что сделало их реализацию нарушением правильного кода). Однако есть возможность отключить его.

Answer 3

Если вы хотите получить более чистое поведение в этом сценарии, вы можете заменить использование a[0] с использованием a.at(0), который будет метаться, если индекс недействителен.

Прагматичным решением будет вектор инициализации с n + 1 записями и ограничение доступа к 0..n-1 (как этот код уже делает).

void foo (int n) { 
    std::vector<char> scoped_array (n+1); 
    char* pointer = &scoped_array[0]; 
    file.read (pointer , n); 
    for (int i = 0; i < n; ++i) { 
    //do something 
    } 
} 

Answer 4

Это вызвало интересный вопрос, на мой взгляд, который я сразу же спросил here. В вашем случае, вы можете избежать использования указателей следующим образом:

template<class InputIterator, class OutputIterator> 
OutputIterator copy_n(InputIterator first, InputIterator last, OutputIterator result, std::size_t n) 
{ 
    for (std::size_t i = 0; i < n; i++) { 
     if (first == last) 
      break; 
     else 
      *result++ = *first++; 
    } 
    return result; 
} 

std::ifstream file("path_to_file"); 
std::vector<char> buffer(n); 
copy_n(std::istream_iterator<char>(file), 
     std::istream_iterator<char>(), 
     std::back_insert_iterator<vector<char> >(buffer), 
     n); 

Это скопирует содержимое файла в буфер n символов одновременно. Когда вы перебираете буфер, используйте:

for (std::vector<char>::iterator it = buffer.begin(); it != buffer.end(); it++) 

вместо счетчика.

Answer 5

Что касается стандарта C++, то operator[] не гарантированно не проверяет, это просто (в отличие от at()), это не гарантируется.

Вы ожидаете, что в неконтролирующей реализации &scoped_array[scoped_array.size()] приведет к легальному указателю либо внутри, либо по одному в конце массива, выделенного вектором. Это явно не гарантировано, но для конкретной реализации вы можете проверить, просмотрев ее источник. Для пустого вектора вообще не может быть выделение (в качестве оптимизации), и я не вижу ничего в части стандарта, которая определяет результат scoped_array[0], кроме таблицы 68.

Исходя из в таблице 68 вы можете сказать, что результатом вашего выражения является &*(a.begin() + 0), который незаконно разыгрывает сторонний итератор. Если векторный итератор вашей реализации - это просто указатель, то вы, вероятно, избегаете этого, если не можете, и, очевидно, ваше нет.

Я забыл результаты аргумента относительно того, является ли &* указателем, который не должен быть разыменован, является не-операцией или нет. IIRC, это не ясно из стандарта (некоторая двусмысленность где-то), что вызвало просьбы исправить стандарт, чтобы сделать его явно законным. Это говорит о том, что он действительно работает над всеми или наиболее известными реализациями.

Лично я бы не стал полагаться на это, и я бы не отключил проверку. Я бы переписать код:

char* pointer = (scoped_array.size() > 0) ? &scoped_array[0] : 0; 

Или в этом случае просто:

char* pointer = (n > 0) ? &scoped_array[0] : 0; 

Это выглядит просто неправильно меня использовать индекс п вектора, не зная, что размер, по крайней мере, п + 1, независимо от того, действительно ли он работает в вашей реализации после того, как вы отключили проверку.

Answer 6

operator [] возвращает ссылку, и поэтому ее обращение к пустому вектору должно быть неопределенным.

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

Итак, вы все время использовали неопределенное поведение. Необычные, но все еще непрочные проверки Visual Studio в operator [] только что раскрыли этот факт.

Answer 7

Не могли бы вы использовать итераторы вместо указателей?

{ 
    std::vector<char> scoped_array (size); 
    std::vector<char>::iterator pointer = scoped_array.begin(); 

    //do work 

} // exception safe deallocation