memcpy 与 startIndex ？

Question

我希望从一个特定的起点将特定长度的内容从一个缓冲区复制到另一个缓冲区。 我检查了 memcpy() ，但它只需要复制内容的长度，而我也想指定起始索引。

是否有任何函数可以执行此操作，或者是否有任何好的方法可以使用现有的 memcpy 函数来执行此操作？

Answer 1

我总是更喜欢语法

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

Answer 2

只需将所需的偏移量添加到缓冲区的地址即可。

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

这将从 abuff[5] 开始复制 10 个字节到 bbuff。

Answer 3

只需将偏移量添加到地址即可。 例如，如果您想复制从第 N 个字节开始的缓冲区：

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

这将复制到目标。 如果您还想偏移目的地 - 将偏移量添加到两者：

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

Answer 4

不需要索引，因为您只需按指定的字节数更新源指针即可。 下面的包装应该可以解决问题

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

Answer 5

只需将指针增加到起始索引即可。

示例

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 集合来避免内存访问错误怎么样？

Answer 6

除了匿名回答之外，该网站还需要一种允许匿名跟进的方法。

为什么我不止一次看到这种疯狂的断言：“索引”必须以 1 字节为单位？ 这与惯例完全相反。 “索引”通常是象征性的，其物理字节偏移量由数组（或向量，甚至可能没有数组的物理布局，但随后 memcpy() 也无关）中元素的大小确定课程）。

因此，数组中的第 5 个元素的“索引”为 5，但是：

• 如果数组为 char 类型，则该“索引”的字节偏移量为 5。
• 如果数组为 Short 类型（在 x86 上），则该字节偏移量该“索引”的值为 10。
• 如果该数组为 int 类型（在 x86 上），则该“索引”的字节偏移量为 20。
• 如果该数组是某个大型 48 字节对象的类型，则该数组的字节偏移量为“index”是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”更明确。当您选择不言自明时，代码不需要那么多注释变量名。）

Answer 7

只需将索引添加到缓冲区的地址，并将其作为源参数传递给 memcpy() ，例如从缓冲区 b 的第 3 个项目复制

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

还要考虑缓冲区中项目的类型， 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

Answer 8

你可以有一个像下面这样的函数。

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

您必须确保目标缓冲区有足够的空间来复制元素。

Answer 9

如果您使用 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() ，但可能不会太多。