Compound literal và thời gian sống

typedef struct { int x, y; } Diem;

/* 1. Doi so tam, khong can dat ten bien */
ve_diem((Diem){ 1, 2 });
ve_diem((Diem){ .x = 1, .y = 2 });

/* 2. Gan lai ca struct mot lan */
Diem p = { 0, 0 };
p = (Diem){ 10, 20 };          /* thay cho p.x = 10; p.y = 20; */

/* 3. Mang tam */
int tong = cong((int[]){ 1, 2, 3, 4, 5 }, 5);

/* Va mot dang it gap: con tro toi mot gia tri tam */
f(&(int){ 42 });               /* truyen dia chi cua mot int chua 42 */

#include <stdio.h>

static int *g = (int[]){1, 2, 3};      /* pham vi TEP: song TINH */

static int *tra_ve_cl(void) {
    return (int[]){10, 20, 30};        /* trong HAM: song TU DONG,
                                          chet khi ham tra ve */
}

int main(void) {
    printf("g[0] = %d\n", g[0]);

    int *p = tra_ve_cl();
    printf("p[0] = %d  (con tro treo)\n", p[0]);

    int *q;
    { int x = 5; q = &x; }
    printf("q     = %p  (doc dia chi cung la UB)\n", (void *)q);

    return 0;
}

void f(int co) {
    int *p;

    if (co) {
        p = (int[]){1, 2, 3};      /* song toi dau ngoac dong cua if */
    }

    printf("%d\n", p[0]);          /* UB neu co != 0 */
}

/* Compound literal chet o cuoi KHOI chua no, khong phai cuoi ham.

   Va trong mot vong lap: */

for (int i = 0; i < 3; ++i) {
    int *p = (int[]){i, i, i};     /* MOT doi tuong moi moi vong,
                                      va cai cu chet o cuoi moi vong */
    ds[i] = p;                     /* ca ba con tro deu treo sau vong lap */
}

/* Thay vi khai bao mot mang tinh chi dung mot lan: */

const char *ten_thu(int n) {
    static const char *const BANG[] = {
        "CN", "T2", "T3", "T4", "T5", "T6", "T7"
    };
    return (n >= 0 && n < 7) ? BANG[n] : "?";
}

/* Voi compound literal o PHAM VI HAM thi van an toan neu ban
   dung ngay va khong luu lai: */

const char *ten_thu(int n) {
    return (n >= 0 && n < 7)
         ? (const char *[]){ "CN","T2","T3","T4","T5","T6","T7" }[n]
         : "?";
}

/* CHU Y: cach thu hai tra ve mot con tro toi CHUOI HANG,
   khong phai toi compound literal. Chuoi hang song suot chuong trinh,
   nen an toan.

   Nhung neu ban tra ve chinh mang thi khong: */

const char **bang(void) {
    return (const char *[]){ "CN", "T2" };    /* SAI: mang chet */
}

/* Ban thu nhat ro rang hon va khong co bay. Nen dung no. */

/* C23 them tu khoa "constexpr" cho compound literal,
   de bat no co thoi gian luu tru TINH ngay ca trong ham: */

void f(void) {
    int *p = (static int[]){1, 2, 3};   /* de xuat, chua vao chuan */
    constexpr int a[] = {1, 2, 3};      /* C23: hang so that su */
}

/* Thuc te C23 lam duoc hai viec lien quan:

   1. constexpr cho bien: gia tri biet luc dich, dung lam kich thuoc
      mang va nhan case duoc. Bai 51.3.

   2. "{}" rong hop le: */

Diem p = {};              /* C23: moi truong bang 0 */
Diem p = { 0 };           /* truoc C23 phai viet vay */

*c = (CauHinh){};         /* C23: quet sach, gon hon (CauHinh){ 0 } */

/* De xuat "storage-class specifier trong compound literal", tuc
   (static int[]){...}, da duoc thao luan nhung chua vao C23.
   GCC ho tro no nhu mot mo rong tu lau: */

gcc -std=gnu2x prog.c     /* co the chap nhan (static int[]){...} */