/* 2차원 표에서 값을 찾아 다중 루프를 빠져나오는 세 가지 방식.
   셋은 같은 답을 내고, 다른 것은 '읽는 사람이 흐름을 얼마나 쉽게 따라가는가'다. */
#include <stdbool.h>
#include <stdio.h>

#define ROWS 4
#define COLS 5

static const int grid[ROWS][COLS] = {
    {  3, 14, 15,  92,  6 },
    { 53, 58,  9,  79,  3 },
    { 23, 84, 62,  64, 33 },
    { 83, 27, 95,  28, 84 },
};

struct pos { int row, col; bool found; };

/* ── ① 플래그 변수 ──
   바깥 루프의 조건에 플래그를 얹는다. 표준 C 만으로 되지만,
   조건이 늘고 '어디서 끝났는가'가 두 곳에 흩어진다. */
static struct pos find_flag(int target)
{
    struct pos p = { -1, -1, false };
    for (int i = 0; i < ROWS && !p.found; i++)
        for (int j = 0; j < COLS; j++)
            if (grid[i][j] == target) { p.row = i; p.col = j; p.found = true; break; }
    return p;
}

/* ── ② goto ──
   '두 겹을 한 번에 벗는다'는 뜻이 한 줄로 드러난다.
   레이블은 아래에 두고, 이름은 하는 일로 짓는다. */
static struct pos find_goto(int target)
{
    struct pos p = { -1, -1, false };
    for (int i = 0; i < ROWS; i++)
        for (int j = 0; j < COLS; j++)
            if (grid[i][j] == target) { p.row = i; p.col = j; p.found = true; goto done; }
done:
    return p;
}

/* ── ③ 함수로 빼고 return ──
   return 은 몇 겹이든 한 번에 벗는다. 탈출 장치가 아예 필요 없어진다. */
static struct pos find_return(int target)
{
    for (int i = 0; i < ROWS; i++)
        for (int j = 0; j < COLS; j++)
            if (grid[i][j] == target) return (struct pos){ i, j, true };
    return (struct pos){ -1, -1, false };
}

static void show(const char *how, struct pos p)
{
    if (p.found) printf("  %-16s (%d, %d)\n", how, p.row, p.col);
    else         printf("  %-16s none\n", how);
}

int main(void)
{
    puts("[looking for 62 - three ways, same answer]");
    show("① flag", find_flag(62));
    show("② goto",   find_goto(62));
    show("③ function + return", find_return(62));

    puts("\n[looking for a value that is not there (100)]");
    show("① flag", find_flag(100));
    show("② goto",   find_goto(100));
    show("③ function + return", find_return(100));

    puts("\n[break peels off one layer only - hence the devices above]");
    int visited = 0;
    for (int i = 0; i < ROWS; i++)
        for (int j = 0; j < COLS; j++) { visited++; if (grid[i][j] == 62) break; }
    printf("  break in the inner loop only: visited %d cells (of %d)\n",
           visited, ROWS * COLS);
    puts("  -> only the inner loop ended; the outer one kept going.");
    return 0;
}

/* 매크로를 '한 문장'으로 만드는 do { } while (0), 그리고 goto 로 정리하기. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* 중괄호만 쓰면 뒤에 세미콜론이 붙는 순간 문장이 둘이 된다.
   그래서 아래처럼 if/else 사이에 놓으면 컴파일 오류가 난다.

       #define SWAP_BAD(a, b) { int t = (a); (a) = (b); (b) = t; }
       if (x < y) SWAP_BAD(x, y); else puts("...");
           → error: 'else' without a previous 'if'

   do { } while (0) 은 '중괄호 블록이면서 동시에 한 문장'이 되게 한다. */
#define SWAP(a, b)  do { int t_ = (a); (a) = (b); (b) = t_; } while (0)

#define LOG(fmt, ...)  do {                       \
        printf("[log] " fmt "\n", __VA_ARGS__);   \
    } while (0)

/* goto 로 정리 지점을 한 곳에 모으는 무늬 — 리눅스 커널이 쓰는 그 형태다.
   중간에 실패해도 '거기까지 얻은 것만' 되돌린다. */
static bool build(size_t n, bool fail_at_second)
{
    char *a = nullptr, *b = nullptr;
    bool ok = false;

    a = malloc(n);
    if (!a) goto out;                 /* 아직 되돌릴 것이 없다 */
    memset(a, 'a', n);

    b = fail_at_second ? nullptr : malloc(n);
    if (!b) goto free_a;              /* a 만 되돌린다 */
    memset(b, 'b', n);

    ok = true;

    free(b);
free_a:
    free(a);
out:
    return ok;
}

int main(void)
{
    int x = 1, y = 2;

    puts("[do { } while (0) - a macro becomes one statement]");
    if (x < y) SWAP(x, y); else puts("  (we never get here)");
    printf("  after the swap: x=%d y=%d   <- it does not break between if and else\n", x, y);

    LOG("values %d and %d", x, y);

    puts("\n[safe as the body of a for, even without braces]");
    for (int i = 0; i < 2; i++)
        LOG("round %d", i);

    puts("\n[gathering cleanup with goto]");
    printf("  both succeeded: %s\n", build(16, false) ? "ok" : "failed");
    printf("  second one failed: %s  <- only the first was undone before leaving\n",
           build(16, true) ? "ok" : "failed");
    return 0;
}

/* 루프의 관용구 몇 가지 — 그리고 조용히 무는 자리들. */
#include <stddef.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    int a[] = { 10, 20, 30, 40, 50 };
    size_t n = sizeof a / sizeof a[0];

    puts("[iterating backwards - with size_t you cannot write i >= 0]");
    printf("  the right shape (i-- > 0): ");
    for (size_t i = n; i-- > 0; ) printf("%d ", a[i]);
    puts("");
    puts("  the wrong shape (size_t i = n-1; i >= 0; i--) loops forever -");
    puts("  for an unsigned value 0 is followed by SIZE_MAX, so the condition never fails.");
    printf("  with a signed index that shape works: ");
    for (int i = (int)n - 1; i >= 0; i--) printf("%d ", a[i]);
    puts("");

    puts("\n[the comma operator - closing in from both ends]");
    printf("  reversed: ");
    int b[] = { 1, 2, 3, 4, 5, 6 };
    size_t m = sizeof b / sizeof b[0];
    for (size_t i = 0, j = m - 1; i < j; i++, j--) {
        int t = b[i]; b[i] = b[j]; b[j] = t;
    }
    for (size_t i = 0; i < m; i++) printf("%d ", b[i]);
    puts("");

    puts("\n[sentinel loop - read and test in one step]");
    const char *text = "hi!\n";
    const char *p = text;
    int c, count = 0;
    while ((c = *p++) != '\0') {          /* 괄호가 필수다 */
        if (c == '\n') printf("\\n ");
        else printf("%c ", c);
        count++;
    }
    printf("\n  read %d characters\n", count);

    puts("\n[do not call strlen in the loop condition]");
    const char *s = "measure once";
    size_t len = strlen(s);               /* 한 번만 잰다 */
    size_t vowels = 0;
    for (size_t i = 0; i < len; i++)
        if (strchr("aeiou", s[i]) && s[i]) vowels++;
    printf("  \"%s\" has %zu vowels (length %zu, measured once)\n", s, vowels, len);

    puts("\n[write down what an empty body means]");
    size_t skip = 0;
    const char *q = "   value";
    while (q[skip] == ' ')
        skip++;                            /* 몸통이 있는 형태로 적는다 */
    printf("  skipped %zu leading spaces\n", skip);
    puts("  while (q[skip++] == ' ') ;  is shorter with an empty body,");
    puts("  but the lone semicolon is easy to miss, and that causes accidents.");
    return 0;
}