연산자 #

int x = 5;
int a = ++x;   // x는 6, a는 6
int b = x++;   // b는 6, x는 7
int c = --x;   // x는 6, c는 6
int d = x--;   // d는 6, x는 5

int x = 42;
x = 100;

int x = 10;
x += 5;     // x는 15
x -= 3;     // x는 12
x *= 2;     // x는 24
x /= 4;     // x는 6
x %= 5;     // x는 1

uint32_t flags = 0xFF00;
flags &= 0x0F0F;    // flags는 0x0F00
flags |= 0x00F0;    // flags는 0x0FF0
flags ^= 0x0FF0;    // flags는 0x0000

// 단락 평가는 *평가 순서*에 영향을 줄 뿐, unsafe 역참조 규칙에는
// 영향을 주지 않습니다: &&가 ptr이 non-null일 때만 실행되도록 보장하더라도
// *ptr에는 여전히 'unsafe'가 필요합니다 — 컴파일러는 흐름 민감한
// 좁히기(narrowing)를 수행하지 않습니다.
unsafe {
    if (ptr != (int*)0 && *ptr > 0) {
        // &&' 덕분에 *ptr은 ptr이 non-null일 때만 평가됩니다
    }
}

uint32_t flags = 0b1100;              // 이진 리터럴 (리터럴과 한정자 참고); = 0xC
uint32_t mask  = 0b1010;              // = 0xA

uint32_t and_result = flags & mask;   // 0x8  (0b1000)
uint32_t or_result  = flags | mask;   // 0xE  (0b1110)
uint32_t xor_result = flags ^ mask;   // 0x6  (0b0110)
uint32_t not_result = ~flags;         // 모든 비트가 반전됨

uint32_t shifted = 1 << 4;           // 16 (비트 4가 설정됨)

struct Point { double x; double y; };

struct Point p = {3.0, 4.0};
double x1 = p.x;            // 값 접근

// raw pointer를 얻고 이를 ->로 역참조하는 것 모두 'unsafe'가 필요합니다 —
// '&stack Point'에서 'Point*'로의 암묵적 변환은 없습니다.
struct Point *ptr;
unsafe { ptr = (struct Point*)&p; }
double x2;
unsafe { x2 = ptr->x; }      // 포인터 역참조 + 접근
// (*ptr).x와 동등함

double Point::length() const {
    return sqrt_d(self.x * self.x + self.y * self.y);
}

int arr[5] = {10, 20, 30, 40, 50};
int x = arr[2];              // 30 (경계 검사됨)

[]int s = arr[1..4];
int y = s[0];                // 20 (슬라이스 길이를 기준으로 경계 검사됨)

condition ? then_expr : else_expr

int x = 10;
int y = 20;
int max = (x > y) ? x : y;       // max is 20

const &char label = (count == 1) ? "item" : "items";

int a; int b;
int x = (a = 1, b = 2, a + b);   // x는 3

int i = 0;
int j = 10;
for (; i < j; i++, j--) {
    // i는 증가, j는 감소
}

for (int i = 0, j = 10; i < j; i++, j--) {
    // i는 증가, j는 감소
}

int a, b = 5, c;   // a와 c는 초기화되지 않음, b는 5

int x = 42;
&stack int ref = &x;         // 리전 한정 참조
int y = *ref;                // 역참조: y는 42

int x = 42;
double d = (double)x;        // 명시적 캐스트

long s1 = sizeof(int);       // 4
long s2 = sizeof(x);         // 4
long a = alignof(double);    // 8 (플랫폼에 따라 다름)