Cộng và trừ ma trận

C[i][j] = A[i][j] + B[i][j]      /* cộng */
C[i][j] = A[i][j] - B[i][j]      /* trừ */

enum { COT = 4 };

void cong_ma_tran(const int a[][COT], const int b[][COT],
                  int kq[][COT], size_t hang)
{
    for (size_t i = 0; i < hang; ++i)
        for (size_t j = 0; j < COT; ++j)
            kq[i][j] = a[i][j] + b[i][j];
}

void tru_ma_tran(const int a[][COT], const int b[][COT],
                 int kq[][COT], size_t hang)
{
    for (size_t i = 0; i < hang; ++i)
        for (size_t j = 0; j < COT; ++j)
            kq[i][j] = a[i][j] - b[i][j];
}

int a[3][4], b[3][4], c[3][4];
int d[3][5];

cong_ma_tran(a, b, c, 3);      /* đúng */
cong_ma_tran(a, d, c, 3);      /* lỗi biên dịch: số cột khác nhau */
cong_ma_tran(a, b, c, 10);     /* biên dịch sạch, chạy tràn bộ nhớ */

/* Trả về 0 nếu ổn, âm một nếu tham số vô lý. */
int cong_ma_tran(const int *a, const int *b, int *kq,
                 size_t hang, size_t cot)
{
    if (a == NULL || b == NULL || kq == NULL) return -1;
    if (hang == 0 || cot == 0)                return -1;

    for (size_t i = 0; i < hang; ++i)
        for (size_t j = 0; j < cot; ++j) {
            size_t k = i * cot + j;

            kq[k] = a[k] + b[k];
        }

    return 0;
}

/* Hai vòng lặp */
for (size_t i = 0; i < hang; ++i)
    for (size_t j = 0; j < cot; ++j)
        kq[i * cot + j] = a[i * cot + j] + b[i * cot + j];

/* Một vòng lặp, cho ra kết quả giống hệt */
size_t n = hang * cot;

for (size_t k = 0; k < n; ++k)
    kq[k] = a[k] + b[k];

void nhan_so(const int *a, int he_so, int *kq, size_t n)
{
    for (size_t k = 0; k < n; ++k)
        kq[k] = a[k] * he_so;
}

/* Hàm nhận một con trỏ hàm hai ngôi và áp dụng nó lên từng cặp phần tử. */
void ap_dung(const int *a, const int *b, int *kq, size_t n,
             int (*phep)(int, int))
{
    for (size_t k = 0; k < n; ++k)
        kq[k] = phep(a[k], b[k]);
}

static int cong(int x, int y)    { return x + y; }
static int tru(int x, int y)     { return x - y; }
static int nhan(int x, int y)    { return x * y; }
static int lon_hon(int x, int y) { return x > y ? x : y; }

ap_dung(&a[0][0], &b[0][0], &kq[0][0], 12, cong);
ap_dung(&a[0][0], &b[0][0], &kq[0][0], 12, lon_hon);

typedef struct {
    size_t hang, cot;
    int    gia_tri;
} O;

/* Ma trận thưa là một mảng O đã sắp theo hàng rồi theo cột.
   Phép cộng khi đó là phép trộn hai danh sách đã sắp, giống bước trộn
   của sắp xếp trộn ở Chương 27. */
size_t cong_thua(const O *a, size_t na, const O *b, size_t nb,
                 O *kq, size_t co);