memcpy () বনাম মেমোমোভ ()

Question

আমি মধ্যে পার্থক্য বুঝতে চেষ্টা করছি memcpy()এবং memmove(), এবং আমি যে টেক্সট পড়া আছে memcpy()ওভারল্যাপিং উৎস যত্ন এবং গন্তব্য লাগবে না যেহেতু memmove()আছে।

যাইহোক, যখন আমি ওভারল্যাপিং মেমরি ব্লকগুলিতে এই দুটি ফাংশন সম্পাদন করি তখন তারা উভয়ই একই ফলাফল দেয়। উদাহরণস্বরূপ, memmove()সহায়তা পৃষ্ঠায় নিম্নলিখিত এমএসডিএন উদাহরণটি ধরুন : -

এর অপূর্ণতাগুলি বোঝার জন্য এর চেয়ে ভাল উদাহরণ 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

Comments

মাইক্রোসফ্ট সিআরটি বেশ কিছু সময়ের জন্য একটি নিরাপদ মেমকি () ছিল had

— হ্যান্স প্যাস্যান্ট

আমি মনে করি না "নিরাপদ" এর জন্য সঠিক শব্দ। একটি নিরাপদ memcpyচাইবে assertযে আপনার অঞ্চলগুলিতে ইচ্ছাকৃত আপনার বাগগুলি coveringাকানোর চেয়ে অঞ্চলগুলি ওভারল্যাপ না হয়।

— আর .. গিটহাব বন্ধ করুন ICE

আপনার অর্থ "বিকাশকারীদের পক্ষে নিরাপদ" বা "শেষ ব্যবহারকারীর পক্ষে নিরাপদ" কিনা তা নির্ভর করে। আমি যুক্তি দিয়েছি যে যেমন বলা হয়েছে তা করা, এটি মান-অনুপযুক্ত না হলেও শেষ ব্যবহারকারীর পক্ষে নিরাপদ পছন্দ।

— কুসমা

যেহেতু The string: aabbcc New string: aaaaaa The string: aabbcc New string: aaaabb

— গ্লিবসি

আপনি এখানে দেখতে পারেন ।

— রেন

Answer 1

আমি পুরোপুরি বিস্মিত হইনি যে আপনার উদাহরণটি কোনও অদ্ভুত আচরণ প্রদর্শন করে না। পরিবর্তে অনুলিপি str1করার চেষ্টা করুন str1+2এবং দেখুন কি হয়। (আসলে কোনও পার্থক্য নাও করতে পারে, সংকলক / গ্রন্থাগারগুলির উপর নির্ভর করে))

সাধারণভাবে, মেমকিটি একটি সহজ (তবে দ্রুত) উপায়ে প্রয়োগ করা হয়। সহজলভ্যভাবে, এটি কেবলমাত্র এক স্থান থেকে অন্য স্থানে অনুলিপি করে (ক্রমে) ডেটার উপরে লুপ করে। এটি পড়ার সময় উত্সটি ওভাররাইট হয়ে যাওয়ার ফলাফল হতে পারে।

ওভারল্যাপটি সঠিকভাবে পরিচালনা করে তা নিশ্চিত করতে মেমমভ আরও কাজ করে।

সম্পাদনা করুন:

(দুর্ভাগ্যক্রমে, আমি শালীন উদাহরণগুলি খুঁজে পাই না তবে এটিগুলি করবে)। এখানে দেখানো মেমকি এবং মেমোমোভ বাস্তবায়নের তুলনা করুন। মেমকিপি কেবল লুপ করে, যখন মেমোভ ডেটাটি ক্ষতিগ্রস্ত না করে কোন দিকটি লুপ করে তা নির্ধারণ করার জন্য একটি পরীক্ষা করে। এই বাস্তবায়ন বরং সহজ। সর্বাধিক উচ্চ-কার্যকারিতা বাস্তবায়নগুলি আরও জটিল (বাইটের পরিবর্তে একবারে শব্দের আকারের ব্লকগুলি অনুলিপি করার সাথে জড়িত)।

Comments

+1 টি এছাড়াও, নিম্নলিখিত বাস্তবায়নের, memmoveকল memcpy: এক শাখায় পয়েন্টার পরীক্ষার পর student.cs.uwaterloo.ca/~cs350/common/os161-src-html/...

— পাসকাল Cuoq

ভালই শোনা যাচ্ছে. দেখে মনে হচ্ছে ভিজ্যুয়াল স্টুডিও একটি "নিরাপদ" ম্যাকপি প্রয়োগ করে (জিসিসি ৪.১.১ সহ আমি আরএইচএল ৫ তেও পরীক্ষা করেছি)। Clc-wiki.net থেকে এই ফাংশনগুলির সংস্করণ লিখলে একটি পরিষ্কার চিত্র পাওয়া যায়। ধন্যবাদ।

— ব্যবহারকারী534785

মেমকিপি ওভারল্যাপিং-ইস্যুটির যত্ন নেয় না, তবে মেমমোভ করে। তাহলে লিবি থেকে মেমকি কে বাদ দেবেন না কেন?

— অ্যালকোট

@ অ্যালকোট: কারণ memcpyদ্রুত হতে পারে।

— বিলি ওনিল

: নির্দিষ্ট / webarchive উপরে পাসকাল Cuoq থেকে লিঙ্ক web.archive.org/web/20130722203254/http://...

— JWCS

Answer 2

এর মধ্যে থাকা স্মৃতিটি ওভারল্যাপ 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. 

মেমকপির কিছু বাস্তবায়ন এখনও ওভারল্যাপিং ইনপুটগুলির জন্য কাজ করতে পারে তবে আপনি সেই আচরণটি গণনা করতে পারবেন না। মেমোমোভকে অবশ্যই ওভারল্যাপিংয়ের অনুমতি দিতে হবে।

Comments

এটি আমাকে সত্যিই সাহায্য করেছে! আপনার তথ্যের জন্য +1

— মুথু গণপতি নাথান

Answer 3

শুধু কারণ memcpyওভারল্যাপিং অঞ্চলে মোকাবেলা করার থাকে না, তার মানে এই নয় এটি সঠিকভাবে তাদের মোকাবেলা করে না। ওভারল্যাপিং অঞ্চলগুলির সাথে কলটি নির্ধারিত আচরণ তৈরি করে। অপরিবর্তিত আচরণ সম্পূর্ণভাবে কাজ করতে পারে যেমন আপনি একটি প্ল্যাটফর্মে প্রত্যাশা করেছেন; এর অর্থ এই নয় যে এটি সঠিক বা বৈধ।

Comments

বিশেষত, প্ল্যাটফর্মের উপর নির্ভর করে, এটি memcpyঠিক একইভাবে কার্যকর করা সম্ভব memmove। অর্থাত, যে কেউ সংকলক লিখেছেন তিনি কোনও অনন্য memcpyফাংশন লেখার বিরক্ত করেননি ।

— ক্যাম

Answer 4

মেমকি এবং মেমোভ উভয়ই একই রকম কাজ করে।

তবে এক পার্থক্য দেখার বিষয়:

#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

Comments

আইএমএইচও, এই উদাহরণ প্রোগ্রামটির কিছু ত্রুটি রয়েছে, যেহেতু আরআর 1 বাফারটি সীমা ছাড়িয়ে অ্যাক্সেস করা হয় (অনুলিপি করতে 10 বাইট, বাফার আকারে 7 বাইট)। সীমার বাইরে ত্রুটি অনির্ধারিত আচরণের ফলাফল। মেমকি () / মেমমোভ () কলগুলির প্রদর্শিত ফলাফলের পার্থক্যগুলি বাস্তবায়ন নির্দিষ্ট। এবং উদাহরণস্বরূপ আউটপুটটি উপরের প্রোগ্রামটির সাথে ঠিক মেলে না ... এছাড়াও, strcpy_s () স্ট্যান্ডার্ড সি আফাইক (এমএস নির্দিষ্ট, এটিও দেখুন: stackoverflow.com/questions/36723946/… ) এর অংশ নয় - দয়া করে আমাকে সংশোধন করুন যদি আমি 'আমি ভুল.

— rel

Answer 5

"খারাপ" সংকলকের কারণে আপনার ডেমো মেম্পি ত্রুটিগুলি প্রকাশ করে নি, এটি আপনাকে ডিবাগ সংস্করণে পছন্দ করে favor একটি রিলিজ সংস্করণ, তবে আপনাকে একই আউটপুট দেয়, তবে অপ্টিমাইজেশনের কারণে।

    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 টি ওভারল্যাপযুক্ত মেমরি ব্লকগুলি অনুলিপি করার চেষ্টা করার সময় সর্বদা চয়ন করি ।

Answer 6

মধ্যে পার্থক্য 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

Comments

-1 -

— মেমমোভের

এই উদাহরণটি ধারণাটি বুঝতে সহায়তা করে না .... বেশিরভাগ সংকলক যেমন মেমো মুভ আউটপুট হিসাবে সমান হবে

— জসদীপ সিং অরোরা

@jjwchoy ধারণাগতভাবে এটি করে। বাফারটি সাধারণত অনুকূলিত হয়

— এমএম

লিনাক্স এ একই ফল।

— কোডিচান

Answer 7

যেমন ইতিমধ্যে অন্যান্য উত্তরে নির্দেশিত হয়েছে, এটি স্মৃতি ওভারল্যাপগুলির জন্য অ্যাকাউন্টগুলির memmoveচেয়ে বেশি পরিশীলিত memcpy। মেমমোভের ফলাফলটি এমনভাবে সংজ্ঞায়িত করা হয় যেন এটি srcএকটি বাফারে অনুলিপি করা হয় এবং তারপরে বাফার অনুলিপি করা হয়েছিল dst। এর অর্থ এই নয় যে প্রকৃত বাস্তবায়ন কোনও বাফার ব্যবহার করে তবে সম্ভবত কিছু পয়েন্টার গাণিতিক হয় does

Answer 8

সংকলক উদাহরণস্বরূপ মেমকিটিকে অনুকূল করতে পারে:

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

এই ম্যাকপিটি হিসাবে অনুকূলিত করা যেতে পারে: x = *(int*)some_pointer;

Comments

এই ধরনের অপ্টিমাইজেশান কেবলমাত্র আর্কিটেকচারগুলিতেই অনুমোদিত যা যা স্বাক্ষরবিহীন intঅ্যাক্সেসের অনুমতি দেয় । কিছু আর্কিটেকচারে (যেমন কর্টেক্স-এম0), intএমন ঠিকানা থেকে 32-বিট আনার চেষ্টা যা চারটির একাধিক নয় এটি ক্রাশের কারণ হতে পারে (তবে memcpyকাজ করবে)। যদি কেউ সিপিইউ ব্যবহার করে থাকে যা আন-স্বাক্ষরিত অ্যাক্সেসের অনুমতি দেয় বা প্রয়োজনীয় এমন কোনও শব্দ সহ একটি সংকলক ব্যবহার করে যা #define UNALIGNED __unalignedসংকলককে যখন প্রয়োজন হয় তখন পৃথকভাবে আনা বাইটগুলির মধ্যে পূর্ণসংখ্যা একত্রিত করতে নির্দেশ দেয়, কেউ এর মতো কিছু করতে পারে এবং তারপরে `x = * (int UNALIGNED *) ) some_pointer;

— সুপারক্যাট

কিছু প্রসেসর স্বাক্ষরবিহীন ইন অ্যাক্সেস ক্র্যাশটিকে অনুমতি দেয় না char x = "12345"; int *i; i = *(int *)(x + 1);তবে কিছু করে, কারণ তারা দোষের সময় অনুলিপিটি ঠিক করে দেয়। আমি এই জাতীয় সিস্টেমে কাজ করেছি এবং কেন পারফরম্যান্স এত দুর্বল তা বুঝতে সময় লাগল।

— ব্যবহারকারী 3431262

*(int *)some_pointerএকটি কঠোর আলিয়াজিং লঙ্ঘন, তবে আপনি সম্ভবত বোঝাতে পারেন যে সংকলকটি আউটপুট অ্যাসেমব্লিউটি বের করবে যা কোনও ইনট অনুলিপি করবে

— এমএম

Answer 9

Http://clc-wiki.net/wiki/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

তবে আপনি এখন বুঝতে পারবেন যে মেমমোভ কেন ওভারল্যাপিংয়ের বিষয়ে যত্ন নেবে।

Answer 10

সি 11 মানক খসড়া

C11 N1570 মান খসড়া বলেছেন:

7.24.2.1 "মেমকি ফাংশন":

2 মেমকি ফাংশনটি এস 2 দ্বারা নির্দেশিত বস্তুর মধ্যে এস 1 দ্বারা নির্দেশিত বস্তু থেকে n অক্ষর অনুলিপি করে। যদি অনুলিপি করা বস্তুগুলির মধ্যে অনুলিপি হয়, তবে আচরণটি সংজ্ঞায়িত।

7.24.2.2 "মেমোমোভ ফাংশন":

2 মেমমোভ ফাংশনটি এস 2 দ্বারা নির্দেশিত বস্তুর মধ্যে এস 1 দ্বারা নির্দেশিত বস্তু থেকে n অক্ষর অনুলিপি করে। অনুলিপিটি সংঘটিত হয় যেমন s2 দ্বারা নির্দেশিত বস্তু থেকে এন অক্ষরগুলি প্রথমে এন অক্ষরের অস্থায়ী অ্যারেতে অনুলিপি করা হয় যা s1 এবং s2 দ্বারা নির্দেশিত বস্তুগুলিকে ওভারল্যাপ করে না এবং তারপরে অস্থায়ী অ্যারে থেকে এন অক্ষরগুলি অনুলিপি করা হয় s1 দ্বারা নির্দেশিত বস্তু

অতএব, কোনও ওভারল্যাপ memcpyঅনির্ধারিত আচরণের দিকে পরিচালিত করে এবং যে কোনও কিছুই ঘটতে পারে: খারাপ, কিছুই বা এমনকি ভাল নয়। ভাল যদিও বিরল :-)

memmove তবে স্পষ্টতই বলেছে যে সবকিছু ঘটে যেমন একটি মধ্যবর্তী বাফার ব্যবহার করা হয়, সুতরাং স্পষ্টভাবে ওভারল্যাপগুলি ঠিক আছে।

সি ++ std::copyতবে আরও ক্ষমাশীল, এবং ওভারল্যাপগুলিকে অনুমতি দেয়: এসটিডি :: কপি হ্যান্ডেল ওভারল্যাপিং রেঞ্জগুলি কি?

Comments

memmoveএকটি অতিরিক্ত অস্থায়ী অ্যারে এন ব্যবহার করুন, সুতরাং এটি অতিরিক্ত মেমরি ব্যবহার করে? তবে কীভাবে এটি যদি আমরা কোনও স্মৃতিতে অ্যাক্সেস না দিয়ে থাকি। (এটি 2x মেমরিটি ব্যবহার করছে)।

— clmno

@ ক্লোম্নো এটি স্ট্যাক বা মালোকের জন্য বরাদ্দ করে এমন কোনও ফাংশনের মতো যা আমি আশা করব :-)

— সিরো সান্তিলি 法轮功 冠状 病 六四 事件

আমি এখানে একটি প্রশ্ন জিজ্ঞাসা করেছি , খুব ভাল উত্তর পেয়েছি। ধন্যবাদ. আপনার হ্যাকারনিউজ পোস্টটি ভাইরাল হয়ে দেখেছেন (x86 এক) :)

— clmno

Answer 11

আমি গ্রহনটি ব্যবহার করে একই প্রোগ্রাম চালানোর চেষ্টা করেছি এবং এটি memcpyএবং এর মধ্যে স্পষ্ট পার্থক্য দেখায় memmove। memcpy()মেমোরি অবস্থানের ওভারল্যাপিংয়ের বিষয়ে চিন্তা করে না যার ফলস্বরূপ ডেটা দুর্নীতি হয়, যখন memmove()অস্থায়ী পরিবর্তনশীলটিতে ডেটা অনুলিপি করে তারপরে প্রকৃত মেমরির স্থানে অনুলিপি করে।

অবস্থান থেকে ডেটা অনুলিপি str1করার সময় str1+2, আউটপুট memcpy" aaaaaa" হয় " প্রশ্নটা কেমন হবে? memcpy()বাম থেকে ডানে একবারে একটি বাইট অনুলিপি করবে। আপনার প্রোগ্রাম " 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

Comments

স্ট্যাক ওভারফ্লোতে আপনাকে স্বাগতম। শীঘ্রই সম্পর্কে পৃষ্ঠাটি পড়ুন । সম্বোধনের বিভিন্ন বিষয় রয়েছে। প্রথম এবং সর্বাগ্রে, আপনি 18 মাস বা তার আগের একাধিক উত্তর সহ একটি প্রশ্নের উত্তর যুক্ত করেছেন। সংযোজনটির পরোয়ানা দেওয়ার জন্য আপনার চমকপ্রদ নতুন তথ্য সরবরাহ করতে হবে। দ্বিতীয়ত, আপনি Eclipse নির্দিষ্ট করেছেন তবে Eclipse হ'ল একটি IDE যা একটি সি সংকলক ব্যবহার করে তবে আপনি যে প্ল্যাটফর্মটি আপনার কোডটি চালাচ্ছেন বা C সংকলক Eclipse ব্যবহার করছেন তা আপনি চিহ্নিত করতে পারবেন না। আপনি কীভাবে memmove()মধ্যবর্তী স্থানে সেই অনুলিপিগুলি নির্ধারণ করতে পারবেন তা জানতে আগ্রহী হব । এটি প্রয়োজন হলে কেবল বিপরীতে অনুলিপি করা উচিত।

— জোনাথন লেফলার

ধন্যবাদ। সংকলক সম্পর্কে, তাই আমি লিনাক্সে জিসিসি সংকলক ব্যবহার করছি। মেমোভের জন্য লিনাক্সের একটি ম্যান পেজ রয়েছে যা স্পষ্টভাবে উল্লেখ করে যে মেমোভ ডেটা ওভারল্যাপিং এড়াতে অস্থায়ী পরিবর্তনশীল ডেটা অনুলিপি করবে। এই লোক পৃষ্ঠাটির লিঙ্কটি এখানে রয়েছে linux.die.net/man/3/memmove

— প্রতীক

এটি আসলে "যেন" বলে, যার অর্থ এই নয় যে এটি আসলে ঘটে। অনুমোদিত যে এটি আসলে এটি করতে পারে (যদিও এটি থেকে অতিরিক্ত স্মৃতি পাওয়া যায় সে সম্পর্কে প্রশ্ন থাকলেও) তবে বাস্তবে এটি যদি হয় তবে আমি কিছুটা অবাক হব। যদি উত্স ঠিকানা লক্ষ্য ঠিকানার চেয়ে বেশি হয় তবে এটি শুরু থেকে শেষ পর্যন্ত অনুলিপি করতে যথেষ্ট (ফরোয়ার্ড অনুলিপি); যদি উত্স ঠিকানা লক্ষ্য ঠিকানার চেয়ে কম হয় তবে এটি প্রারম্ভ থেকে শুরু পর্যন্ত অনুলিপি করা যথেষ্ট (পিছনের অনুলিপি)। কোনও সহায়ক মেমরির প্রয়োজন বা ব্যবহৃত হয় না।

— জোনাথন লেফলার

আপনার উত্তরটি কোডে প্রকৃত ডেটা দিয়ে ব্যাখ্যা করার চেষ্টা করুন, এটি আরও সহায়ক হবে।

— HaseeB মীর