60 선언을 읽는 법 — 두 가지 독법과 typedef

60.1 두 가지 독법

먼저 규칙 하나만 챙기면 된다. 선언에서 이름 곁에 붙는 세 기호의 힘이 다르다.

• [](배열)와 ()(함수)는 이름의 오른쪽에 붙고, *(포인터)는 왼쪽에 붙는다.
• 오른쪽 둘이 왼쪽 하나보다 세다. 그래서 int *a[3]은 “포인터의 배열” 이지 “배열의 포인터”가 아니다.
• 순서를 뒤집고 싶으면 괄호로 묶는다 — int (*a)[3].

이 힘의 차이 위에서 두 가지 독법이 나온다.

독법 ① — 가장 안쪽 이름에서 바깥으로(오른쪽-왼쪽 규칙). 식별자를 찾아 거기서 시작해, 오른쪽을 먼저 보고 그다음 왼쪽을 보며 번갈아 바깥으로 나간다. 괄호를 만나면 그 안을 다 읽고 밖으로 나간다. 읽어 나가는 말이 영어 어순 그대로 이어진다는 것이 이 방법의 묘미다.

독법 ② — 바깥에서 안으로. 타입 이름(맨 왼쪽의 int, char 같은 것) 에서 시작해 “이것은 무엇의 무엇인가”를 감싸 들어간다. 식별자가 아예 없는 선언 — 캐스트나 sizeof에 적는 추상 선언자 — 에서는 시작할 이름이 없으므로 이쪽이 유일한 길이다.

두 독법은 같은 결론에 도달한다. 상황에 따라 편한 쪽을 쓰면 된다.

60.2 독법 ① 실습 — 영어 어순으로 이어 읽기

/* 선언을 읽는 두 가지 방법을 눈으로 확인한다.
   같은 뜻을 typedef 로 쌓아 만든 타입과 원래 선언이 정말 같은지도 검사한다. */
#include <stdio.h>

/* ① 별 하나 차이 ─────────────────────────────────────── */
int  *pa[3];      /* pa: 배열[3] of 포인터 to int   */
int (*ap)[3];     /* ap: 포인터 to 배열[3] of int   */

/* ② 함수가 끼면 ──────────────────────────────────────── */
int  *f(void);    /* f: 함수(void) 반환 포인터 to int */
int (*g)(void);   /* g: 포인터 to 함수(void) 반환 int */

/* ③ 악명 높은 형태: 배열[4] of 포인터 to 함수(int) 반환 포인터 to char */
char *(*table[4])(int);

/* ④ 같은 타입을 typedef 로 한 겹씩 쌓아 만든다 */
typedef char           *charptr;        /* 포인터 to char                  */
typedef charptr         handler(int);   /* 함수(int) 반환 charptr          */
typedef handler        *handler_ptr;    /* 포인터 to 그 함수               */
typedef handler_ptr     table4[4];      /* 배열[4] of 그 포인터            */

/* 두 길로 만든 타입이 정말 같은지 컴파일 시간에 검사한다 */
static_assert(sizeof(table4) == sizeof(table), "they must be the same type");

static char *shout(int n)  { (void)n; return "shout"; }
static char *quiet(int n)  { (void)n; return "quiet"; }

int main(void)
{
    printf("int  *pa[3]  : whole %zu, element %zu  -> %zu pointers\n",
           sizeof pa, sizeof pa[0], sizeof pa / sizeof pa[0]);
    printf("int (*ap)[3] : whole %zu, pointee %zu\n",
           sizeof ap, sizeof *ap);

    /* ③ 을 실제로 채워 쓴다 */
    table[0] = shout;
    table[1] = quiet;
    printf("table[0](1) = %s, table[1](2) = %s\n", table[0](1), table[1](2));

    /* ④ 의 typedef 로 만든 변수도 같은 자리에 그대로 들어간다 */
    table4 other = { quiet, shout };
    printf("other[0](3) = %s   (the same type, made with a typedef)\n", other[0](3));

    /* 식별자가 없는 형태(추상 선언자): 캐스트와 sizeof 에서 쓴다 */
    printf("sizeof(char *(*)(int)) = %zu   (an unnamed function pointer type)\n",
           sizeof(char *(*)(int)));
    return 0;
}

int  *pa[3]  : whole 24, element 8  -> 3 pointers
int (*ap)[3] : whole 8, pointee 12
table[0](1) = shout, table[1](2) = quiet
other[0](3) = quiet   (the same type, made with a typedef)
sizeof(char *(*)(int)) = 8   (an unnamed function pointer type)

예제의 선언들을 하나씩 읽어 본다. 읽는 말은 영어로 이어 붙이는 편이 자연스럽다 — C의 선언 문법이 영어 어순을 따라 설계됐기 때문이다.

int *pa[3];

1. 식별자 pa에서 시작한다 — “pa is”
2. 오른쪽을 본다: [3] — “array 3 of”
3. 오른쪽이 끝났으니 왼쪽을 본다: * — “pointer to”
4. 남은 것: int — “int”

이어 읽으면 “pa is array 3 of pointer to int” — 포인터 세 개짜리 배열이다. 예제가 전체 24바이트, 원소 8바이트로 그것을 확인했다.

int (*ap)[3];

1. ap에서 시작 — “ap is”
2. 오른쪽은 괄호의 끝이므로 갈 수 없다. 왼쪽을 본다: * — “pointer to”
3. 괄호를 벗어난다. 다시 오른쪽: [3] — “array 3 of”
4. 남은 것: int

“ap is pointer to array 3 of int” — 포인터 하나(8바이트)이고, 가리키는 것이 12바이트짜리 배열이다. 예제의 두 번째 줄이 그것이다.

char *(*table[4])(int); — 이 장의 주인공이다.

1. table에서 시작 — “table is”
2. 오른쪽: [4] — “array 4 of”
3. 왼쪽: * — “pointer to”
4. 괄호 밖 오른쪽: (int) — “function (int) returning”
5. 왼쪽: * — “pointer to”
6. 남은 것: char

“table is array 4 of pointer to function (int) returning pointer to char” — 정수 하나를 받아 문자열을 돌려주는 함수들의 표다. 예제에서 실제로 두 함수를 넣고 불러 보았다.

60.2.1 이 읽기에는 이름이 있다 — 우경식(boustrophedon)

방금 한 일을 다시 보면 눈이 오른쪽 → 왼쪽 → 오른쪽으로 갈지자를 그렸다. 이 움직임에는 오래된 이름이 있다. 우경식(牛耕式, boustrophedon)이다. 그리스어 βοῦς(소)와 στρέφειν(돌다)을 합친 말로, 소가 쟁기를 끌고 밭 끝까지 갔다가 돌아서 반대 방향으로 오는 모양을 뜻한다. 고대 그리스 비문에는 실제로 한 줄은 왼쪽에서 오른쪽, 다음 줄은 오른쪽에서 왼쪽으로 새긴 것들이 있고, 그것을 우경식 서법이라 부른다.

C 선언을 이 낱말로 처음 부른 사람은 페터르 판데르린던이다. 그는 이렇게 적었다 — “C의 선언은 우경식으로 읽는다. 즉 오른쪽에서 왼쪽으로, 왼쪽에서 오른쪽으로 번갈아 가며. 그런 것을 가리키는 낱말이 따로 있으리라고 누가 생각이나 했겠는가!”¹

이름을 알아 두면 좋은 이유는 하나다. 독법 ①이 임의의 요령이 아니라 하나의 꼴을 가진 절차라는 것이 이름에 담기기 때문이다. 같은 책이 그 절차를 우선순위 규칙(precedence rule)으로 압축해 놓았다. 우리가 앞에서 문장으로 풀어 쓴 것과 같은 것인데, 세 번째 항목은 아직 다루지 않았다.

★ C항이 실무에서 가장 자주 사고를 낸다. const가 어디에 붙는지가 뜻을 완전히 뒤집기 때문이다.

/* 우경식(牛耕式) 읽기의 우선순위 규칙을 눈으로 확인한다.
   특히 const/volatile 이 「왼쪽의 별표에 붙는가, 타입에 붙는가」를 실물로 가른다. */
#include <stdio.h>

static int one = 1, two = 2;

int main(void)
{
    /* ① const 가 타입 지정자 옆에 있다 → 타입에 붙는다(가리키는 것이 읽기 전용) */
    const int *pci  = &one;     /* 「int const 를 가리키는 포인터」 */
    int const *pci2 = &one;     /* 위와 완전히 같다 — 순서만 다르다 */

    /* ② const 가 타입 지정자 옆이 아니다 → 바로 왼쪽의 별표에 붙는다 */
    int *const cpi = &one;      /* 「int 를 가리키는, 읽기 전용 포인터」 */

    /* ③ 둘 다 */
    const int *const cpci = &one;

    /* ①은 가리키는 곳을 바꿀 수 있다.  *pci = 9; 는 오류다. */
    pci = &two;
    pci2 = &two;
    printf("(1) *pci=%d  *pci2=%d   <- the pointer itself can move\n", *pci, *pci2);

    /* ②는 반대다.  cpi = &two; 는 오류이고, 가리키는 값은 바꿀 수 있다. */
    *cpi = 42;
    printf("(2) *cpi=%d   one=%d      <- the value can be changed\n", *cpi, one);

    printf("(3) *cpci=%d              <- read-only on both sides\n", *cpci);

    /* ④ 우경식으로 읽는 실물: 오른쪽 먼저, 막히면 왼쪽 */
    char *const *next = NULL;   /* next 는 「char 를 가리키는 읽기 전용 포인터」를
                                   가리키는 포인터 */
    printf("(4) sizeof next = %zu   (one pointer)\n", sizeof next);

    /* ⑤ 태그를 붙여 두었기에 자기 자신을 가리킬 수 있다 */
    struct node_tag { int datum; struct node_tag *next; };
    struct node_tag b = { 2, NULL };
    struct node_tag a = { 1, &b };
    printf("(5) a.datum=%d -> a.next->datum=%d\n", a.datum, a.next->datum);

    return 0;
}

(1) *pci=2  *pci2=2   <- the pointer itself can move
(2) *cpi=42   one=42      <- the value can be changed
(3) *cpci=42              <- read-only on both sides
(4) sizeof next = 8   (one pointer)
(5) a.datum=1 -> a.next->datum=2

예제의 앞 세 줄이 그 갈림이다.

예제가 이것을 실물로 갈랐다. const int *pci는 pci = &two;로 옮길 수는 있고, int *const cpi는 *cpi = 42;로 값을 바꿀 수는 있다. 반대쪽은 각각 컴파일 오류다 — assignment of read-only location '*pci'와 assignment of read-only variable 'cpi'.

60.2.2 지워 가며 읽기

같은 책이 함께 권한 요령이 하나 더 있다. 읽은 부분을 지우는 것이다. 눈으로만 훑으면 어디까지 처리했는지 놓치는데, 처리한 조각을 지우면 남은 것이 곧 다음 할 일이 된다. 종이에 옮겨 적으며 읽으면 실수가 거의 나지 않는 이유가 이것이다.

char *const *(*next)();를 그렇게 읽어 보자. 굵은 것이 지금 보는 조각이다.

이어 붙이면 “next는 함수를 가리키는 포인터인데, 그 함수는 char를 가리키는 읽기 전용 포인터를 가리키는 포인터를 돌려준다”가 된다. 이 선언은 지어낸 것이 아니라 telnet의 소스에서 나온 실물이다.

60.3 독법 ② — 이름이 없을 때

캐스트와 sizeof에는 이름이 없는 타입을 적는다. 예제 마지막 줄의 sizeof(char *(*)(int))가 그것이다. 이런 형태를 추상 선언자라 부르고, 읽는 법은 간단하다 — 이름이 있어야 할 자리를 찾아 거기에 이름을 하나 얹어 놓고 독법 ①로 읽는다.

char *(*)(int)        /* 이름이 없다 */
char *(*x)(int)       /* 빈자리에 x 를 넣으면 */
                      /* "x is pointer to function (int) returning pointer to char" */

빈자리는 대개 (*)의 별표 뒤, 또는 []나 ()의 앞이다. 이 요령 덕에 독법 ①의 근육을 그대로 쓸 수 있다.

그러면 독법 ②는 언제 쓰는가. 함수 포인터를 인자로 받는 선언처럼, 껍질이 여러 겹인데 어느 것이 바깥인지부터 알고 싶을 때다.

void qsort(void *base, size_t n, size_t size,
           int (*cmp)(const void *, const void *));

바깥에서 안으로 읽으면 “이것은 함수 qsort이고, 반환은 void, 인자는 넷인데 마지막은 함수 포인터”라는 뼈대가 먼저 잡힌다. 세부는 그다음에 독법 ①로 확인한다. 실무에서 남의 헤더를 읽을 때는 이 순서가 편하다.

60.4 typedef — 층을 나누어 이름을 붙인다

험한 선언을 다루는 가장 실용적인 답은 이름을 붙여 층을 나누는 것이다. 예제 ④가 그 시연이다.

typedef char       *charptr;        /* 포인터 to char        */
typedef charptr     handler(int);   /* 함수(int) 반환 charptr */
typedef handler    *handler_ptr;    /* 포인터 to 그 함수      */
typedef handler_ptr table4[4];      /* 배열[4] of 그 포인터   */

네 줄이 각각 한 겹씩만 얹는다. 마지막 table4는 예제 ③의 char *(*table[4])(int)와 정확히 같은 타입이고, 예제의 static_assert가 그것을 컴파일 시간에 확인한다. 실무에서는 이렇게까지 잘게 쪼개기보다 한두 겹만 이름을 붙이는 경우가 많다.

typedef char *(*handler_fn)(int);   /* 한 겹으로 충분할 때 */
handler_fn table[4];

60.4.1 어디에 쓰고 어디에 쓰지 않을 것인가

층을 나누는 법은 알았는데, 언제 나눌 것인가. 여기에 대해서는 30년 넘게 인용되는 어림규칙이 있다. 판데르린던이 「typedef를 다루는 요령」이라는 상자에 적어 둔 세 가지다.²

세 가지를 오늘 기준으로 하나씩 확인해 본다.

①은 지금도 유효하다. 앞의 반례 상자에서 본 그대로다 — typedef로 struct를 감추면 const가 어디 붙는지가 흐려지고, 그것이 struct를 감춘 대가다. 리눅스 커널 코딩 규약이 같은 결론을 못박아 두었다. 감추는 것이 설계인 불투명 타입만 예외다.

②는 우리가 이미 하고 있는 것이고, 여기에 오늘의 사정을 하나 보태야 한다. “20비트 이상이 필요하면 typedef로 두라”는 조언은 1994년에는 직접 만들어 써야 하는 일이었다. 지금은 표준이 그 일을 대신해 준다 — <stdint.h>의 int32_t·int_least32_t·int_fast32_t가 정확히 그 목적의 typedef다(27장). ★ 그러므로 오늘의 판본은 이렇다: 직접 만들기 전에 표준에 이미 있는지 먼저 보라. 없을 때만 만든다.

③은 재미있게도 두 가지 이유에서 옳다. 하나는 판데르린던이 말한 “나중에 필요해진다”이고, 다른 하나는 지금 당장 필요한 경우가 있다는 것이다. 자기 자신을 가리키는 구조체가 그렇다.

typedef struct { int datum; node *next; } node;   /* 안 된다 */

node라는 이름은 ;에 이르러서야 생기므로 안쪽에서는 아직 쓸 수 없다. 실제로 컴파일하면 error: unknown type name 'node'가 난다. 태그가 있으면 문제가 사라진다 — 태그는 struct 다음에 곧바로 생기기 때문이다.

typedef struct node_tag { int datum; struct node_tag *next; } node;   /* 된다 */

예제 ⑤가 이 형태로 두 마디를 이어 붙였다. 앞 장들에서 우리가 구조체 태그에 _tag를 붙여 온 것도 같은 이유다 — 같은 이름을 서로 다른 두 가지에 쓰지 않으려는 것이다(55장의 이름 공간).

typedef struct node *node;      /* 포인터라는 사실이 이름에서 사라진다 */
void f(const node n);           /* const 는 무엇에 붙는가? */

typedef int meters;
typedef int seconds;
meters  d = 10;
seconds t = 5;
d = t;              /* 경고 없음 — 둘 다 그냥 int 다 */

60.5 실물 — 실무에서 실제로 쓰인 선언들

지금까지 본 것은 연습용이 아니다. 실제로 출하된 라이브러리의 선언을 그대로 가져와 절차대로 읽어 보자. 겁먹을 필요가 없다는 것을 확인하는 것이 이 절의 목적이다.

/* 실무에서 실제로 쓰인 난해한 선언들 — 그리고 절차대로 읽으면 풀린다는 것. */
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>

/* ── ① 표준의 signal — C 표준 §7.14.1.1 에 그대로 있는 선언 ────────
      void (*signal(int sig, void (*func)(int)))(int);
   같은 것을 typedef 로 층을 나누면 이렇게 된다. */
typedef void handler_t(int);          /* 함수 타입 자체에 이름을 준다 */
static void on_int(int sig) { (void)sig; }

/* ── ② X11 의 XSetErrorHandler 를 흉내 낸 모양 ───────────────────
      int (*XSetErrorHandler(int (*handler)(Display *, XErrorEvent *)))();
   Display·XErrorEvent 자리에 흉내용 타입을 넣어 그대로 옮겼다. */
typedef struct { int dummy; } Display;
typedef struct { int code; } XErrorEvent;

static int my_error_handler(Display *d, XErrorEvent *e)
{ (void)d; printf("  error handler: code=%d\n", e->code); return 0; }

/* 날것 그대로: "핸들러를 받아, 이전 핸들러를 돌려주는 함수" */
static int (*set_error_handler(int (*handler)(Display *, XErrorEvent *)))
           (Display *, XErrorEvent *)
{
    static int (*current)(Display *, XErrorEvent *);
    int (*prev)(Display *, XErrorEvent *) = current;
    current = handler;
    return prev;
}

/* 같은 것을 typedef 로 — 한 줄이 세 줄이 되고, 세 줄이 다 읽힌다 */
typedef int error_handler_t(Display *, XErrorEvent *);
static error_handler_t *set_error_handler2(error_handler_t *handler)
{ return set_error_handler(handler); }

/* ── ③ 함수를 가리키는 포인터의 배열 — 명령 표(dispatch table) ──── */
static int cmd_add(int a, int b) { return a + b; }
static int cmd_mul(int a, int b) { return a * b; }

/* int (*table[2])(int, int) — "int 둘을 받아 int 를 돌려주는 함수를
   가리키는 포인터"의 배열. 절차대로 읽으면 이렇게 나온다. */
static int (*table[2])(int, int) = { cmd_add, cmd_mul };

/* ── ④ 배열을 가리키는 포인터를 돌려주는 함수 ──────────────────── */
static int (*rows(void))[4]            /* "int[4] 를 가리키는 포인터를 돌려주는 함수" */
{
    static int grid[3][4] = { {1,2,3,4}, {5,6,7,8}, {9,10,11,12} };
    return grid;                        /* int (*)[4] 로 무너진다 */
}

int main(void)
{
    /* ① signal 은 *이전 핸들러*를 돌려준다 — 그래서 반환 타입이 함수 포인터다 */
    handler_t *old = signal(SIGINT, on_int);
    printf("signal returns the previous handler: %s\n",
           old == SIG_ERR ? "SIG_ERR" : "there was one");
    (void)signal(SIGINT, old == SIG_ERR ? SIG_DFL : old);

    /* ② 같은 무늬 — 설치하고, 이전 것을 돌려받는다 */
    puts("\ninstalling an X11-style error handler:");
    int (*prev)(Display *, XErrorEvent *) = set_error_handler(my_error_handler);
    printf("  previous handler: %s\n", prev ? "present" : "none (first install)");
    Display d = { 0 };
    XErrorEvent e = { .code = 42 };
    error_handler_t *prev2 = set_error_handler2(my_error_handler);  /* typedef 판 */
    printf("  the typedef version does the same: previous handler %s\n",
           prev2 == my_error_handler ? "identical" : "different");
    my_error_handler(&d, &e);

    /* ③ 명령 표 */
    printf("\ncommand table: add(3,4)=%d, mul(3,4)=%d\n", table[0](3, 4), table[1](3, 4));

    /* ④ 배열을 가리키는 포인터 */
    int (*g)[4] = rows();
    printf("pointer to an array: g[2][1] = %d (one step is %zu bytes)\n",
           g[2][1], sizeof *g);
    return 0;
}

signal returns the previous handler: there was one

installing an X11-style error handler:
  previous handler: none (first install)
  the typedef version does the same: previous handler identical
  error handler: code=42

command table: add(3,4)=7, mul(3,4)=12
pointer to an array: g[2][1] = 10 (one step is 16 bytes)

60.5.1 ① 표준이 직접 낳은 괴물 — signal

C 표준의 <signal.h>에 이 선언이 그대로 있다(§7.14.1.1).

void (*signal(int sig, void (*func)(int)))(int);

처음 보면 괄호의 숲이지만, 앞 절의 절차를 그대로 밟으면 다섯 걸음이면 끝난다. 이름에서 시작해, 오른쪽을 먼저 보고, 막히면 왼쪽으로 간다.

한 문장으로 옮기면 이렇다 — “signal은 신호 번호와 핸들러를 받아,이전 핸들러를 돌려주는 함수”다. 반환 타입이 왜 저렇게 험한지도 그 순간 설명된다. 설치하면서 이전 것을 돌려주어야 나중에 되돌릴 수 있기 때문이다. 시연의 첫 줄이 실제로 그 이전 핸들러를 받아 되돌린다.

typedef 한 줄이면 이 선언은 평범해진다.

typedef void handler_t(int);          /* 함수 타입에 이름을 준다 */
handler_t *signal(int sig, handler_t *func);

표준이 이렇게 쓰지 않은 것은 역사 때문이다 — 이 함수는 typedef로 층을 나누는 관행이 자리 잡기 한참 전부터 있었다.

60.5.2 ② 실제로 더 험한 것 — X11의 오류 처리기

X 윈도 시스템의 매뉴얼에 실린 선언이다.

int (*XSetErrorHandler(int (*handler)(Display *, XErrorEvent *)))();

무늬는 signal과 똑같다. 핸들러를 받아 이전 핸들러를 돌려주는 함수다. 다른 것은 인자가 둘이라 괄호가 한 겹 더 두꺼워 보인다는 것뿐이다. 절차대로 읽으면 걸음 수도 같다.

시연의 두 번째 묶음이 이 무늬를 그대로 옮겨 실제로 돌린다 — 날것 그대로 쓴 set_error_handler와, typedef로 층을 나눈 set_error_handler2가 같은 일을 한다. 후자를 보면 이 험한 선언이 사실은 “핸들러를 받아 핸들러를 돌려주는 함수” 한 줄임이 드러난다.

typedef int error_handler_t(Display *, XErrorEvent *);
error_handler_t *XSetErrorHandler(error_handler_t *handler);

60.5.3 ③ 그리고 정말로 무의미한 것

인터넷의 선언 퀴즈에 단골로 나오는 것들이 있다.

char *(*(*foo[][8])())[];      /* cdecl 문서의 예 */
int (*(*bar[10])(void))(int);

이런 것도 절차는 똑같이 통한다. 첫 번째는 “char를 가리키는 포인터의 배열을 가리키는 포인터를 돌려주는 함수를 가리키는 포인터를 가리키는 포인터의, 8열짜리 배열의 배열”이다. 읽어 냈다는 사실보다 중요한 것은 그다음 판단이다 — 이런 선언은 코드에 두지 않는다.

앞의 둘(signal, X11)과 이것의 차이가 이 장의 요점이다. 앞의 둘은 풀어야 할 이유가 있는 선언이다. 실제로 쓰이고, 무늬에 뜻이 있다. 뒤의 것은 뜻이 없다 — 문법이 허용한다는 사실을 보여 줄 뿐이다.

60.6 도구에 맡기기 — cdecl

이 읽기를 대신해 주는 프로그램이 오래전부터 있다. 1980년대에 나와 지금도 관리되고 있는 cdecl이다(현재 관리자 Paul J. Lucas, GPLv3). 선언을 주면 영어로 풀어 주고, 영어로 말하면 선언을 지어 준다.

cdecl> explain char *(*table[4])(int)
cdecl> declare table as array 4 of pointer to function (int) returning pointer to char

첫 줄은 우리가 위에서 손으로 한 일을 대신하고, 둘째 줄은 그 반대 방향 이다 — 영어로 말한 것을 C 선언으로 지어 준다. 리눅스 배포판의 패키지로 설치할 수 있고(cdecl), 설치 없이 브라우저에서 쓰는 cdecl.org도 있다.

선언을 읽는 근육을 얻었다. 다음 장부터는 표준 라이브러리의 지형으로 들어간다 — 지금까지 배운 언어 위에, 세상이 반세기 동안 쌓아 온 함수들이 어떤 계약과 함정을 안고 있는지 보는 부다.