memcpy（）対memmove（）

私は違いを理解しようとしているmemcpy()としmemmove()、そして私は、テキスト読み持っているmemcpy()のに対し、重複送信元と送信先の世話をしていないmemmove()んです。

ただし、これらの2つの関数を重複するメモリブロックで実行すると、どちらも同じ結果になります。たとえば、memmove()ヘルプページで次のMSDNの例を見てください。

の欠点を理解し、それmemcpyをどのようにmemmove解決するためのより良い例がありますか？

// crt_memcpy.c
// Illustrate overlapping copy: memmove always handles it correctly; memcpy may handle
// it correctly.

#include <memory.h>
#include <string.h>
#include <stdio.h>

char str1[7] = "aabbcc";

int main( void )
{
    printf( "The string: %s\n", str1 );
    memcpy( str1 + 2, str1, 4 );
    printf( "New string: %s\n", str1 );

    strcpy_s( str1, sizeof(str1), "aabbcc" );   // reset string

    printf( "The string: %s\n", str1 );
    memmove( str1 + 2, str1, 4 );
    printf( "New string: %s\n", str1 );
}

出力：

The string: aabbcc
New string: aaaabb
The string: aabbcc
New string: aaaabb

あなたの例が奇妙な振る舞いを示さないことに全く驚いていません。代わりににコピーstr1してみてstr1+2、その後どうなるか確認してください。（実際には違いはないかもしれませんが、コンパイラ/ライブラリによって異なります。）

一般に、memcpyは単純な（ただし高速）方法で実装されます。単純に言えば、データを（順番に）ループし、ある場所から別の場所にコピーします。これにより、読み取り中にソースが上書きされる可能性があります。

Memmoveは、オーバーラップを正しく処理するために、より多くの作業を行います。

編集：

（残念ながら、適切な例は見つかりませんが、これで十分です）。ここに示すmemcpyとmemmoveの実装を比較してください。memcpyはループするだけですが、memmoveは、データの破損を防ぐためにループする方向を決定するテストを実行します。これらの実装はかなり単純です。ほとんどの高性能実装はより複雑です（バイトではなく、ワードサイズのブロックを一度にコピーする必要があります）。

のメモリmemcpy はオーバーラップできませんが、未定義の動作のリスクがありますが、メモリmemmoveはオーバーラップできます。

char a[16];
char b[16];

memcpy(a,b,16);           // valid
memmove(a,b,16);          // Also valid, but slower than memcpy.
memcpy(&a[0], &a[1],10);  // Not valid since it overlaps.
memmove(&a[0], &a[1],10); // valid. 

memcpyの一部の実装は、重複する入力に対しても機能する可能性がありますが、その動作を数えることはできません。memmoveは重複を許可する必要がありますが。

理由だけでmemcpy重複領域に対処する必要はありません、それは正しくそれらに対処しないという意味ではありません。領域が重複する呼び出しは、未定義の動作を生成します。未定義の動作は、1つのプラットフォームで期待どおりに完全に機能します。それが正しいまたは有効であるという意味ではありません。

memcpyとmemoveはどちらも同じようなことをします。

しかし、1つの違いを見抜くには：

#include <memory.h>
#include <string.h>
#include <stdio.h>

char str1[7] = "abcdef";

int main()
{

   printf( "The string: %s\n", str1 );
   memcpy( (str1+6), str1, 10 );
   printf( "New string: %s\n", str1 );

   strcpy_s( str1, sizeof(str1), "aabbcc" );   // reset string


   printf("\nstr1: %s\n", str1);
   printf( "The string: %s\n", str1 );
   memmove( (str1+6), str1, 10 );
   printf( "New string: %s\n", str1 );

}

与える：

The string: abcdef
New string: abcdefabcdefabcd
The string: abcdef
New string: abcdefabcdef

あなたのデモは「悪い」コンパイラーのためにmemcpyの欠点を明らかにしませんでした、それはデバッグバージョンであなたに有利です。ただし、リリースバージョンでも同じ出力が得られますが、最適化のためです。

    memcpy(str1 + 2, str1, 4);
00241013  mov         eax,dword ptr [str1 (243018h)]  // load 4 bytes from source string
    printf("New string: %s\n", str1);
00241018  push        offset str1 (243018h) 
0024101D  push        offset string "New string: %s\n" (242104h) 
00241022  mov         dword ptr [str1+2 (24301Ah)],eax  // put 4 bytes to destination
00241027  call        esi  

%eaxここのレジスタは一時的なストレージとして機能し、「エレガントに」オーバーラップの問題を修正します。

6バイトをコピーするときに欠点が明らかになりますが、少なくともその一部です。

char str1[9] = "aabbccdd";

int main( void )
{
    printf("The string: %s\n", str1);
    memcpy(str1 + 2, str1, 6);
    printf("New string: %s\n", str1);

    strcpy_s(str1, sizeof(str1), "aabbccdd");   // reset string

    printf("The string: %s\n", str1);
    memmove(str1 + 2, str1, 6);
    printf("New string: %s\n", str1);
}

出力：

The string: aabbccdd
New string: aaaabbbb
The string: aabbccdd
New string: aaaabbcc

奇妙に見えますが、それも最適化が原因です。

    memcpy(str1 + 2, str1, 6);
00341013  mov         eax,dword ptr [str1 (343018h)] 
00341018  mov         dword ptr [str1+2 (34301Ah)],eax // put 4 bytes to destination, earlier than the above example
0034101D  mov         cx,word ptr [str1+4 (34301Ch)]  // HA, new register! Holding a word, which is exactly the left 2 bytes (after 4 bytes loaded to %eax)
    printf("New string: %s\n", str1);
00341024  push        offset str1 (343018h) 
00341029  push        offset string "New string: %s\n" (342104h) 
0034102E  mov         word ptr [str1+6 (34301Eh)],cx  // Again, pulling the stored word back from the new register
00341035  call        esi  

これが、memmove2つの重複したメモリブロックをコピーするときに常に選択する理由です。

違いmemcpyとは、memmoveということです

1. ではmemmove、指定されたサイズのソースメモリがバッファにコピーされてから、宛先に移動されます。したがって、メモリが重複している場合、副作用はありません。

2. の場合、memcpy()ソースメモリ用に追加のバッファは使用されません。コピーはメモリ上で直接行われるため、メモリが重複していると、予期しない結果が生じます。

これらは、次のコードで確認できます。

//include string.h, stdio.h, stdlib.h
int main(){
  char a[]="hare rama hare rama";

  char b[]="hare rama hare rama";

  memmove(a+5,a,20);
  puts(a);

  memcpy(b+5,b,20);
  puts(b);
}

出力は次のとおりです。

hare hare rama hare rama
hare hare hare hare hare hare rama hare rama

すでに他の回答で指摘されているように、メモリの重複を考慮にmemmove入れるよりも高度ですmemcpy。memmoveの結果は、srcがバッファにコピーされ、次にバッファがにコピーされたかのように定義されdstます。これは、実際の実装がバッファを使用することを意味するのではなく、おそらくいくつかのポインタ計算を実行します。

コンパイラーはmemcpyを最適化できます。例えば：

int x;
memcpy(&x, some_pointer, sizeof(int));

このmemcpyは次のように最適化できます。 x = *(int*)some_pointer;

リンクhttp://clc-wiki.net/wiki/memcpyのmemcpyに示されているコードは、以下の例を使用して実装した場合と同じ出力が得られないため、少し混乱しているようです。

#include <memory.h>
#include <string.h>
#include <stdio.h>

char str1[11] = "abcdefghij";

void *memcpyCustom(void *dest, const void *src, size_t n)
{
    char *dp = (char *)dest;
    const char *sp = (char *)src;
    while (n--)
        *dp++ = *sp++;
    return dest;
}

void *memmoveCustom(void *dest, const void *src, size_t n)
{
    unsigned char *pd = (unsigned char *)dest;
    const unsigned char *ps = (unsigned char *)src;
    if ( ps < pd )
        for (pd += n, ps += n; n--;)
            *--pd = *--ps;
    else
        while(n--)
            *pd++ = *ps++;
    return dest;
}

int main( void )
{
    printf( "The string: %s\n", str1 );
    memcpy( str1 + 1, str1, 9 );
    printf( "Actual memcpy output: %s\n", str1 );

    strcpy_s( str1, sizeof(str1), "abcdefghij" );   // reset string

    memcpyCustom( str1 + 1, str1, 9 );
    printf( "Implemented memcpy output: %s\n", str1 );

    strcpy_s( str1, sizeof(str1), "abcdefghij" );   // reset string

    memmoveCustom( str1 + 1, str1, 9 );
    printf( "Implemented memmove output: %s\n", str1 );
    getchar();
}

出力：

The string: abcdefghij
Actual memcpy output: aabcdefghi
Implemented memcpy output: aaaaaaaaaa
Implemented memmove output: aabcdefghi

しかし、これでmemmoveが重複する問題を処理する理由を理解できます。

C11標準ドラフト

C11 N1570標準案言います：

7.24.2.1 "memcpy関数"：

2 memcpy関数は、s2が指すオブジェクトからn文字をs1が指すオブジェクトにコピーします。重複するオブジェクト間でコピーが行われた場合の動作は未定義です。

7.24.2.2 "memmove関数"：

2 memmove関数は、s2が指すオブジェクトからn文字をs1が指すオブジェクトにコピーします。コピーは、s2が指すオブジェクトのn文字が、s1およびs2が指すオブジェクトと重ならないn文字の一時配列に最初にコピーされた後、一時配列のn文字がs1が指すオブジェクト

したがって、オーバーラップはmemcpy未定義の動作につながり、何でも発生する可能性があります。良いことはまれです:-)

memmove ただし、すべてが中間バッファーが使用されているかのように行われるため、オーバーラップは明らかに問題ありません。

std::copyただし、C ++ はより寛容であり、オーバーラップを許可します。std:: copyはオーバーラップする範囲を処理しますか？

私は日食を使用して、同じプログラムを実行しようとしているとそれが間に明確な違いを示すmemcpyとしますmemmove。memcpy()データの破損を引き起こすメモリロケーションのオーバーラップは気にしませんが、memmove()データを一時変数に最初にコピーしてから、実際のメモリロケーションにコピーします。

場所str1からstr1+2にデータをコピーしようとしたときに、の出力memcpyは " aaaaaa"です。問題はどのようになるでしょうか？ memcpy()左から右に一度に1バイトをコピーします。プログラム " aabbcc"に示されているように、すべてのコピーは次のように行われます。

1. aabbcc -> aaabcc

2. aaabcc -> aaaacc

3. aaaacc -> aaaaac

4. aaaaac -> aaaaaa

memmove() 最初にデータを一時変数にコピーしてから、実際のメモリ位置にコピーします。

1. aabbcc(actual) -> aabbcc(temp)

2. aabbcc(temp) -> aaabcc(act)

3. aabbcc(temp) -> aaaacc(act)

4. aabbcc(temp) -> aaaabc(act)

5. aabbcc(temp) -> aaaabb(act)

出力は

memcpy ： aaaaaa

memmove ： aaaabb