Both x and xPlus1 should be of type double*. They are pointers to an array of n doubles.

So when you do this:

memcpy(x, xPlus1, sizeof(x));

Since x is just a double*, that only copies sizeof(double*) bytes... which is to say, 8. What you want to do is:

memcpy(x, xPlus1, n * sizeof(*x));

because the type of *x is double, so n * sizeof(*x) will be the total bytes of memory that xPlus1 owns: n doubles.

You're right that in a pedantic reading of the standard, we would need to take the address of the array instead of passing buf because array-to-pointer conversion obtains a pointer to the first element. std::memcpy(buf, &obj, N); would therefore write past the end of the first char object in buf, which is not okay if it writes

into the object pointed to by s1

Another bit of broken wording in this area is that we never clearly specify that you can use an unsigned char*/char* to "navigate" the bytes of an object, and P1839R7 Accessing object representations deals with that problem. Currently, memcpy just "magically" copies the object even though the user couldn't implement that.

In general, the wording in these areas of both the C and C++ standard is pretty defective. However, this doesn't really matter in practice. std::memcpy(buf, &obj, N); is expected to work by users, compilers consider it to be valid, and disallowing it would break immeasurable amounts of code.

How to fix it

The C++ standard generally only specifies additional semantic on top of C functions like in [cstring.syn] p3; it doesn't fully redefine them.

Therefore, this wording would have to be fixed on the C side, and the process is explained at https://www.open-std.org/jtc1/sc22/wg14/www/contributing.html What we probably want to say is that memcpy copies bytes of storage from the source into the destination, and that this can access bytes not just from a single object but also from the surrounding array, if any.

f2_int_ptr() needs to become this:

void f2_int_ptr() {
    int i = 0;
    void *elements = malloc(size * sizeof(int*));

    for ( i = 0; i < size; i++ ) { 
       int *v = malloc ( sizeof(int));
       memcpy ( v, &i, sizeof ( int ));
       memcpy ( INDEX(i) , &v,  sizeof (int*));
    }

    for ( i = 0; i < size; i++ ) {
        int *v;
        memcpy ( &v, INDEX(i), sizeof(int *));
        printf ( "%d\n", *v );
    }
}

Note the subtle changes to the memcpy() arguments.

Note: I really, really, really, wouldn't write code like this! It's incredibly difficult to follow.

So the order is memcpy(destination, source, number_of_bytes).

Therefore, you can place the old data at the beginning of newarr with

memcpy(newarr, arr, 5 * sizeof *arr);
/* sizeof *arr == sizeof arr[0]  == sizeof (int) */

or at the end with

memcpy(newarr+1, arr, 5 * sizeof *arr);

Because you know the data type of arr and newarr, pointer arithmetic works. But inside memcpy it doesn't know the type, so it needs to know the number of bytes.

Another alternative is std::copy or std::copy_n.

std::copy_n(arr, 5, newarr);

For fundamental types like int, the bitwise copy done by memcpy will work fine. For actual class instances, you need to use std::copy (or copy_n) so that the class's customized assignment operator will be used.