memcpy с startIndex?

Я всегда предпочитаю синтаксис

memcpy( &dst[dstIdx], &src[srcIdx], numElementsToCopy * sizeof( Element ) );

Просто добавьте смещение к адресам. Например, если вы хотите скопировать буфер, начиная с N-го байта:

memcpy( destination, source + N, sourceLen - N );

Это будет скопировано в место назначения . Если вы также хотите сместить адрес назначения - добавьте смещение к обоим:

memcpy( destination + N, source + N, sourceLen - N );

Индекс не требуется, потому что вы можете просто обновить указатель источника на указанное количество байтов. Следующая оболочка должна помочь

void* memcpy_index(void *s1, const void *s2, size_t index, size_t n) {
  s2 = ((char*)s2)+index;
  return memcpy(s1, s2,n);
}

Просто добавьте нужное смещение к адресу буфера.

char abuff[100], bbuff[100];
....
memcpy( bbuff, abuff + 5, 10 );

Это копирует 10 байтов, начиная с abuff [5] в bbuff.

Просто увеличьте указатель на свой начальный индекс.

Пример

const unsigned char * src = reinterpret_cast<const unsigned char*>(your source);
unsigned char * dest = reinterpret_cast<unsigned char *>(your dest);
memcpy(dest, src + offset, len);

Как насчет использования коллекций STL для предотвращения ошибок доступа к памяти?

Просто добавьте индекс к адресу буфера и передайте его в memcpy () в качестве исходного параметра, например, скопируйте из 3-го элемента буфера b

char a[10], b[20];
::memcpy(a,b+2,10);

Также примите во внимание тип элементов в буфере, параметр length (3-й) в memcpy () указывается в байтах, поэтому для копирования 4 целых чисел вы должны поместить 4 * sizeof (int) - что, вероятно, будет 16 (на 32-битном системы. Но тип не имеет значения для начального адреса из-за арифметики указателя:

int a[10], b[10];
::memcpy( a+2, b, 2*sizeof(int) );
// a+2 will be address of 3rd item in buffer a
// not address of 1st item + 2 bytes

У вас может быть функция, как показано ниже.

template<typename T>
T* memcopy_index(T* dst,T* src,unsigned int index, unsigned int element_count)
{
    return (T*)memcpy(dst,src + index, element_count * sizeof(T));
}

Ее можно использовать как показано ниже:

int src[]={0,1,2,3,4,5,6};
int dst[15];

memcopy_index(dst,src,2,5);    //copy 5 elements from index 2

Вы должны убедиться, что целевой буфер имеет достаточно места для копирования элементов.

Если вы используете c ++, вероятно, лучше использовать std :: copy () вместо memcpy (). std :: copy может принимать указатели так же легко, как и итераторы.

например

int src[20];
int dst[15];

// Copy last 10 elements of src[] to first 10 elements of dst[]
std::copy( src+10, src+20, dst );

Как и в случае с memcpy (), вы обязаны убедиться, что указатели действительны.

ПРИМЕЧАНИЕ. Если ваше использование критично для производительности, вы можете быстрее найти memcpy (), как описано в других ответах, но, вероятно, не намного.

Этому сайту требуется способ разрешить анонимные последующие запросы в дополнение к анонимным ответам.

Почему я чаще, чем однажды, вижу это безумное утверждение, что «индекс» должен быть в единицах по 1 байту? Это полная противоположность условности. «Индекс» обычно является символическим, мерой, физическое смещение байта которой определяется размером элемента в массиве (или вектора, который может даже не иметь физического макета массива, но тогда memcpy () также не имеет отношения к курс).

Итак, 5-й элемент в массиве имеет «индекс» 5, но:

• Если массив имеет тип char, то байтовое смещение этого «индекса» равно 5.
• Если массив имеет тип short (на x86), тогда байтовое смещение этого «индекса» равно 10.
• Если массив имеет тип int (на x86), то байтовое смещение этого «индекса» равно 20.
• Если массив имеет размер типа некоторого большого 48-байтового объекта, то смещение в байтах этого «индекса» равно 240.

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

О значении слов я бы предпочел прочитать:

 void* memcpy_offset(void *s1, const void *s2, size_t offset, size_t n);

, чем:

 void* memcpy_index(void *s1, const void *s2, size_t index, size_t n);

Я считаю, что идея о том, что полностью общий void * может иметь «индекс», вводит в заблуждение. (Пока мы здесь, «dest» и «source» или «in» и «out» будут гораздо менее двусмысленными, чем «s1» и «s2». Коду не нужно столько комментариев, когда вы выбираете самоочевидные имена переменных.)