Bài 32.224 phút đọc

const là hợp đồng

Sau bài này bạn sẽ làm được

Đặt const đúng chỗ cho con trỏ và cho thứ nó trỏ tới
Giải thích vì sao ép bỏ const rồi ghi là hành vi không xác định
Dùng const cho tham số hàm để nói rõ hợp đồng
Kết hợp const với volatile cho thanh ghi chỉ đọc

constnói hai điều với hai người khác nhau: với trình biên dịch là "hãy chặn tôi nếu tôi ghi vào đây", và với người đọc là "hàm này không sửa dữ liệu của bạn". Nó không nói với hệ điều hành rằng vùng nhớ này chỉ đọc.

#Bốn dạng khai báo

const int x = 5;              /* hang so */

const char *p;                /* con tro toi const char:
                                 KHONG sua duoc *p, sua duoc p */

char *const q = bo_dem;       /* con tro const toi char:
                                 sua duoc *q, KHONG sua duoc q */

const char *const r = ten;    /* ca hai deu khong sua duoc */

Khai báo	Sửa được *p	Sửa được p	Dùng khi
char *p;	Được	Được	Bộ đệm bạn sở hữu và sửa
const char *p;	Không	Được	Tham số chỉ đọc. Trường hợp thường gặp nhất
char *const p;	Được	Không	Con trỏ tới thanh ghi cố định, hoặc biến cục bộ không muốn gán lại
const char *const p;	Không	Không	Bảng tra chỉ đọc

Quy tắc đọc: const áp dụng cho thứ bên trái nó

const char *p;     /* khong co gi ben trai const
                      -> ap dung cho char
                      -> "con tro toi const char" */

char const *p;     /* GIONG HET dong tren */

char *const p;     /* ben trai const la dau sao
                      -> ap dung cho con tro
                      -> "con tro const toi char" */

/* Meo doc nhanh: doc TU PHAI SANG TRAI.

   char * const p   ->  p la const, tro toi char
   const char * p   ->  p la con tro, toi char const

   Cung quy tac voi volatile, xem Bai 32.1. */

Mảng const và con trỏ hằng số không giống nhau

const int a[5] = { 1, 2, 3, 4, 5 };

a[0] = 9;             /* error: assignment of read-only location */

int *p = a;           /* warning: initialization discards 'const' qualifier */

const int *q = a;     /* dung */

/* Mang khong bao gio "gan lai" duoc, nen "int *const a" va
   "int a[]" giong nhau ve mat do. Khac biet chi nam o *a. */

/* Bang tra chi doc, mau chuan: */
static const char *const TEN_THU[] = {
    "Chu nhat", "Thu hai", "Thu ba", "Thu tu",
    "Thu nam", "Thu sau", "Thu bay",
};

/* HAI chu const:
     con tro trong mang la const  -> khong tro sang chuoi khac duoc
     chuoi la const               -> khong sua noi dung chuoi duoc

   Bo mot chu la mat mot nua bao ve. */

#const là hợp đồng, không phải khóa

co.c

#include <stdio.h>

int main(void) {
    const int x = 5;

    int *p = (int *)&x;      /* ep bo const: hop le ve CU PHAP */

    *p = 10;                 /* HANH VI KHONG XAC DINH */

    printf("x  = %d\n", x);
    printf("*p = %d\n", *p);
    printf("&x = %p, p = %p\n", (void *)&x, (void *)p);

    return 0;
}

terminal

gcc -std=c11 -O2 -o co co.c && ./co

x  = 5
*p = 10
&x = 000000000061FE4C, p = 000000000061FE4C

gcc -std=c11 -O0 -o co co.c && ./co

x  = 10
*p = 10
&x = 000000000061FE44, p = 000000000061FE44

Cùng một địa chỉ, hai giá trị khác nhau

Ở -O2, x in ra 5 còn *p in ra 10, và hai dòng cuối xác nhận chúng là cùng một địa chỉ. Trình biên dịch đã thay x bằng hằng số 5 ngay lúc dịch, vì nó tin vào lời hứa const.

/* Day khong phai "trinh bien dich lam sai". Ban da hua rang
   x khong doi, roi ban pha loi hua. Chuan goi do la
   HANH VI KHONG XAC DINH, va moi ket qua deu hop le:

     - in 5 va 10 nhu tren
     - in 10 va 10 nhu o -O0
     - chuong trinh sap, neu x nam trong vung chi doc

   Truong hop thu ba xay ra that voi bien const o pham vi tep: */

const int g = 5;

int main(void) {
    *(int *)&g = 10;      /* Segmentation fault: g nam trong .rodata */
}

const ở phạm vi tệp nằm trong vùng chỉ đọc, const trong hàm thì không

terminal

gcc -O2 -c const.c && nm const.o

0000000000000000 R g_const
0000000000000000 D g_thuong
0000000000000004 B g_khong_dau

const int g = 5;         /* -> phan doan .rodata, chu R trong nm.
                            He dieu hanh danh dau trang nho do chi doc,
                            nen ghi vao la loi phan doan THAT. */

void f(void) {
    const int x = 5;     /* -> ngan xep, khong co bao ve phan cung.
                            Ghi vao chi la UB, khong sap ngay. */
}

/* Do la ly do vi du o tren cho ra ket qua la thay vi sap:
   x nam tren ngan xep. Bai 20.3 da gioi thieu cach doc nm. */

Ba chỗ ép bỏ const là chính đáng, và chỉ ba chỗ đó

/* 1. API cu khong co const, va ban BIET no khong sua */
extern int ham_cu(char *s);          /* thu vien 1990, khong co const */

int f(const char *s) {
    return ham_cu((char *)s);        /* chap nhan duoc, kem chu thich */
}

/* 2. Ham tra ve con tro vao chinh doi so, kieu strchr */
char *strchr(const char *s, int c);

/* Chuan phai lam vay vi C khong co nap chong ham.
   C++ co hai ban: const va khong const. */

/* 3. Bo dem nho trong mot doi tuong logic khong doi */
typedef struct {
    const char *duong_dan;
    char       *bo_dem_nho;          /* khong const: no la chi tiet cai dat */
    int         da_nho;
} Tep;

/* MOI truong hop khac deu la dau hieu thiet ke sai.
   Neu ban thay minh viet (int *)&x thi hay hoi lai vi sao
   bien do lai la const ngay tu dau. */

#const trong tham số hàm

Không có const

size_t do_dai(char *s);
int    so_sanh(char *a, char *b);
void   in(SinhVien *sv);

/* Doc nguyen mau khong biet ham co sua du lieu cua ban khong.
   Phai doc than ham, va phai doc lai moi lan no thay doi. */

const cho mọi tham số chỉ đọc

size_t do_dai(const char *s);
int    so_sanh(const char *a, const char *b);
void   in(const SinhVien *sv);

/* Doc nguyen mau la biet ngay: ba ham nay khong sua gi ca. */

Ba thứ const trong tham số mang lại

Tài liệu tự động. Nguyên mẫu nói hết, không phải đọc thân hàm.
Bắt lỗi. Nếu bạn vô tình ghi vào đó, trình biên dịch báo ngay.
Nhận được con trỏ const. Không có const thì người gọi có một const char * sẽ không truyền vào được.

const char *ten = "abc";

do_dai(ten);         /* voi "char *s": warning: passing argument 1
                        discards 'const' qualifier

                        Nguoi goi buoc phai ep kieu, va do la
                        mot lan ep kieu KHONG CAN THIET ma ban ep
                        len ho. */

const trên tham số truyền theo giá trị là vô nghĩa trong nguyên mẫu

void f(const int x);      /* const KHONG phai mot phan cua kieu ham */
void f(int x);            /* GIONG HET dong tren voi trinh lien ket */

/* x la ban sao, nen nguoi goi khong quan tam ban co sua no khong.

   Nhung trong DINH NGHIA thi no van co ich: */

void f(const int x) {
    x = 5;                /* error: assignment of read-only parameter */
}

/* Quy uoc pho bien:
     - nguyen mau (.h): KHONG viet const cho tham so gia tri
     - dinh nghia (.c): viet neu ban muon trinh bien dich giu ho

   Voi tham so CON TRO thi khac han: "const char *s" la mot phan
   cua hop dong, va phai co trong ca nguyen mau. */

Quy tắc đặt const cho mọi loại tham số

/* Doc, khong sua */
size_t sv_dem(const SinhVien *ds, size_t n);

/* Sua noi dung, khong doi con tro */
void sv_chuan_hoa(SinhVien *sv);

/* Ghi ket qua ra, tham so ra */
int sv_doc(const char *dong, SinhVien *ra);

/* Mang chi doc */
int tim(const int a[], size_t n, int x);

/* Mang con tro chi doc, ca hai tang */
void in_het(const char *const ten[], size_t n);

/* Con tro toi con tro, tang trong chi doc */
int gom(const SinhVien *const *ds, size_t n);

#const không lan truyền qua một tầng

const trên struct không làm dữ liệu nó trỏ tới thành const

typedef struct {
    char  *bo_dem;
    size_t n;
} Vung;

void f(const Vung *v) {
    v->n = 0;             /* error: assignment of member 'n'
                             in read-only object   <- bat duoc */

    v->bo_dem[0] = 'x';   /* HOP LE, khong canh bao nao!
                             const chi ap dung cho CHINH struct,
                             khong lan sang vung ma bo_dem tro toi. */
}

Đây là chỗ hệ thống const của C yếu nhất. Một hàm nhận const Vung * vẫn sửa được dữ liệu qua con trỏ bên trong, và trình biên dịch không nói gì.

Cách chữa: khai báo hẳn một kiểu chỉ đọc

typedef struct {
    char  *bo_dem;
    size_t n;
} Vung;

typedef struct {
    const char *bo_dem;      /* con tro toi const */
    size_t      n;
} VungDoc;

/* Ham chi doc nhan VungDoc: */
size_t dem_ky_tu(VungDoc v);

/* Chuyen doi mot chieu, an toan: */
static inline VungDoc vung_doc(Vung v) {
    return (VungDoc){ v.bo_dem, v.n };
}

/* Danh doi: hai kieu thay vi mot. Chi lam khi bat bien do
   that su quan trong, vi du mot thu vien phat hanh ra ngoai. */

Gán con trỏ tới con trỏ cũng không tự động thêm const

char       *a[3];
const char *const *b = a;     /* HOP LE trong C11? Khong. */

/* gcc bao:
     warning: initialization of 'const char * const*' from incompatible
              pointer type 'char **' */

/* Trong C++ thi phep gan nay hop le. Trong C thi khong,
   vi quy tac tuong thich con tro cua C chat hon o cho nay.

   Cach lam trong C: ep kieu tuong minh, kem chu thich giai thich
   rang no an toan: */

const char *const *b = (const char *const *)a;   /* an toan: chi THEM const */

/* Day la mot trong vai cho ep kieu KHONG lam mat an toan,
   vi ban chi bo sung han che chu khong go bo. */

const không phải hằng số biên dịch

const int N = 10;

int a[N];                /* o pham vi tep: error: variably modified
                            'a' at file scope */

switch (x) { case N: }   /* error: case label does not reduce to
                            an integer constant */

/* Bai 19.2 da noi ky: trong C, const nghia la "khong duoc GHI",
   khong phai "gia tri biet luc bien dich".

   Dung enum cho so nguyen can lam hang so bien dich: */
enum { N = 10 };

int a[N];                /* dung */
switch (x) { case N: }   /* dung */

#Kết hợp với volatile

const volatile uint32_t *ID_CHIP = (const volatile uint32_t *)0x1FFF7A10;

uint32_t id = *ID_CHIP;      /* doc duoc */
*ID_CHIP = 0;                /* error: assignment of read-only location */

Khai báo	Chương trình ghi được	Đọc lại mỗi lần	Ví dụ thật
uint32_t x	Được	Không	Biến thường
const uint32_t x	Không	Không	Hằng số
volatile uint32_t *p	Được	Có	Thanh ghi điều khiển, ví dụ GPIO ODR
const volatile uint32_t *p	Không	Có	Thanh ghi chỉ đọc: mã chip, cờ trạng thái, bộ đếm

Hai từ khóa nói về hai chuyện khác nhau

/* const    : QUYEN CUA BAN.        Ban co duoc ghi khong?
   volatile : HANH VI CUA THE GIOI. Gia tri co tu doi khong?

   Bon to hop deu co nghia:

     khong gi ca:    ban ghi duoc, gia tri chi doi khi ban ghi
     const:          ban khong ghi, gia tri khong doi
     volatile:       ban ghi duoc, gia tri co the tu doi
     const volatile: ban khong ghi, gia tri co the tu doi

   To hop cuoi khong he mau thuan, va no la dang dung cho
   moi thanh ghi chi doc cua phan cung. */

Ví dụ thật từ CMSIS

typedef struct {
    volatile uint32_t CR1;        /* doc va ghi */
    volatile uint32_t CR2;
    const volatile uint32_t SR;   /* CHI DOC: co trang thai */
    volatile uint32_t DR;
    volatile uint32_t BRR;
} USART_TypeDef;

#define USART1 ((USART_TypeDef *)0x40011000UL)

while (!(USART1->SR & (1u << 7))) { }    /* doc duoc */

USART1->DR = b;                           /* ghi duoc */

USART1->SR = 0;                           /* error: read-only.
                                             Va do la dieu ban muon:
                                             thanh ghi nay xoa co bang
                                             cach doc DR, khong bang
                                             cach ghi vao SR. */

Nhiều header nhà sản xuất dùng __IO, __I, __O

/* Trong core_cm4.h cua CMSIS: */
#define __I   volatile const     /* chi doc  */
#define __O   volatile           /* chi ghi  */
#define __IO  volatile           /* doc ghi  */

typedef struct {
    __IO uint32_t CR1;
    __I  uint32_t SR;
    __IO uint32_t DR;
} USART_TypeDef;

/* Ba macro nay chi la ten khac cho to hop const va volatile.
   Chung ngan hon va noi ro y dinh hon, nen dang dung neu
   du an cua ban co nhieu khoi thanh ghi. */

Bảng tổng kết bốn từ khóa

Từ khóa	Nói với trình biên dịch	Dùng khi
const	Tôi không ghi vào đây	Tham số chỉ đọc, hằng số, bảng tra
volatile	Đừng tối ưu, đọc lại mỗi lần	Thanh ghi phần cứng, ISR, tín hiệu
restrict	Không con trỏ nào khác trỏ vào đây	Hàm xử lý mảng cần tối ưu, xem Bài 32.3
_Atomic	Thao tác này nguyên tử	Biến chia sẻ giữa các luồng
register	Cố giữ trong thanh ghi	Lỗi thời, trình biên dịch làm tốt hơn bạn

Tự làm thử

Viết bốn dạng khai báo con trỏ const và thử gán để xem cái nào bị từ chối.
Chạy chương trình ép bỏ const ở -O0 và -O2, so hai kết quả.
Đưa biến const ra phạm vi tệp rồi chạy lại, xem chương trình sập ở đâu.
Chạy nm trên tệp đối tượng và xác nhận biến const có chữ R.
Viết hàm nhận const Vung * rồi sửa dữ liệu qua con trỏ bên trong, xác nhận trình biên dịch không nói gì.
Khai báo một thanh ghi const volatile và thử ghi vào nó.

Trình chấm điểm tự động sẽ được bổ sung ở giai đoạn sau. Hiện tại bạn tự chạy thử trên máy.

Tóm tắt

const áp dụng cho thứ bên trái nó, và nếu không có gì bên trái thì cho thứ bên phải.
const là hợp đồng với trình biên dịch, không phải bảo vệ bộ nhớ. Ép bỏ rồi ghi là hành vi không xác định.
Biến const ở phạm vi tệp nằm trong vùng chỉ đọc thật, nên ghi vào gây lỗi phân đoạn. Biến const trong hàm thì không.
const trên struct không lan sang dữ liệu mà con trỏ bên trong nó trỏ tới.
const volatile không mâu thuẫn: một cái nói về quyền của bạn, cái kia nói về hành vi của thế giới.