Namespaces
Variants

    std:: memcpy

    From fr.cppreference.net
    C++
    Text processing library
    Null-terminated byte strings
    Défini dans l'en-tête <cstring>
    void * memcpy ( void * dest, const void * src, std:: size_t count ) ;

    Effectue les opérations suivantes dans l'ordre :

    1. Crée implicitement des objets à dest .
    2. Copie count caractères (comme s'ils étaient de type unsigned char ) depuis l'objet pointé par src vers l'objet pointé par dest .

    Si l'une des conditions suivantes est satisfaite, le comportement est indéfini :

    Sommaire

    Paramètres

    dest - pointeur vers l'emplacement mémoire de destination
    src - pointeur vers l'emplacement mémoire source
    count - nombre d'octets à copier

    Valeur de retour

    S'il existe un objet créé approprié , retourne un pointeur vers celui-ci ; sinon retourne dest .

    Notes

    std::memcpy est conçu pour être la routine de bibliothèque la plus rapide pour la copie mémoire-à-mémoire. Elle est généralement plus efficace que std::strcpy , qui doit analyser les données qu'elle copie, ou std::memmove , qui doit prendre des précautions pour gérer les chevauchements d'entrées.

    Plusieurs compilateurs C++ transforment les boucles de copie mémoire appropriées en appels à std::memcpy .

    Lorsque l'aliasing strict interdit d'examiner la même mémoire comme des valeurs de deux types différents, std::memcpy peut être utilisé pour convertir les valeurs.

    Exemple

    Exécuter ce code 
    #include <cstdint>
#include <cstring>
#include <iostream>
int main()
{
    // utilisation simple
    char source[] = "once upon a daydream...", dest[4];
    std::memcpy(dest, source, sizeof dest);
    std::cout << "dest[4] = {";
    for (int n{}; char c : dest)
        std::cout << (n++ ? ", " : "") << '\'' << c << "'";
    std::cout << "};\n";
    // réinterprétation
    double d = 0.1;
//  std::int64_t n = *reinterpret_cast<std::int64_t*>(&d); // violation d'aliasing
    std::int64_t n;
    std::memcpy(&n, &d, sizeof d); // OK
    std::cout << std::hexfloat << d << " est " << std::hex << n
              << " comme std::int64_t\n" << std::dec;
    // création d'objet dans le tampon de destination
    struct S
    {
        int x{42};
        void print() const { std::cout << '{' << x << "}\n"; }
    } s;
    alignas(S) char buf[sizeof(S)];
    S* ps = new (buf) S; // placement new
    std::memcpy(ps, &s, sizeof s);
    ps->print();
}

    Sortie : 

    dest[4] = {'o', 'n', 'c', 'e'};
0x1.999999999999ap-4 est 3fb999999999999a comme std::int64_t
{42}

    Rapports de défauts

    Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

    DR Appliqué à Comportement tel que publié Comportement correct
    LWG 4064 C++98 il n'était pas clair si le pointeur retourné pointe vers un objet créé approprié clarifié

    Voir aussi

    		 déplace un tampon vers un autre
    (fonction)
    (C++26)
    		 remplit un tampon avec un caractère
    (fonction)
    		copie un certain nombre de caractères larges entre deux tableaux non chevauchants
    (fonction)
    		copie des caractères
    (fonction membre publique de std::basic_string<CharT,Traits,Allocator>)
    (C++11)
    		 copie une plage d'éléments vers un nouvel emplacement
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)(C++20)
    		copie une plage d'éléments dans l'ordre inverse
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)
    (C++11)
    		 vérifie si un type est trivialement copiable
    (modèle de classe)
    Documentation C pour memcpy