C เลือกชนิดจำนวนเต็มให้ถูก



int, long ขนาดไม่แน่นอน (บทที่ 4) — โค้ดที่ต้อง portable หรือทำงานกับ binary format ต้องเลือกชนิดให้ชัด

<stdint.h> — ชนิดขนาดแน่นอน

#include <stdint.h>

int8_t   a;    // มีเครื่องหมาย 8 บิต   (-128 .. 127)
uint8_t  b;    // ไม่มีเครื่องหมาย 8 บิต (0 .. 255)
int16_t  c;    // 16 บิต
uint16_t d;
int32_t  e;    // 32 บิต — "int จริง ๆ 32 บิตแน่นอน"
uint32_t f;
int64_t  g;    // 64 บิต
uint64_t h;

// อย่างน้อย N บิต (เร็วที่สุด / เล็กที่สุด)
int_least32_t  i;   // อย่างน้อย 32 บิต
int_fast32_t   j;   // อย่างน้อย 32 บิต, เร็วที่สุดบนเครื่องนี้

// สำหรับเก็บ pointer เป็นตัวเลข
intptr_t   p;
uintptr_t  up;

// ค่าขอบเขต
INT32_MAX, UINT8_MAX, INT64_MIN, SIZE_MAX

ใช้เมื่อ:

  • เขียน/อ่าน binary format (ไฟล์, network) — ต้องรู้ว่ากี่ไบต์
  • ทำ bit manipulation — ต้องรู้จำนวนบิต
  • ต้องรองรับค่าช่วงเฉพาะ

ไม่จำเป็นเมื่อ: ตัวนับ loop ทั่วไป, ค่าที่รู้ว่าเล็ก — int พอ

// binary file header
struct FileHeader {
    uint32_t magic;
    uint16_t version;
    uint16_t flags;
    uint64_t data_size;
};

size_t — สำหรับขนาดและ index

size_t คือ unsigned integer ที่ใหญ่พอเก็บขนาดของอ็อบเจกต์ใด ๆ (sizeof คืนชนิดนี้)

size_t len = strlen(s);
void *p = malloc(n * sizeof(int));      // n ควรเป็น size_t
for (size_t i = 0; i < len; i++) { ... }
  • คืนจาก sizeof, strlen, malloc argument
  • printf ใช้ %zu
  • เป็น unsigned — for (size_t i = n - 1; i >= 0; i--) = infinite loop (ไม่มีทาง < 0)

ptrdiff_t = signed สำหรับผลต่างของ pointer (p - q) — %td

กับดัก signed vs unsigned

1. เปรียบเทียบ signed กับ unsigned

int a = -1;
unsigned int b = 1;

if (a < b) {                  // ❌ ไม่เป็นจริง!
    printf("a < b\n");
}

เมื่อเทียบ signed กับ unsigned ขนาดเท่ากัน C แปลง signed → unsigned ก่อน -1 กลายเป็น 4294967295 ซึ่ง > 1

-Wsign-compare (มากับ -Wextra) เตือนกรณีนี้

// จุดที่เจอบ่อย
int i;
for (i = 0; i < some_size(); i++)     // some_size() คืน size_t → i ถูกแปลง unsigned

แก้: ใช้ชนิดให้ตรงกัน — size_t i เมื่อเทียบกับ size_t

2. unsigned ลบต่ำกว่า 0

size_t count = 0;
size_t result = count - 1;             // 18446744073709551615 ไม่ใช่ -1

for (size_t i = n; i-- > 0; ) {        // สำนวนวนถอยหลังปลอดภัยกับ unsigned
    process(arr[i]);                    // i จาก n-1 ถึง 0
}

3. narrowing conversion

int big = 300;
uint8_t small = big;                    // 300 % 256 = 44 (ข้อมูลหาย เงียบ ๆ)
printf("%u\n", small);                  // 44

int64_t huge = 5000000000;
int32_t truncated = huge;               // ข้อมูลหาย

-Wconversion เตือนการแปลงที่อาจเสียข้อมูล

<stdbool.h>

#include <stdbool.h>

bool is_ready = true;
bool found = false;

if (is_ready && !found) { ... }

bool คือ _Bool — เก็บ 0 หรือ 1 เท่านั้น (assign ค่าอื่นกลายเป็น 1) ใช้ให้โค้ดสื่อความหมายว่า “นี่คือ flag ไม่ใช่ตัวเลข”

char — signed หรือ unsigned?

char เป็น implementation-defined — บาง platform signed (x86) บาง unsigned (ARM บางรุ่น)

char c = 200;                          // ถ้า signed char: เป็น -56!
printf("%d\n", c);                     // -56 หรือ 200 แล้วแต่ platform

unsigned char b = 200;                 // 200 เสมอ
signed char s = -56;                   // -56 เสมอ
  • ข้อความ/สตริง — char (ธรรมดา)
  • ไบต์ดิบ / ค่า 0-255 — unsigned char
  • ตัวเลขเล็กมีเครื่องหมาย — signed char หรือ int8_t

แนวทางเลือกชนิด

งานชนิด
ตัวนับ loop, ค่าเล็กทั่วไปint
ขนาด, ความยาว, index ของอาร์เรย์/mallocsize_t
ผลต่างของ pointer/indexptrdiff_t
binary format / network / bit opsint32_t, uint8_t, ฯลฯ (<stdint.h>)
ไบต์ดิบunsigned char
flag จริง/เท็จbool
Unix timestamptime_t
เก็บ pointer เป็นตัวเลขuintptr_t (มีเมื่อ implementation รองรับ)
ค่า 0–255uint8_t / unsigned char (ไม่ใช่ int8_t)

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

  • int i เทียบกับ size_t ใน for (int i = 0; i < strlen(s); i++) — signed/unsigned mismatch (-Wsign-compare); ใช้ size_t i
  • for (size_t i = n - 1; i >= 0; i--) — infinite loop, size_t ไม่มีทาง < 0; ใช้ for (size_t i = n; i-- > 0;)
  • size_t x = a - b เมื่อ b > a — ได้ค่ามหาศาล ไม่ใช่ค่าลบ
  • char เก็บค่า > 127 — อาจเป็นค่าลบบน platform ที่ char signed; ใช้ unsigned char/uint8_t (ไม่ใช่ int8_t — ค่าสูงสุดของมันคือ 127)
  • assign int ที่เกินช่วงลง uint8_t/int16_t — ชนิด unsigned วนแบบ modulo (กำหนดไว้), ชนิด signed เป็น implementation-defined ไม่ใช่ truncate แบบตายตัว (-Wconversion เตือน)
  • ใช้ int สำหรับ file offset ใหญ่ — เกิน 2 GB overflow; ใช้ off_t/int64_t
  • unsigned เพราะ “ค่าไม่ติดลบ” แล้วเจอ bug จากการลบ/เปรียบเทียบ — หลายทีมใช้ int/signed เป็นค่าเริ่มต้น ยกเว้นจำเป็น

สรุป

  • <stdint.h>: int32_t/uint8_t/… — ขนาดแน่นอน สำหรับ binary format, bit ops, ช่วงเฉพาะ
  • size_t (unsigned) สำหรับขนาด/index/malloc — %zu, ระวังลบต่ำกว่า 0 และ loop ถอยหลัง
  • ptrdiff_t (signed) สำหรับผลต่าง pointer — %td
  • อย่าเทียบ signed กับ unsigned — signed ถูกแปลงเป็น unsigned (-1 → ค่ามหาศาล); -Wsign-compare
  • char อาจ signed หรือ unsigned — ไบต์ดิบใช้ unsigned char
  • <stdbool.h>: bool/true/false สำหรับ flag
  • ค่าเริ่มต้น: int ทั่วไป, size_t สำหรับขนาด — unsigned เมื่อจำเป็นจริง ๆ

บทถัดไปว่าด้วยการเขียนโค้ดที่ปลอดภัยจากการโจมตี — buffer overflow, format string bug, integer overflow ก่อน malloc