C - Copying array in other array as output argument

You need to make sure you are passing two int pointers pointing to both arrays. In your code only one of the arguments is a pointer. The code below should make it more clear:

#include <stdio.h>

void copyArray(int * arr1, int * arr2, int size);

int main(void)
{

    int t1[] = {1,2,3,4};
    int t2[4];

    copyArray(t1, t2,4);

    for(int i = 0; i <= 3; i ++)
    {
        printf("%d - %d\n", t1[i], t2[i]);
    }

    return 0;
}


void copyArray(int * arr1, int * arr2, int size)
{

    for(int i = 0; i < size; i++)
    {
        printf("%d\n", arr1[i]);
        arr2[i] = arr1[i];
    }

    return;
}

Edit: in what you have written, a TablaArray * is a pointer to an array of 32 ints, while you need an int *

typedef int TablaArray[32]; 

is bad practice

The problem is connected with array to pointer decay and then with pointer arithmetics:

Pointer decay means that if you pass an array-object of type int x[32] as argument to a function, then it "decays" to a pointer like int *, which points to the first element of the integer array. So be aware that if you pass an int x[32]-object, it's actually passed by reference (the array is not copied) and you may alter the contents of the array in the function.

Now pointer arithmetics:

Incrementing a pointer (or accessing an array through array subscripting) implicitly does pointer arithmetics, and the number of bytes added to the initial value depends on the type of the object to which the pointer points:

typedef int Array10[10];
Array10 arr = { 1,2,3,4,5,6,7,8,9,0 };
int *x = arr; // arrayOfInts decays to a pointer; x points to the &arr[0]

x++; // in terms of bytes, x is incremented by sizeof(int) bytes
int i = x[3]; // gets the int-value on the address of x + 3*sizeof(int)

Array10 *arr10ptr = arr;
arr10ptr++; // in terms of bytes, x is incremented by sizeof(Array10) bytes, which is 10*sizeof(int)
arr10ptr[3]; // 3*sizeof(Array10), i.e. 3*10*sizeof(int)

Now it should be clear why a function parameter being declared as a pointer to an array of int[32] behaves different from a function parameter being declared as an int[32].

So you could correct your program as follows, now knowing that TablaArray t2 will be a reference to the underlying array anyway:

void copyArray(TablaArray t1, TablaArray t2, int tam){        
    for(int i = 0; i<tam; i++){
        printf("%d\n", t1[i]);
        t2[i] = t1[i];
    }
}

Hope it helps.

Compile with warnings enabled. If you used gcc -Wall -Werror, you would get the following errors:

luis.c:10:6: error: return type of ‘main’ is not ‘int’ [-Werror=main]
 void main(){
      ^~~~
luis.c: In function ‘main’:
luis.c:15:19: error: passing argument 2 of ‘copyArray’ from incompatible pointer type [-Werror=incompatible-pointer-types]
     copyArray(t1, t2,4);
                   ^~
luis.c:8:6: note: expected ‘int (*)[32]’ but argument is of type ‘int *’
 void copyArray(TablaArray, TablaArray*, int);
      ^~~~~~~~~
cc1: all warnings being treated as errors

The first one is simple, it should be int main.

The second one is a bit harder to see exactly because you used a typedef. So your prototype is now

void copyArray(int *, int (*)[32], int);

With the second value being a pointer-to-array that by itself is a construct that is not used often.

Instead, you'd just need two pointers to int here, and the size of an array should perhaps use size_t instead:

void copyArray(int *, int *, size_t);

void copyArray(int *t1, int *t2, size_t n){
    for (int i = 0; i < tam; i++) {
        t2[i] = t1[i];
    }
}

Finally, if you use a C99, C11 compiler, it could be nice to use the variable-length arrays arrays to tell that one of the parameters tell the sizes of the arrays; for that we need to reorder the parameters:

void copyArray(size_t, int[*], int[*]);

void copyArray(size_t n, int t1[n], int t2[n]) {
     ...
}

In Your Copy function you were copying the same value of T1 to T2 on the Address Of T2. you can do it with out pointers but pointers helps you to refer the Address