Как скопировать содержимое массива в std :: vector в C ++ без цикла?

У меня есть массив значений, который передается моей функции из другой части программы, которую мне нужно сохранить для последующей обработки. Так как я не знаю, сколько раз будет вызываться моя функция, прежде чем придет время обрабатывать данные, мне нужна динамическая структура хранения, поэтому я выбрал файл std::vector. Я не хочу делать стандартный цикл для push_backвсех значений по отдельности, было бы неплохо, если бы я мог просто скопировать все это, используя что-то похожее на memcpy.

Если вы можете построить вектор после того, как получили массив и размер массива, вы можете просто сказать:

std::vector<ValueType> vec(a, a + n);

... предполагая, что aэто ваш массив и nколичество содержащихся в нем элементов. В противном случае std::copy()w / 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 - это то, что вы ищете.

Поскольку я могу редактировать только свой ответ, я собираюсь составить ответ на основе других ответов на свой вопрос. Спасибо всем, кто ответил.

Использование 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));

- избегай memcpy, - говорю я. Нет причин возиться с операциями с указателями, если только в этом нет необходимости. Кроме того, он будет работать только для типов POD (например, 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));
}

В дополнение к методам, представленным выше, вам необходимо убедиться, что вы используете либо 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));

http://www.cppreference.com/wiki/stl/vector/start