C ส่งค่ากลับผ่าน pointer



C ส่ง argument แบบ pass by value เสมอ แต่ถ้าส่ง ที่อยู่ ของตัวแปรไป ฟังก์ชันก็แก้ตัวแปรนั้นได้ — จำลอง “pass by reference”

swap — ตัวอย่างคลาสสิก

#include <stdio.h>

void swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main(void)
{
    int x = 3, y = 7;
    swap(&x, &y);              // ส่งที่อยู่
    printf("%d %d\n", x, y);   // 7 3
    return 0;
}

ถ้า swap รับ int a, int b (ไม่ใช่ pointer) มันจะสลับแค่สำเนา — x, y ไม่เปลี่ยน

out-parameter — คืนค่าเพิ่มผ่าน pointer

ฟังก์ชัน C คืนได้ค่าเดียว ถ้าอยากคืนหลายค่า ใช้ pointer parameter:

#include <stdio.h>
#include <limits.h>

// คืน 0 = สำเร็จ, -1 = error; ผลลัพธ์ผ่าน *quotient และ *remainder
int divide(int a, int b, int *quotient, int *remainder)
{
    if (b == 0) {
        return -1;
    }
    if (a == INT_MIN && b == -1) {
        return -1;              // INT_MIN / -1 ล้นช่วง int → UB
    }
    *quotient = a / b;
    *remainder = a % b;
    return 0;
}

int main(void)
{
    int q, r;
    if (divide(17, 5, &q, &r) == 0) {
        printf("17 / 5 = %d เศษ %d\n", q, r);   // 3 เศษ 2
    }
    return 0;
}

รูปแบบที่พบบ่อยใน C: return value บอกสถานะ (สำเร็จ/error), ผลลัพธ์จริงส่งกลับผ่าน out-parameter

// strtol ก็ทำแบบนี้ — คืนค่าที่แปลงได้ + เขียนตำแหน่งที่หยุดลง endptr
long v = strtol("42abc", &endptr, 10);

min/max พร้อมกัน

// ผู้เรียกต้องรับประกัน n > 0 (ฟังก์ชันอ่าน arr[0] เป็นค่าเริ่มต้น)
void min_max(const int *arr, size_t n, int *out_min, int *out_max)
{
    int mn = arr[0], mx = arr[0];
    for (size_t i = 1; i < n; i++) {
        if (arr[i] < mn) mn = arr[i];
        if (arr[i] > mx) mx = arr[i];
    }
    *out_min = mn;
    *out_max = mx;
}

int main(void)
{
    int data[] = {4, 9, 1, 7, 3};
    int lo, hi;
    min_max(data, 5, &lo, &hi);
    printf("ต่ำสุด %d สูงสุด %d\n", lo, hi);   // 1, 9
    return 0;
}

const pointer parameter — “ฉันแค่อ่าน”

size_t count_char(const char *s, char target)   // const = ฟังก์ชันนี้ไม่แก้ s
{
    size_t count = 0;
    while (*s) {
        if (*s == target) count++;
        s++;                  // เลื่อน pointer (สำเนา) ได้ — แต่แก้ *s ไม่ได้
    }
    return count;
}

ใส่ const กับ pointer parameter ที่ฟังก์ชันแค่อ่าน:

  • บอกผู้เรียกว่า “ข้อมูลของคุณปลอดภัย ฉันไม่แตะ”
  • คอมไพเลอร์จับได้ถ้าเผลอเขียน
  • ส่ง const char * (เช่น string literal) เข้าได้

เห็นแทบทุก API มาตรฐาน — strlen(const char *), strcmp(const char *, const char *), memcpy(void *dest, const void *src, ...)

(*p)++ vs *p++

int x = 5;
int *p = &x;
(*p)++;              // เพิ่มค่าที่ p ชี้ → x กลายเป็น 6

int arr[3] = {10, 20, 30};
int *q = arr;
int first = *q++;    // *(q++): อ่านค่าที่ q เดิมชี้ (arr[0] = 10) ใส่ first แล้ว q เลื่อนไป arr[1]
printf("%d %d\n", first, *q);   // 10 20

++ (postfix) มีลำดับสูงกว่า * — *q++ คือ *(q++) (เลื่อน pointer, ค่าที่ได้คือของตำแหน่งเดิม) ต้องใส่วงเล็บ (*p)++ เมื่อจะเพิ่ม “ค่า” ที่ชี้อยู่

pointer ไป pointer

ถ้าฟังก์ชันต้องแก้ ตัว pointer เอง ของผู้เรียก (เช่นให้ชี้ที่ใหม่, ให้เป็น NULL หลัง free) ต้องส่ง pointer ไป pointer:

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

// คืน 0 = ok, -1 = หน่วยความจำไม่พอ (ไม่แตะ *out เมื่อพลาด)
int alloc_and_fill(int **out, size_t n)
{
    int *arr = malloc(n * sizeof(int));      // (บทที่ 14)
    if (!arr) {
        return -1;
    }
    for (size_t i = 0; i < n; i++) arr[i] = (int)i * 10;
    *out = arr;               // เขียนที่อยู่ใหม่กลับไปที่ pointer ของผู้เรียก
    return 0;
}

int main(void)
{
    int *data = NULL;
    if (alloc_and_fill(&data, 4) != 0) {   // ส่งที่อยู่ของ pointer data
        return 1;
    }
    printf("%d %d\n", data[0], data[3]);   // 0 30
    free(data);
    return 0;
}

int **out — “pointer ไป (pointer ไป int)” *out = arr เขียนค่า pointer ใหม่ลงในตัวแปร data ของ main

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

  • ส่งตัวแปรตรง ๆ เข้าฟังก์ชันที่รับ pointer — swap(x, y) แทน swap(&x, &y) — compile error หรือ (ถ้าชนิดพอเข้ากันได้) UB
  • *p++ แทน (*p)++ — เลื่อน pointer แทนเพิ่มค่า
  • ลืมเขียนผลลัพธ์ลง out-parameter บางเส้นทาง — if (b==0) return -1; แล้ว *quotient ยังเป็นขยะ ผู้เรียกต้องเช็ค return ก่อนใช้
  • ไม่ใส่ const กับ pointer parameter ที่แค่อ่าน — ผู้เรียกไม่มั่นใจ และส่ง const data เข้าไม่ได้
  • int ** งง — อ่านทีละชั้น: *out คือ pointer ของผู้เรียก, **out คือค่า int
  • ส่ง &arr[0] แล้วฟังก์ชันเขียนเกินขนาด — ยังต้องส่งขนาดและฟังก์ชันต้องเคารพ
  • alloc_and_fill เขียนลง arr ก่อนเช็ค malloc — คืนสถานะ/-1 และไม่แตะ *out เมื่อจองไม่ได้
  • min_max/divide ไม่ระบุ domain — min_max ต้อง n > 0; divide ต้องกัน b == 0 และ INT_MIN / -1

สรุป

  • ส่ง &x เข้าฟังก์ชันที่รับ int * → ฟังก์ชันแก้ x ได้ (swap, increment)
  • out-parameter: return value = สถานะ, ผลจริงเขียนผ่าน *out — เช็ค return ก่อนอ่าน out
  • const T *p ในพารามิเตอร์ = ฟังก์ชันแค่อ่าน (ใส่เสมอเมื่อเป็นเช่นนั้น)
  • (*p)++ เพิ่มค่า, *p++ เลื่อน pointer — วงเล็บสำคัญ
  • T ** เมื่อต้องแก้ตัว pointer ของผู้เรียกเอง (คืน buffer ที่ malloc, ตั้ง NULL)

บทถัดไปว่าด้วย malloc และ heap — การจองหน่วยความจำเองตอนรัน และความรับผิดชอบในการ free