blocks|key|4055286|text|我总是更喜欢这种语法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4055287|memcpy(+&dst[dstIdx],+&src[srcIdx],+numElementsToCopy+*+sizeof(+Element+)+);|code-block|syntax|javascript|4055288|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I always prefer the syntax 

<pre><code>memcpy( &amp;dst[dstIdx], &amp;src[srcIdx], numElementsToCopy * sizeof( Element ) );
</code></pre>

blocks|key|1589352|text|只需将您想要的偏移量添加到缓冲区的地址。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1589353|char+abuff[100],+bbuff[100];
....
memcpy(+bbuff,+abuff+%2B+5,+10+);|code-block|syntax|javascript|1589354|这会将从abuff5开始的10个字节复制到bbuff。|1589355|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Just add the offset you want to the address of the buffer.

<pre><code>char abuff[100], bbuff[100];
....
memcpy( bbuff, abuff + 5, 10 );
</code></pre>

This copies 10 bytes starting at abuff[5] to bbuff.

blocks|key|4055036|text|只需将偏移量添加到地址。例如，如果要复制从第N个字节开始的缓冲区：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4055037|memcpy(+destination,+source+%2B+N,+sourceLen+-+N+);|code-block|syntax|javascript|4055038|这将复制到destination。如果您还想对目标进行偏移-将偏移添加到两个：|offset|length|style|CODE|4055039|memcpy(+destination+%2B+N,+source+%2B+N,+sourceLen+-+N+);|4055040|entityMap^0|0|0|5|B|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Just add the offset to the addresses. For example, if you wanted to copy the buffer starting with the Nth byte:

<pre><code>memcpy( destination, source + N, sourceLen - N );
</code></pre>

This will copy to the <code>destination</code>. If you also want to offset the destination - add the offset to both:

<pre><code>memcpy( destination + N, source + N, sourceLen - N );
</code></pre>

blocks|key|5473725|text|不需要索引，因为您只需按指定的字节数更新源指针即可。下面的包装器应该可以做到这一点|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5473726|void*+memcpy_index(void+*s1,+const+void+*s2,+size_t+index,+size_t+n)+{
++s2+=+((char*)s2)%2Bindex;
++return+memcpy(s1,+s2,n);
}|code-block|syntax|javascript|5473727|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

An index is not required because you can simply update the source pointer by the specified number of bytes. The following wrapper should do the trick

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

blocks|key|1593457|text|只需增加指向起始索引的指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1593458|示例|1593459|const+unsigned+char+*+src+=+reinterpret_cast<const+unsigned+char*>(your+source);
unsigned+char+*+dest+=+reinterpret_cast<unsigned+char+*>(your+dest);
memcpy(dest,+src+%2B+offset,+len);|code-block|syntax|javascript|1593460|如果使用STL集合来避免内存访问错误呢？|1593461|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Simply increase your pointer to your start index.

Example

<pre><code>const unsigned char * src = reinterpret_cast&lt;const unsigned char*&gt;(your source);
unsigned char * dest = reinterpret_cast&lt;unsigned char *&gt;(your dest);
memcpy(dest, src + offset, len);
</code></pre>

What about using STL collections to avoid memory access errors?

blocks|key|1944927|text|这个网站需要一种方法，除了匿名答案之外，还允许匿名跟进。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1944928|为什么我不止一次看到这种疯狂的断言，即“索引”必须以1字节为单位？这是与惯例完全相反的。"index“通常是符号的，它的物理字节偏移量是由数组中元素的大小决定的(或者向量，它甚至可能没有数组的物理布局，但是memcpy()当然也是无关紧要的)。|1944929|因此，数组中的第5个元素的"index“为5，但是：|1944930|1944931|如果数组的类型为char，则该“索引”的字节偏移量为5。|unordered-list-item|1944932|如果该数组的类型为short+(在x86上)，则该“索引”的字节偏移量为10。|1944933|如果该数组的类型为int+(在x86上)，则该“索引”的字节偏移量为20。|1944934|如果该数组为某个大的48字节对象的类型，则该“索引”的字节偏移量为240。|1944935|1944936|哪种方式是访问特定元素的正确方式是一个侧重点。重要的是你要了解其中的不同之处，选择一个，并使代码正确。|1944937|1944938|关于单词的含义，我更愿意读：|1944939|+void*+memcpy_offset(void+*s1,+const+void+*s2,+size_t+offset,+size_t+n);|code-block|syntax|javascript|1944940|比：|1944941|+void*+memcpy_index(void+*s1,+const+void+*s2,+size_t+index,+size_t+n);|1944942|我发现一个完全通用的void+*可能有一个“索引”的想法是误导的。(在这里，"dest“和"source”或"in“和"out”将比"s1“和"s2”更加明确。当您选择自解释的变量名称时，代码不需要那么多注释。)|1944943|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1A|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|G|3|H|5|I|7|1C|8|@]|9|@]|A|$]]|$1|J|3|K|5|I|7|1D|8|@]|9|@]|A|$]]|$1|L|3|M|5|I|7|1E|8|@]|9|@]|A|$]]|$1|N|3|O|5|I|7|1F|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1H|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1J|8|@]|9|@]|A|$]]|$1|V|3|W|5|X|7|1K|8|@]|9|@]|A|$Y|Z]]|$1|10|3|11|5|6|7|1L|8|@]|9|@]|A|$]]|$1|12|3|13|5|X|7|1M|8|@]|9|@]|A|$Y|Z]]|$1|14|3|15|5|6|7|1N|8|@]|9|@]|A|$]]|$1|16|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|17|$]]

This site needs a way to allow anonymous followups in addition to anonymous answers.

Why, more than once, do I see this insane assertion that an "index" must be in units of 1 byte? It's the complete opposite of convention. An "index" is usually symbolic, a measure whose physical byte offset is determined by the size of the element in the array (or vector, which may not even have the physical layout of an array, but then memcpy() is irrelevant too of course).

So, the 5th element in an array has "index" 5, but:

<ul>
<li>If the array is type char, then the byte offset of that "index" is 5.</li>
<li>If the array is type short (on x86), then the byte offset of that "index" is 10.</li>
<li>If the array is type int (on x86), then the byte offset of that "index" is 20. </li>
<li>If the array is type of some large 48-byte object, then the byte offset of that "index" is 240.</li>
</ul>

Which way is the correct way to access that specific element is a side point. The important part is that you understand the difference, choose one, and make the code correct.

<hr>

On the meaning of words, I would much rather read:

<pre><code> void* memcpy_offset(void *s1, const void *s2, size_t offset, size_t n);
</code></pre>

than:

<pre><code> void* memcpy_index(void *s1, const void *s2, size_t index, size_t n);
</code></pre>

I find the idea that a completely generic void * could have an "index" to be misleading. (While we're here, "dest" and "source" or "in" and "out" would be much less ambiguous than "s1" and "s2". Code doesn't need as many comments when you pick self-explanatory variable names.)

blocks|key|5473795|text|只需将索引添加到缓冲区的地址，并将其作为源参数传递给memcpy()，例如从缓冲区b的第3项复制|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5473796|char+a[10],+b[20];
::memcpy(a,b%2B2,10);|code-block|syntax|javascript|5473797|还要考虑到缓冲区中项目的类型，memcpy()的length+(第3)参数是以字节为单位的，因此要复制4个整数，您应该放入4*sizeof(int)+-这可能是16+(在32位系统上)。但是类型对于起始地址并不重要，因为指针算法：|5473798|int+a[10],+b[10];
::memcpy(+a%2B2,+b,+2*sizeof(int)+);
//+a%2B2+will+be+address+of+3rd+item+in+buffer+a
//+not+address+of+1st+item+%2B+2+bytes|5473799|entityMap^0|Q|8|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

Simply add the index to the address of the buffer, and pass it to <code>memcpy()</code> as the source parameter, e.g. copy from 3rd item of buffer b

<pre><code>char a[10], b[20];
::memcpy(a,b+2,10);
</code></pre>

Also take into account the type of items in the buffer, length (3rd) parameter of memcpy() is in bytes, so to copy 4 ints you shall put 4*sizeof(int) - which will probably be 16 (on a 32 bit system. But the type does not matter for the start address, because of pointer arithmetics:

<pre><code>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
</code></pre>

blocks|key|5473903|text|你可以有一个如下所示的函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5473904|template<typename+T>
T*+memcopy_index(T*+dst,T*+src,unsigned+int+index,+unsigned+int+element_count)
{
++++return+(T*)memcpy(dst,src+%2B+index,+element_count+*+sizeof(T));
}|code-block|syntax|javascript|5473905|它的使用方法如下：|5473906|int+src[]={0,1,2,3,4,5,6};
int+dst[15];

memcopy_index(dst,src,2,5);++++//copy+5+elements+from+index+2|5473907|您必须确保目标缓冲区有足够的空间来复制元素。|5473908|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You could have a function like below.

<pre><code>template&lt;typename T&gt;
T* memcopy_index(T* dst,T* src,unsigned int index, unsigned int element_count)
{
 return (T*)memcpy(dst,src + index, element_count * sizeof(T));
}
</code></pre>

It can be used as below:

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

memcopy_index(dst,src,2,5); //copy 5 elements from index 2
</code></pre>

You have to make sure that destination buffer has enough room to copy the elements.

blocks|key|4055339|text|如果您使用的是c%2B%2B，那么使用std::copy()可能比使用memcpy()更好。copy可以像迭代器一样轻松地获取指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4055340|例如：|4055341|int+src[20];
int+dst[15];

//+Copy+last+10+elements+of+src[]+to+first+10+elements+of+dst[]
std::copy(+src%2B10,+src%2B20,+dst+);|code-block|syntax|javascript|4055342|与memcpy()一样，您有责任确保指针有效。|4055343|请注意。如果您的用法是性能关键型的，您可能会更快地找到其他答案中详细介绍的memcpy()，但可能不会太多。|4055344|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If you're using c++, it is probably better to use std::copy() instead of memcpy(). std::copy can take pointers just as easily as iterators.

e.g.

<pre><code>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 );
</code></pre>

As with memcpy(), it's your responsibility to make sure the pointers are valid.

NOTE. If your usage is performance critical you may find a memcpy() as detailed in the other answers quicker, but probably not by much.

I wish to copy content of specific length from one buffer to another from a specific starting point. I checked <code>memcpy()</code> but it takes only the length of content to be copied while I want to specify the starting index too.

Is there any function which can do this or is there any good approach to do it with the existing <code>memcpy</code> function?

memcpy with startIndex?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我希望从特定的起点将特定长度的内容从一个缓冲区复制到另一个缓冲区。我检查了memcpy()，但它只需要复制内容的长度，而我还想指定起始索引。有没有什么函数可以做到这一点，或者有什么好的方法可以用现有的memcpy函数来做到这一点？

问memcpy和startIndex？
EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问memcpy和startIndex？EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问memcpy和startIndex？
EN