# std::memcpy

From cppreference.com
< cpp‎ | string‎ | byte

Defined in header `<cstring>` |  |
void* memcpy( void* dest, const void* src, std::size_t count ); |  |

Copies `count` bytes from the object pointed to by `src` to the object pointed to by `dest`. Both objects are reinterpreted as arrays of unsigned char.

If the objects overlap, the behavior is undefined.

If either `dest` or `src` is a null pointer, the behavior is undefined, even if `count` is zero.

If the objects are potentially-overlapping or not TriviallyCopyable, the behavior of `memcpy` is not specified and may be undefined.

### Parameters

dest | - | pointer to the memory location to copy to
src | - | pointer to the memory location to copy from
count | - | number of bytes to copy

### Return value

`dest`

### Notes

`std::memcpy` is meant to be the fastest library routine for memory-to-memory copy. It is usually more efficient than std::strcpy, which must scan the data it copies or std::memmove, which must take precautions to handle overlapping inputs.

Several C++ compilers transform suitable memory-copying loops to `std::memcpy` calls.

Where strict aliasing prohibits examining the same memory as values of two different types, `std::memcpy` may be used to convert the values.

### Example

Run this code

    #include <iostream>
    #include <cstdint>
    #include <cstring>

    int main()
    {
        // simple usage
        char source[] = "once upon a midnight dreary...", dest[4];
        std::memcpy(dest, source, sizeof dest);
        for (char c : dest)
            std::cout << c << '\n';

        // reinterpreting
        double d = 0.1;
    //  std::int64_t n = *reinterpret_cast<std::int64_t*>(&d); // aliasing violation
        std::int64_t n;
        std::memcpy(&n, &d, sizeof d); // OK

        std::cout << std::hexfloat << d << " is " << std::hex << n
                  << " as an std::int64_t\n";
    }

Output:

    o
    n
    c
    e
    0x1.999999999999ap-4 is 3fb999999999999a as an std::int64_t

### See also

memmove | moves one buffer to another (function)
memset | fills a buffer with a character (function)
wmemcpy | copies a certain amount of wide characters between two non-overlapping arrays (function)
copycopy_if (C++11) | copies a range of elements to a new location (function template)
copy_backward | copies a range of elements in backwards order (function template)
is_trivially_copyable (C++11) | checks if a type is trivially copyable (class template)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/string/byte/memcpy&oldid=108588"