C語言矩陣轉置：指標算術與函數參數傳遞深度解析

編輯：關於C語言

矩陣轉置是線性代數基本運算，C 語言透過指標算術實現高效記憶體存取。本文完整實作 3×4 矩陣轉置為 4×3，深度解析二維陣列指標參數傳遞、記憶體佈局與快取優化技巧。

完整程式碼實作


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

#define ROWS_A 3
#define COLS_A 4
#define ROWS_B 4
#define COLS_B 3

// 函數宣告：指向固定列數陣列的指標
void input_matrix(int (*mat)[COLS_A], int rows, int cols);
void output_matrix(int (*mat)[COLS_B], int rows, int cols);
void transpose(int (*src)[COLS_A], int (*dst)[COLS_B]);

int main() {
    int a[ROWS_A][COLS_A];
    int b[ROWS_B][COLS_B];
    
    printf("請輸入 %d×%d 矩陣元素:\n", ROWS_A, COLS_A);
    input_matrix(a, ROWS_A, COLS_A);
    
    printf("原矩陣 A[%d][%d]:\n", ROWS_A, COLS_A);
    output_matrix(a, ROWS_A, COLS_A);
    
    transpose(a, b);
    
    printf("轉置矩陣 B[%d][%d]:\n", ROWS_B, COLS_B);
    output_matrix(b, ROWS_B, COLS_B);
    
    return 0;
}

void input_matrix(int (*mat)[COLS_A], int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            scanf("%d", &mat[i][j]);  // 等價於 *(*(mat+i)+j)
        }
    }
}

void output_matrix(int (*mat)[COLS_B], int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d\t", mat[i][j]);
        }
        printf("\n");
    }
}

void transpose(int (*src)[COLS_A], int (*dst)[COLS_B]) {
    for (int i = 0; i < ROWS_B; i++) {      // 目的矩陣列數 = 來源矩陣行數
        for (int j = 0; j < COLS_B; j++) {  // 目的矩陣行數 = 來源矩陣列數
            dst[i][j] = src[j][i];          // 核心轉置邏輯：行列互換
        }
    }
}

指標參數深度解析

參數型別對應關係

實際陣列	型別	函數參數宣告	說明
int a[3][4]	int (*)[4]	int (*mat)[4]	指向含 4 個 int 陣列的指標
int b[4][3]	int (*)[3]	int (*mat)[3]	指向含 3 個 int 陣列的指標

指標算術等價關係


// 以下四種寫法完全等價：
mat[i][j]
*(*(mat + i) + j)
*(mat[i] + j)
*((int*)mat + i*COLS + j)  // 單一指標扁平化存取

記憶體佈局與快取效能

行優先存儲

C 語言二維陣列按行連續儲存：a[0][0], a[0][1]... a[0][3], a[1][0]...

轉置存取模式分析

讀取 src：src[j][i] — 列優先存取，**快取未命中率高** (步長 COLS_A×sizeof(int))
寫入 dst：dst[i][j] — 行優先存取，**快取友好**

分塊轉置優化 (Cache Blocking)


#define BLOCK_SIZE 32

void transpose_blocked(int (*src)[COLS_A], int (*dst)[COLS_B]) {
    for (int i = 0; i < ROWS_B; i += BLOCK_SIZE) {
        for (int j = 0; j < COLS_B; j += BLOCK_SIZE) {
            int i_max = (i + BLOCK_SIZE < ROWS_B) ? i + BLOCK_SIZE : ROWS_B;
            int j_max = (j + BLOCK_SIZE < COLS_B) ? j + BLOCK_SIZE : COLS_B;
            for (int ii = i; ii < i_max; ii++) {
                for (int jj = j; jj < j_max; jj++) {
                    dst[ii][jj] = src[jj][ii];
                }
            }
        }
    }
}

動態分配矩陣轉置


// 扁平化一維陣列模擬二維 (單一 malloc，快取更好)
int* allocate_matrix(int rows, int cols) {
    return (int*)malloc(rows * cols * sizeof(int));
}

void transpose_flat(int *src, int *dst, int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            dst[j * rows + i] = src[i * cols + j];
        }
    }
}

// 存取宏
#define AT(mat, i, j, cols) ((mat)[(i)*(cols) + (j)])

方陣原地轉置

N×N 方陣可不需額外空間：


void transpose_inplace(int (*mat)[N], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {  // 只交換上三角
            int tmp = mat[i][j];
            mat[i][j] = mat[j][i];
            mat[j][i] = tmp;
        }
    }
}

進階應用：SIMD 向量化轉置


// x86 SSE/AVX 向量化轉置 4×4 float 區塊
#include <immintrin.h>

void transpose_4x4_sse(float *src, float *dst, int lds, int ldd) {
    __m128 row0 = _mm_load_ps(src + 0*lds);
    __m128 row1 = _mm_load_ps(src + 1*lds);
    __m128 row2 = _mm_load_ps(src + 2*lds);
    __m128 row3 = _mm_load_ps(src + 3*lds);
    
    _MM_TRANSPOSE4_PS(row0, row1, row2, row3);
    
    _mm_store_ps(dst + 0*ldd, row0);
    _mm_store_ps(dst + 1*ldd, row1);
    _mm_store_ps(dst + 2*ldd, row2);
    _mm_store_ps(dst + 3*ldd, row3);
}