Chances are you mean < instead of <= in your for loops.

Using integer for accumulation of doubles is a bad idea: Replace:

Copyint sum = 0;

with

Copydouble sum = 0;

Another issue is indexing the C array. It should be:

CopyC[j + i * k] = ...

For every increment of i by 1, the j is incremented k times.

Here is a fixed version with a Minimal, Complete, and Verifiable example, which you should have posted.

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

void multiply(int *a, int row1, int col1, int *b, int row2, int col2) 
{
    assert(col1 == row2);

    int size = row1*col2;
#ifdef _MSC_VER
    int *d = malloc(size * sizeof *d);
#else
    int d[size];
#endif
    for (int i = 0; i < row1; i++) {
        for (int j = 0; j < col2; j++) {
            int sum = 0;
            for (int k = 0; k < col1; k++)
                sum = sum + a[i * col1 + k] * b[k * col2 + j];
            d[i * col2 + j] = sum;
        }
    }

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

#ifdef _MSC_VER
    free(d);
#endif
}

int main(void)
{
    int a[] = {
        1, 2, 3,
        4, 5, 6,
    };
    int b[] = {
        7, 10,
        8, 11,
        9, 12,
    };

    multiply(a, 2, 3, b, 3, 2);
}

Apart having a solution for avoiding VLAs, the mistake was in the inner loop which should run up to col1 or row2, not col2.

By the way: I'd avoid passing col1 and row2. These should be the same. I substituted a[] and b[] with *a and *b, which is closer to the real thing (my opinion). Moreover you should avoid mixing computation and printing. Have your function return a new matrix and another function to print matrices. Finally, use a struct to keep the data pointer, rows and cols together.

No. Let's first look at it as two dimensional arrays, so we know what we're talking about:

int i[4][4];
int j[4][4];
int k[4][4];

for (int x = 0; x < 4; x++) { // row number of output
    for (int y = 0; y < 4; y++) { // column number of output
        k[x][y] = 0;
        for (int z = 0; z < 4; z++) { // four elements are added for this output
            k[x][y] += i[x][z] * j[z][y];
        }
    }
}

Important difference!!! We start at 0 for the indices!

Now I'll convert it to int[16]s for you assuming that i[1] is the second element of the first row:

int i[16];
int j[16];
int k[16];

for (int x = 0; x < 4; x++) { // row number of output
    for (int y = 0; y < 4; y++) { // column number of output
        k[4*x+y] = 0;
        for (int z = 0; z < 4; z++) { // four elements are added for this output
            k[4*x+y] += i[4*x+z] * j[4*z+y];
        }
    }
}

This is equivalent to your code except for the fact that you start at 1 instead of zero.

Lets start with two arrays:

>>> a
array([0, 1, 2, 3, 4])
>>> b
array([5, 6, 7])

Transposing either array does not work because it is only 1D- there is nothing to transpose, instead you need to add a new axis:

>>> b.T
array([5, 6, 7])
>>> b[:,None]
array([[5],
       [6],
       [7]])

To get the dot product to work as shown you would have to do something convoluted:

>>> np.dot(a[:,None],b[None,:])
array([[ 0,  0,  0],
       [ 5,  6,  7],
       [10, 12, 14],
       [15, 18, 21],
       [20, 24, 28]])

You can rely on broadcasting instead of dot:

a[:,None]*b

Or you can simply use outer:

np.outer(a,b)

All three options return the same result.

You might also be interested in something like this so that each vector is always a 2D array:

np.dot(np.atleast_2d(a).T, np.atleast_2d(b))