C อาร์เรย์หลายมิติและ array of pointers



อาร์เรย์ 2 มิติ

#include <stdio.h>

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

    printf("%d\n", grid[1][2]);        // 7 (แถว 1, คอลัมน์ 2)
    grid[0][0] = 99;

    for (int r = 0; r < 3; r++) {
        for (int c = 0; c < 4; c++) {
            printf("%3d", grid[r]);
        }
        printf("\n");
    }
    return 0;
}

int grid[3][4] = 3 แถว แถวละ 4 คอลัมน์ = 12 int ต่อกัน

จริง ๆ มันคือบล็อกเดียวต่อเนื่อง (row-major)

grid[0][0..3] , grid[1][0..3] , grid[2][0..3]   ← เรียงต่อกันในหน่วยความจำ
int (*flat)[4] = grid;            // ชนิดเดียวกับ grid — pointer ไปแถวละ 4 int
printf("%d\n", flat[1][2]);       // 7 — grid[1][2]

grid[r] แปลเป็น *(*(grid + r) + c) — บวกทีละ “แถว” (4 int) แล้วบวกทีละคอลัมน์

ทั้ง 12 int เรียงต่อกันจริง แต่ int *raw = &grid[0][0]; raw[6] เป็น undefined behavior ตามมาตรฐาน เพราะ raw ชี้ในอาร์เรย์ grid[0] ที่มีแค่ 4 ตัว — เดิน pointer ข้ามขอบ subarray ทำไม่ได้ (สอดคล้องกับบท 12) ถ้าต้องการ index ราบจริง ๆ ให้จองบล็อกเดียวตั้งแต่ต้น (ดูท้ายบท)

ส่งอาร์เรย์ 2 มิติเข้าฟังก์ชัน

ฟังก์ชันต้องรู้ จำนวนคอลัมน์ (มิติที่ 2 ขึ้นไป) เพื่อคำนวณ offset:

void print_grid(int rows, int cols, int g[][cols])   // C99 VLA parameter — ยืดหยุ่น
{
    for (int r = 0; r < rows; r++) {
        for (int c = 0; c < cols; c++) {
            printf("%3d", g[r]);
        }
        printf("\n");
    }
}

// หรือ fixed columns
void print_grid_4(int rows, int g[][4])
{
    // ...
}

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

int g[][cols] = “pointer ไปแถว (อาร์เรย์ของ cols ตัว)” — ชนิดจริงคือ int (*)[cols]

array of pointers

อาร์เรย์ที่แต่ละสมาชิกเป็น pointer — ใช้บ่อยกับสตริง:

const char *fruits[] = {"แอปเปิล", "กล้วย", "ส้ม", "องุ่น"};
size_t n = sizeof(fruits) / sizeof(fruits[0]);

for (size_t i = 0; i < n; i++) {
    printf("%zu: %s\n", i, fruits[i]);
}
fruits[0] ──► "แอปเปิล\0"
fruits[1] ──► "กล้วย\0"
fruits[2] ──► "ส้ม\0"
fruits[3] ──► "องุ่น\0"

แต่ละสตริงยาวไม่เท่ากัน — array of pointers เก็บแค่ที่อยู่ ไม่เปลืองเหมือน char fruits[4][20]

argv — array of pointers ที่คุ้นเคย

int main(int argc, char *argv[])   // argv คือ array of char*
{
    printf("ชื่อโปรแกรม: %s\n", argv[0]);
    for (int i = 1; i < argc; i++) {
        printf("argument %d: %s\n", i, argv[i]);
    }
    return 0;
}
./prog hello world 42
ชื่อโปรแกรม: ./prog
argument 1: hello
argument 2: world
argument 3: 42

argv[argc] เป็น NULL เสมอ บทที่ 24 ลงลึกเรื่อง argv

jagged array — แถวยาวไม่เท่ากันด้วย malloc

int m[3][4] ทุกแถวยาวเท่ากัน ถ้าต้องการแถวยาวต่างกัน (หรือขนาดตอนรัน) ใช้ pointer to pointer:

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

int main(void)
{
    size_t rows = 3;
    size_t lens[] = {2, 4, 3};

    int **matrix = malloc(rows * sizeof(int *));    // อาร์เรย์ของ int*
    if (!matrix) return 1;

    for (size_t r = 0; r < rows; r++) {
        matrix[r] = malloc(lens[r] * sizeof(int));  // แต่ละแถวจองเอง
        if (!matrix[r]) {
            for (size_t k = 0; k < r; k++) free(matrix[k]);   // คืนแถวที่จองไปแล้ว
            free(matrix);
            return 1;
        }
        for (size_t c = 0; c < lens[r]; c++) {
            matrix[r] = (int)(r * 10 + c);
        }
    }

    for (size_t r = 0; r < rows; r++) {
        for (size_t c = 0; c < lens[r]; c++) {
            printf("%d ", matrix[r]);
        }
        printf("\n");
    }

    // free ย้อนลำดับ: แถวก่อน แล้วตัวนอก
    for (size_t r = 0; r < rows; r++) {
        free(matrix[r]);
    }
    free(matrix);
    return 0;
}
0 1
10 11 12 13
20 21 22

int ** ต่างจาก int[3][4]

int m[3][4]int **m
หน่วยความจำบล็อกเดียว 48 ไบต์ ต่อเนื่องอาร์เรย์ pointer + แต่ละแถวแยกก้อน
m[1][2]*(base + 1*4 + 2)*(*(m + 1) + 2) — 2 ครั้ง deref
ส่งเข้าฟังก์ชันเป็นint (*)[4]int **
จองด้วยประกาศตรง ๆ / malloc(r*c*sizeof(int))malloc หลายครั้ง

อย่าสับสน — ส่ง int m[3][4] เข้าฟังก์ชันที่รับ int ** ไม่ได้ (คนละ layout)

ทางเลือกที่ดีสำหรับ matrix ขนาดตอนรัน: จองบล็อกเดียวแล้วคำนวณ index เอง:

int *m = malloc(rows * cols * sizeof(int));
#define AT(r, c) m[(r) * cols + (c)]
AT(1, 2) = 7;
free(m);

เรื่องที่คนมักพลาด

  • ส่ง 2D array เข้าฟังก์ชันโดยไม่บอกจำนวนคอลัมน์ — ฟังก์ชันคำนวณ offset ไม่ได้ ต้องเป็น int g[][cols]
  • ปนกัน int ** กับ int[][N] — คนละ layout ในหน่วยความจำ แปลงตรง ๆ ไม่ได้
  • จอง jagged array แล้ว free แค่ free(matrix) — leak ทุกแถว free แถวก่อน แล้วตัวนอก
  • ใช้ matrix/matrix[r] ก่อนเช็ค malloc — เช็คทุกครั้ง และถ้าแถวใดจองไม่ได้ ต้อง free แถวก่อนหน้าที่จองสำเร็จแล้ว
  • int *raw = &grid[0][0]; raw[6] — UB (ข้ามขอบ grid[0]) แม้หน่วยความจำต่อเนื่อง ใช้ int (*)[C] หรือบล็อกเดียว + คำนวณ index
  • char names[3][10] แต่ชื่อยาว 15 ตัว — overflow ใช้ array of pointers หรือเพิ่มขนาด
  • int m[r] เมื่อ r, c เป็นตัวแปร บน stack ขนาดใหญ่ — VLA, เสี่ยง stack overflow ใช้ malloc
  • grid[3][4] เข้าถึง grid[3][0] — แถวมี index 0-2 (off-by-one)

สรุป

  • int m[R][C] = บล็อกเดียวต่อเนื่อง row-major; m[r] ≡ *(base + r*C + c)
  • ส่งเข้าฟังก์ชัน: ต้องระบุจำนวนคอลัมน์ — void f(int rows, int cols, int g[][cols])
  • array of pointers (char *argv[], const char *words[]) — เก็บที่อยู่ เหมาะกับข้อมูลยาวไม่เท่ากัน
  • jagged array ตอนรัน: int **m — malloc ตัวนอก + แต่ละแถว, free ย้อนลำดับ
  • int ** ≠ int[][N] — คนละ layout; matrix ตอนรันแบบง่ายคือบล็อกเดียว + คำนวณ index เอง

จบเฟส pointer/memory บทถัดไปเข้าเฟส struct — วิธีรวมข้อมูลหลายชนิดเข้าเป็นก้อนเดียว