Как вы копируете содержимое массива в std::vector в C++ без зацикливания?
У меня есть массив значений, который передается в мою функцию из другой части программы, которую мне нужно сохранить для дальнейшей обработки. Поскольку я не знаю, сколько раз моя функция будет вызываться до того, как наступит время обработки данных, мне нужна динамическая структура хранения, поэтому я выбрал std::vector, Я не хочу делать стандартный цикл для push_back все значения по отдельности, было бы хорошо, если бы я мог просто скопировать все это, используя что-то похожее на memcpy,
10 ответов
Если вы можете построить вектор после того, как вы получили массив и размер массива, вы можете просто сказать:
std::vector<ValueType> vec(a, a + n);
... при условии, a ваш массив и n количество элементов в нем Иначе, std::copy() ж /resize() сделает свое дело.
Я бы держался подальше от memcpy() если только вы не уверены, что значения относятся к типам старых данных (POD).
Также стоит отметить, что ни один из них действительно не избегает цикла for - это просто вопрос того, должны ли вы видеть это в своем коде или нет. O(n) производительность во время выполнения неизбежна для копирования значений.
Наконец, обратите внимание, что массивы в стиле C являются совершенно допустимыми контейнерами для большинства алгоритмов STL - необработанный указатель эквивалентен begin(), а также (ptr + n) эквивалентно end(),
Здесь было много ответов, и почти все из них выполнят свою работу.
Однако есть несколько вводящих в заблуждение советов!
Вот варианты:
vector<int> dataVec;
int dataArray[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
unsigned dataArraySize = sizeof(dataArray) / sizeof(int);
// Method 1: Copy the array to the vector using back_inserter.
{
copy(&dataArray[0], &dataArray[dataArraySize], back_inserter(dataVec));
}
// Method 2: Same as 1 but pre-extend the vector by the size of the array using reserve
{
dataVec.reserve(dataVec.size() + dataArraySize);
copy(&dataArray[0], &dataArray[dataArraySize], back_inserter(dataVec));
}
// Method 3: Memcpy
{
dataVec.resize(dataVec.size() + dataArraySize);
memcpy(&dataVec[dataVec.size() - dataArraySize], &dataArray[0], dataArraySize * sizeof(int));
}
// Method 4: vector::insert
{
dataVec.insert(dataVec.end(), &dataArray[0], &dataArray[dataArraySize]);
}
// Method 5: vector + vector
{
vector<int> dataVec2(&dataArray[0], &dataArray[dataArraySize]);
dataVec.insert(dataVec.end(), dataVec2.begin(), dataVec2.end());
}
Короче говоря, метод 4, использующий vector::insert, является лучшим для сценария bsruth.
Вот некоторые кровавые детали:
Способ 1, вероятно, самый простой для понимания. Просто скопируйте каждый элемент из массива и вставьте его в конец вектора. Увы, это медленно. Поскольку существует цикл (подразумевается функцией копирования), каждый элемент должен обрабатываться индивидуально; Невозможно улучшить производительность, поскольку мы знаем, что массив и векторы являются смежными блоками.
Метод 2 является предложенным улучшением производительности по методу 1; просто предварительно зарезервируйте размер массива перед его добавлением. Для больших массивов это может помочь. Однако лучший совет здесь - никогда не использовать резерв, если профилирование не предполагает, что вы можете добиться улучшения (или вам нужно убедиться, что ваши итераторы не будут признаны недействительными). Бьярне соглашается. Кстати, я обнаружил, что этот метод работал медленнее всего большую часть времени, хотя я изо всех сил пытаюсь всесторонне объяснить, почему он регулярно значительно медленнее, чем метод 1...
Метод 3 - старое школьное решение - бросьте немного C в проблему! Работает нормально и быстро для типов POD. В этом случае необходимо вызывать изменение размера, поскольку memcpy работает за пределами вектора, и нет никакого способа сообщить вектору, что его размер изменился. Помимо того, что это некрасивое решение (байтовое копирование!), Помните, что это можно использовать только для типов POD. Я бы никогда не использовал это решение.
Метод 4 - лучший путь. Смысл понятен, он (как правило) самый быстрый и работает для любых объектов. Нет недостатка в использовании этого метода для этого приложения.
Метод 5 - это настройка метода 4 - скопируйте массив в вектор и добавьте его. Хороший вариант - как правило, быстрый и понятный.
Наконец, вы знаете, что вы можете использовать векторы вместо массивов, верно? Даже когда функция ожидает массивы в стиле c, вы можете использовать векторы:
vector<char> v(50); // Ensure there's enough space
strcpy(&v[0], "prefer vectors to c arrays");
Надеюсь, что это поможет кому-то там!
Если все, что вы делаете, это заменяет существующие данные, то вы можете сделать это
std::vector<int> data; // evil global :)
void CopyData(int *newData, size_t count)
{
data.assign(newData, newData + count);
}
Поскольку я могу редактировать только свой собственный ответ, я собираюсь составить ответ из других ответов на мой вопрос. Спасибо всем, кто ответил.
Используя std:: copy, это все еще выполняется в фоновом режиме, но вам не нужно вводить код.
int foo(int* data, int size)
{
static std::vector<int> my_data; //normally a class variable
std::copy(data, data + size, std::back_inserter(my_data));
return 0;
}
Используя обычную memcpy. Это, вероятно, лучше всего использовать для базовых типов данных (например, int), но не для более сложных массивов структур или классов.
vector<int> x(size);
memcpy(&x[0], source, size*sizeof(int));
int dataArray[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };//source
unsigned dataArraySize = sizeof(dataArray) / sizeof(int);
std::vector<int> myvector (dataArraySize );//target
std::copy ( myints, myints+dataArraySize , myvector.begin() );
//myvector now has 1,2,3,...10 :-)
Еще один ответ, поскольку человек сказал: "Я не знаю, сколько раз будет вызываться моя функция", вы можете использовать метод вставки вектора, например, так, чтобы добавлять массивы значений в конец вектора:
vector<int> x;
void AddValues(int* values, size_t size)
{
x.insert(x.end(), values, values+size);
}
Мне нравится этот способ, потому что реализация вектора должна быть в состоянии оптимизировать для наилучшего способа вставки значений на основе типа итератора и самого типа. Вы несколько отвечаете на реализацию stl.
Если вам нужно гарантировать максимальную скорость, и вы знаете, что ваш тип является типом POD, я бы порекомендовал метод изменения размера в ответе Томаса:
vector<int> x;
void AddValues(int* values, size_t size)
{
size_t old_size(x.size());
x.resize(old_size + size, 0);
memcpy(&x[old_size], values, size * sizeof(int));
}
Избегай memcpy, говорю я. Нет причин возиться с операциями с указателями, если только вам это не нужно. Кроме того, он будет работать только для типов POD (например, int), но потерпит неудачу, если вы имеете дело с типами, которые требуют построения.
В дополнение к методам, представленным выше, вам нужно убедиться, что вы используете либо std::Vector.reserve(), std::Vector.resize(), либо создаете вектор по размеру, чтобы убедиться, что в вашем векторе достаточно элементов. это держать ваши данные. если нет, вы испортите память. Это верно как для std:: copy (), так и для memcpy ().
Это причина для использования vector.push_back(), вы не можете писать после конца вектора.
Предполагая, что вы знаете, насколько большой элемент в векторе:
std::vector<int> myArray;
myArray.resize (item_count, 0);
memcpy (&myArray.front(), source, item_count * sizeof(int));