In your 'p' method, you're assigning pointer b to be pointer a, or, in otherwords, you're making b point to what a points to. Any changes to b will cause changes to a since they both wind up pointing to the same block of memory.

Use memcpy to copy blocks of memory. It would look something like this:

#include <string.h>
#include <stdlib.h>
void p(int *a){
   int *b = (int*)malloc(sizeof(int)*4);
   memcpy(b, a, sizeof(int)*4);

    //make changes to b.
   b[0] = 6;
   b[1] = 7;
   b[2] = 8;
   b[3] = 9;
}

int main(int argc, char **argv)
{
    int *a = (int*)malloc(sizeof(int)*4);

    // add values to a
    a[0] = 1;
    a[1] = 2;
    a[2] = 3;
    a[3] = 4;

    p(a);

return 0;
}

Your implementation of mystrcpy2 does not copy anything. In fact, it does nothing at all. When you execute dest = src, you are copying the memory location pointed to by the src variable, not the data at that location. To actually copy the data, you need to deference the pointer, using '*'. So you would do

*dest = *src;

This copies the data from src to dest. But it only copies one character. You need to increment src and dest and then do this again to copy the next character, and you need to keep doing this until you hit the string terminator i.e. until *src == 0. Here's the full implementation.

void mystrcpy2(char *dest, char *src)
{
    while (*src != 0) {
        *dest = *src;
        dest++;
        src++;
    }
    // don't forget to add a terminator
    // to the copied string
    *dest = 0;
}

And here's the exact same thing in a shorter version.

void mystrcpy2(char *dest, char *src)
{
    while (*(dest++) = *(src++));
}

Using memcpy is probably the easiest way to accomplish what you want:

memcpy(x, Temp, m * sizeof*Temp);
memcpy(y, &Temp[m], n * sizeof*Temp);

To print the values, just use printf:

puts("Values in x:");
for(int i = 0; i < m; ++i) {
      printf("%d\n", x[i]); 
}

puts("Values in y:");
for(int i = 0; i < n; ++i) {
      printf("%d\n", y[i]);
}

Here you are

int * arrCopy( const int *a, size_t n )
{
    int *b = malloc( n * sizeof( int ) );

    for ( size_t i = 0; i < n; i++ )
    {
        *( b + i ) = *( a + i );
    }

    return b;
}

Or you could check whether the memory was successfully allocated.

int * arrCopy( const int *a, size_t n )
{
    int *b = malloc( n * sizeof( int ) );

    if ( b != NULL )
    {
        for ( size_t i = 0; i < n; i++ )
        {
            *( b + i ) = *( a + i );
        }
    }

    return b;
}

Here is a demonstrative program

#include <stdio.h>
#include <stdlib.h>

int * arrCopy( const int *a, size_t n )
{
    int *b = malloc( n * sizeof( int ) );

    if ( b != NULL )
    {
        for ( size_t i = 0; i < n; i++ )
        {
            *( b + i ) = *( a + i );
        }
    }           

    return b;
}

int main(void) 
{
    int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    const size_t N = sizeof( a ) / sizeof( *a );

    int *b = arrCopy( a, N );

    if ( b != NULL )
    {
        for ( size_t i = 0; i < N; i++ )
        {
            printf( "%d ", b[i] );
        }

        putchar( '\n' );
    }

    free( b );

    return 0;
}

Its output is

0 1 2 3 4 5 6 7 8 9

As for your code then for example this expression

*(b+(sizeof(int)*i))

is invalid. It selects the element of the array b equivalent to

b[sizeof(int)*i]

So for example when i is equal to 1 and sizeof( int ) equal to 4 then instead of getting the element b[1] you are getting the element b[4].

From the C Standard (6.5.2.1 Array subscripting)

2 A postfix expression followed by an expression in square brackets [] is a subscripted designation of an element of an array object. The definition of the subscript operator [] is that E1[E2] is identical to (*((E1)+(E2))). Because of the conversion rules that apply to the binary + operator, if E1 is an array object (equivalently, a pointer to the initial element of an array object) and E2 is an integer, E1[E2] designates the E2-th element of E1 (counting from zero).

we simply use the strcpy function to copy the array into the pointer.

     char str[] = "Hello World";
     char *result = (char *)malloc(strlen(str)+1);
     strcpy(result,str);