在C中通过memcpy将矩阵复制到另一个矩阵中

Question

I want to write a function to copy a two matrices into one matrix by use of memcpy. It is like C = [A; B] in Matlab. Because, I want to use this function for all the type of data, which means integer and float matrices, I used void pointer.

the code is:

void Repmatrix(void *M3, void *M1, int R1, int C1, void *M2, int R2, int C2, size_t t)
{
    if (RC == 'R')
    {
        int i;
        for (i = 0; i < R1*C1; i++)
        {
            memcpy(M3+i, M1+i, t);

        }
        for (j = 0; j < R1*C1; j++)
        {
            memcpy(M3+i+j, M1+j, t);

        }
    }
}

Any help and suggestion is appreciated.

To clarify it the inputs are:

M1 = [
1 2
3 4]
M2 = [
5 6
7 8]

the output should be:

M3 = [
1 2
3 4
5 6
7 8]

Answer 1

First, there are some simple index errors, probably because you copy-and-pasted the loops: The second loop should use M2 , C2 and R2 .

Then, as others have pointed out, you cannot do arithmetic to void * . Void pointers are just anonymous handles. If you want to do something with them, you should cast them to pointers to a value type. (GCC seems to allow arithmetic on void * and treats them as char * for that matter; it only warns in -pedantic mode.)

Because you don't know the value type in your function, only its size, cast them to char * , because sizeof(char) == 1 . Then you can use your size t in pointer arithmetic like so:

void Repmatrix(void *M3, 
    void *M1, int R1, int C1, 
    void *M2, int R2, int C2, size_t t)
{
    char *MM1 = M1;
    char *MM2 = M2;
    char *MM3 = M3;
    int i, j;

    for (i = 0; i < R1*C1; i++) {
        memcpy(MM3 + i * t, MM1 + i * t, t);
    }

    for (j = 0; j < R2*C2; j++) {
        memcpy(MM3 + (i + j) * t, MM2 + j * t, t);
    }
}

You don't actually need the loop, because the memory in the top and bottom halves is contiguous if you store your matrix in a row-major format:

void Repmatrix(void *M3,
    void *M1, int R1, int C1,
    void *M2, int R2, int C2, size_t t)
{
    char *top = M3;
    char *btm = top + R1 * C1 * t;

    memcpy(top, M1, R1 * C1 * t);
    memcpy(btm, M2, R2 * C2 * t);
}

A more typesafe variant is to stick to double as matrix value and use double * pointers:

void Repmatrix(double *M3,
    double *M1, int R1, int C1,
    double *M2, int R2, int C2)
{
    memcpy(M3, M1, R1 * C1 * sizeof(*M3));
    memcpy(M3 + R1 * C1, M2, R2 * C2 * sizeof(*M3));
}

You'll still have to use sizeof , because memcpy works with void pointers, but you'll catch any occurrences of passing the wrong pointer type to Repmatrix .