调用 memcpy 并将 num 设置为比需要更多的字节

Question

consider the following C code:

#define SIZE_A // >= SIZE_B
#define SIZE_B 
#define SOME_SIZE // > SIZE_B

int main() {
    int a[SIZE_A];
    int b[SIZE_B] = {0};
    memcpy(a, b, sizeof(int)*(SOME_SIZE));
    return 0;
}

assume that SIZE_A, SIZE_B are some integers and SOME_SIZE > SIZE_B and SIZE_A>=SIZE_B. what would be the consequences if:

a. SOME_SIZE < SIZE_A
b. SOME_SIZE = SIZE_A
c. SOME_SIZE > SIZE_A

I tried to run it with some values but didn't understand if there is any constancy. Thanks

Answer 1

In your case (since you are copying from and to start addresses of a and b ), it must hold that SOME_SIZE <= SIZE_A AND SOME_SIZE <= SIZE_B otherwise it is undefined behaviour .

In simple terms the number of bytes you copy from source to destination, should never be more than available bytes starting from the source and destination addresses which you specify to memcpy . For example, if in your case you were to copy from middle of array b , you would have to narrow down the bound for SOME_SIZE even more - as starting from middle of b there are even fewer bytes available than SIZE_B .

Answer 2

You should only copy from a zone you have declared to a zone you have declared. That means that as soon as SOME_SIZE > SIZE_B you invoke Undefined Behaviour.

Now what could happen on common implementations:

ab) SOME_SIZE <= SIZE_A : provided you hit no segment limit, that mean trying to read from non readable memory, you will just copy garbage to the end of a after the content of b - but if you fall in non readable memory you will get a memory violation signal.

c) SOME_SIZE > SIZE_A : in addition to the problems of reading undefined memory, you write it somewhere you do not know . Very bad things are likely to happen here:

• you could overwrite over variables
• you could smash return addresses in the stack
• you could try to access non writable memory and get a memory violation signal

TL/DR: as it is essentially Undefined Behaviour, what will happen is just, hmm, undefined

Answer 3

You are copying data from after the b variable which in this case, will be random stack contents. You won't see any constancy because it is undefined. The good news (or bad news, depending upon how you look at it) is that it does has not crashed so far. If your SOME_SIZE was HUGE then I think you could get a crash on some platforms.