Depends. In general, you couldn’t physically copy anything larger than the largest usable register in a single cycle, but that’s not really how machines work these days. In practice, you really care less about what the CPU is doing and more about the characteristics of DRAM. The memory hierarchy of the machine is going to … Read more
You should never expect them to outperform assignments. The reason is, the compiler will use memcpy anyway when it thinks it would be faster (if you use optimize flags). If not and if the structure is reasonable small that it fits into registers, direct register manipulation could be used which wouldn’t require any memory access … Read more
c c17 The older question Is it guaranteed to be safe to perform memcpy(0,0,0)? points out 7.1.4p1: Each of the following statements applies unless explicitly stated otherwise in the detailed descriptions that follow: If an argument to a function has an invalid value (such as a value outside the domain of the function, or a … Read more
If a function has nothing specific to return, it is often customary to return one of the input parameters (the one that is seen as the primary one). Doing this allows you to use “chained” function calls in expressions. For example, you can do char buffer[1024]; strcat(strcpy(buffer, “Hello”), ” World”); specifically because strcpy returns the … Read more
This doesn’t directly answer your question, but you should simply use std::copy: T c[N]; std::array<T, N> cpp; // from C to C++ std::copy(std::begin(c), std::end(c), std::begin(cpp)); // from C++ to C std::copy(std::begin(cpp), std::end(cpp), std::begin(c)); If T is a trivially copyable type, this’ll compile down to memcpy. If it’s not, then this’ll do element-wise copy assignment and … Read more
Courtesy of William Chan and Google. 30-70% faster than memcpy in Microsoft Visual Studio 2005. void X_aligned_memcpy_sse2(void* dest, const void* src, const unsigned long size) { __asm { mov esi, src; //src pointer mov edi, dest; //dest pointer mov ebx, size; //ebx is our counter shr ebx, 7; //divide by 128 (8 * 128bit registers) … Read more
A std::string’s allocation is not guaranteed to be contiguous under the C++98/03 standard, but C++11 forces it to be. In practice, neither I nor Herb Sutter know of an implementation that does not use contiguous storage. Notice that the &s[0] thing is always guaranteed to work by the C++11 standard, even in the 0-length string … Read more
In C: #include <string.h> // memcpy #include <stdlib.h> //realloc In C++, remove the .h and prefix with a c. In C++, they will be placed in the std namespace, but are also global.
I always prefer the syntax memcpy( &dst[dstIdx], &src[srcIdx], numElementsToCopy * sizeof( Element ) );
The struct1=struct2; notation is not only more concise, but also shorter and leaves more optimization opportunities to the compiler. The semantic meaning of = is an assignment, while memcpy just copies memory. That’s a huge difference in readability as well, although memcpy does the same in this case. Use =.