std::memcpy - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# 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 not `TriviallyCopyable`, the behavior of `memcpy` is not specified and may be undefined.

### [edit] 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

### [edit] Return value

`dest`

### [edit] 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.

### [edit] 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

### [edit] See also

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

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