MENU
  1. ホーム
  2. C 언어
  3. C언어에서 배열 요소 접근: 포인터 아트 완벽 가이드

C언어에서 배열 요소 접근: 포인터 아트 완벽 가이드

C 언어

C언어에서 포인터를 활용해 배열 요소에 접근하는 기술은 고급 프로그래밍의 핵심 주제 중 하나입니다. 배열과 포인터는 메모리 구조상 밀접한 연관이 있으며, 이를 적절히 이해하면 효율적인 메모리 사용과 고성능 코드를 작성할 수 있습니다. 본 기사에서는 배열과 포인터의 기본 개념부터 이를 활용한 고급 활용법까지 단계적으로 살펴보며, 실전 코드를 통해 이해를 돕고자 합니다.

목차
  1. 포인터와 배열의 관계
    1. 배열과 포인터의 메모리 구조
    2. 배열과 포인터의 차이
    3. 포인터와 배열의 유사성
    4. 활용의 중요성
  2. 포인터를 사용한 배열 접근
    1. 배열 요소에 포인터로 접근하기
    2. 포인터와 배열 인덱스의 활용
    3. 이중 포인터를 활용한 다차원 배열 접근
  3. 포인터 연산과 배열 인덱싱
    1. 포인터 연산과 배열 인덱싱의 비교
    2. 내부 동작의 차이
    3. 최적의 사용 사례
    4. 예제: 두 접근법의 사용
    5. 주의점
  4. 다차원 배열과 포인터
    1. 다차원 배열의 메모리 구조
    2. 다차원 배열을 포인터로 접근하기
    3. 이중 포인터를 활용한 다차원 배열
    4. 포인터를 이용한 효율적인 요소 접근
    5. 주의점
  5. 동적 배열과 포인터
    1. 동적 배열 생성
    2. 동적 배열 크기 조정
    3. 동적 2차원 배열 생성
    4. 주의점
  6. 배열 접근 시 발생할 수 있는 오류
    1. 배열 경계를 초과하는 접근
    2. 포인터 초기화 문제
    3. 메모리 누수
    4. 다차원 배열 접근 오류
    5. 동적 배열 크기 오류
    6. 해결을 위한 모범 사례
  7. 실전 코드 예제와 연습 문제
    1. 예제 1: 배열 요소 합 계산
    2. 예제 2: 배열 뒤집기
    3. 예제 3: 2차원 배열의 행별 합 계산
    4. 연습 문제
    5. 연습 문제 해설
  8. 요약

포인터와 배열의 관계


포인터와 배열은 C언어에서 메모리를 다루는 데 중요한 두 가지 요소로, 이들의 관계를 이해하면 효율적인 메모리 관리를 할 수 있습니다.

배열과 포인터의 메모리 구조


배열은 연속된 메모리 공간에 저장되며, 배열의 이름은 첫 번째 요소의 주소를 가리키는 포인터로 작동합니다. 예를 들어, int arr[5]라는 배열에서 arr은 &arr[0]과 동일한 메모리 주소를 가집니다.

배열과 포인터의 차이


배열 이름은 상수 포인터로, 재할당할 수 없지만 포인터 변수는 다른 메모리 주소를 가리키도록 변경할 수 있습니다.
예:

int arr[3] = {1, 2, 3};
int *ptr = arr; // 포인터는 배열의 첫 번째 요소를 가리킴
ptr++;          // 포인터는 다음 요소를 가리킬 수 있음

포인터와 배열의 유사성


배열 요소 접근은 포인터를 사용한 간접 참조와 본질적으로 동일합니다.

  • arr[2]는 사실 *(arr + 2)로 해석됩니다.
    이러한 유사성은 배열과 포인터를 상호 교환적으로 사용할 수 있는 근거가 됩니다.

활용의 중요성


포인터와 배열의 관계를 이해하면 메모리 효율성과 코드의 유연성을 높일 수 있습니다. 예를 들어, 함수에 배열을 전달할 때 포인터를 사용하면 메모리 복사를 피할 수 있습니다.

void printArray(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
}


이처럼 포인터와 배열은 효율적인 C 프로그래밍의 핵심 요소로, 이를 적절히 활용하는 것이 중요합니다.

포인터를 사용한 배열 접근


포인터를 활용하면 배열 요소에 효율적으로 접근할 수 있으며, 이는 특히 반복문과 함께 사용할 때 유용합니다. 배열의 이름이 첫 번째 요소의 주소를 가리키므로 포인터 연산을 통해 배열 요소에 접근할 수 있습니다.

배열 요소에 포인터로 접근하기


포인터를 사용하여 배열 요소를 접근하는 기본 예제는 다음과 같습니다.

#include <stdio.h>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int *ptr = arr; // 배열의 첫 번째 요소를 가리키는 포인터

    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, *(ptr + i)); // 포인터 연산으로 요소 접근
    }
    return 0;
}

위 코드에서 *(ptr + i)는 배열의 arr[i]와 동일하게 동작합니다.

포인터와 배열 인덱스의 활용


포인터는 배열 인덱스를 대체하거나, 배열과 함께 사용해 더욱 유연한 코드를 작성할 수 있습니다.

  • 배열 인덱스 사용: arr[i]
  • 포인터 연산 사용: *(arr + i)

예를 들어, 포인터를 사용하면 배열을 뒤집는 코드를 다음과 같이 작성할 수 있습니다.

#include <stdio.h>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int *start = arr;
    int *end = arr + 4;

    while (start < end) {
        int temp = *start;
        *start = *end;
        *end = temp;

        start++;
        end--;
    }

    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

이중 포인터를 활용한 다차원 배열 접근


이중 포인터를 사용하면 2차원 배열의 각 요소에 동적으로 접근할 수 있습니다.

#include <stdio.h>

int main() {
    int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
    int (*ptr)[3] = arr; // 3개의 요소를 가진 배열을 가리키는 포인터

    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            printf("arr[%d][%d] = %d\n", i, j, *(*(ptr + i) + j));
        }
    }
    return 0;
}

포인터를 활용한 배열 접근은 배열을 다루는 유연성과 효율성을 극대화할 수 있는 중요한 기술입니다.

포인터 연산과 배열 인덱싱


포인터 연산과 배열 인덱싱은 배열 요소에 접근하는 두 가지 주요 방식으로, 각각의 장단점이 있습니다. 이 섹션에서는 두 접근법의 차이점과 최적의 사용 사례를 설명합니다.

포인터 연산과 배열 인덱싱의 비교

  1. 배열 인덱싱
    배열 인덱싱은 배열의 특정 요소를 간단하고 직관적으로 참조할 수 있는 방식입니다.
   int arr[5] = {10, 20, 30, 40, 50};
   printf("%d\n", arr[2]); // 출력: 30
  • 장점: 가독성이 높고 코드 작성이 간편함.
  • 단점: 배열의 경계를 초과하는 접근 시 오류 발생 가능성.
  1. 포인터 연산
    포인터 연산은 배열 요소의 주소를 직접 참조하고 이동하면서 요소를 접근합니다.
   int arr[5] = {10, 20, 30, 40, 50};
   int *ptr = arr;
   printf("%d\n", *(ptr + 2)); // 출력: 30
  • 장점: 배열의 메모리를 직접 제어할 수 있어 고급 작업에 유리.
  • 단점: 초심자에게는 가독성이 떨어질 수 있음.

내부 동작의 차이

  • 배열 인덱싱 arr[i]는 내부적으로 *(arr + i)로 변환됩니다.
    배열 인덱싱은 사실 포인터 연산을 캡슐화한 형태로, 컴파일러가 포인터 산술을 자동으로 수행합니다.
  • 따라서, 포인터 연산을 직접 사용하는 것이 배열 인덱싱과 동일한 성능을 가질 수 있습니다.

최적의 사용 사례

  • 배열 인덱싱이 유리한 경우
  • 단순한 데이터 접근 및 읽기 작업.
  • 코드의 가독성이 중요한 경우.
  • 포인터 연산이 유리한 경우
  • 데이터의 이동 및 동적 메모리 조작이 필요한 작업.
  • 반복문과 함께 메모리를 효율적으로 관리할 때.

예제: 두 접근법의 사용

#include <stdio.h>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};

    // 배열 인덱싱
    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    // 포인터 연산
    int *ptr = arr;
    for (int i = 0; i < 5; i++) {
        printf("*(ptr + %d) = %d\n", i, *(ptr + i));
    }

    return 0;
}

주의점

  • 포인터 연산을 사용할 때는 배열의 경계를 넘어 접근하지 않도록 주의해야 합니다.
  • 메모리 안정성을 확보하기 위해 적절한 검사를 포함해야 합니다.

포인터 연산과 배열 인덱싱의 적절한 활용은 C언어 프로그래밍에서 성능과 코드 가독성을 동시에 향상시키는 데 필수적입니다.

다차원 배열과 포인터


다차원 배열은 복잡한 데이터 구조를 표현하는 데 유용하며, 이를 포인터와 함께 사용하면 더욱 효율적인 데이터 접근이 가능합니다. 이 섹션에서는 다차원 배열과 포인터를 활용한 요소 접근 방법을 다룹니다.

다차원 배열의 메모리 구조


C언어의 다차원 배열은 메모리 상에서 연속적으로 저장됩니다.
예를 들어, int arr[2][3] 배열은 다음과 같이 메모리 상에 배치됩니다.

arr[0][0], arr[0][1], arr[0][2], arr[1][0], arr[1][1], arr[1][2]

즉, 행 우선(row-major) 방식으로 저장됩니다.

다차원 배열을 포인터로 접근하기

  1. 배열 이름은 첫 번째 행의 주소를 가리키는 포인터로 동작합니다.
   int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
   printf("%d\n", *arr[0]); // 출력: 1
  1. 행과 열의 요소 접근은 포인터 연산을 사용해 수행할 수 있습니다.
   printf("%d\n", *(*(arr + 1) + 2)); // 출력: 6 (arr[1][2])

이중 포인터를 활용한 다차원 배열


이중 포인터는 다차원 배열에 대한 동적 접근을 가능하게 합니다.

#include <stdio.h>
#include <stdlib.h>

int main() {
    int rows = 2, cols = 3;
    int **arr = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++) {
        arr[i] = (int *)malloc(cols * sizeof(int));
    }

    // 값 초기화
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            arr[i][j] = i * cols + j;
        }
    }

    // 값 출력
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }

    // 메모리 해제
    for (int i = 0; i < rows; i++) {
        free(arr[i]);
    }
    free(arr);

    return 0;
}

위 예제는 동적 메모리를 사용해 다차원 배열을 생성하고 접근하는 방법을 보여줍니다.

포인터를 이용한 효율적인 요소 접근


포인터를 사용하면 다차원 배열의 행렬 연산이나 데이터 변환과 같은 작업에서 성능을 최적화할 수 있습니다.

#include <stdio.h>

void printMatrix(int (*matrix)[3], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
    printMatrix(arr, 2);
    return 0;
}

위 코드에서 함수는 다차원 배열을 포인터로 받아 메모리를 효율적으로 처리합니다.

주의점

  • 다차원 배열의 인덱스를 사용할 때, 포인터 연산으로 인한 경계 초과를 주의해야 합니다.
  • 동적 메모리를 사용할 경우 반드시 적절히 메모리를 해제해야 메모리 누수를 방지할 수 있습니다.

다차원 배열과 포인터를 결합하여 활용하면 복잡한 데이터 구조를 효율적으로 다룰 수 있습니다.

동적 배열과 포인터


동적 배열은 런타임에 크기를 결정하는 배열로, 메모리를 효율적으로 활용할 수 있게 합니다. 포인터를 사용하면 동적 배열을 생성하고 관리할 수 있습니다. 이 섹션에서는 동적 배열 생성, 요소 접근, 메모리 해제까지의 전체 과정을 다룹니다.

동적 배열 생성


C언어에서 동적 배열은 malloc이나 calloc 함수를 사용해 생성합니다.
예:

#include <stdio.h>
#include <stdlib.h>

int main() {
    int size = 5;
    int *arr = (int *)malloc(size * sizeof(int)); // 크기 5의 동적 배열 생성

    if (arr == NULL) {
        printf("메모리 할당 실패\n");
        return 1;
    }

    for (int i = 0; i < size; i++) {
        arr[i] = i * 10; // 배열 초기화
    }

    for (int i = 0; i < size; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    free(arr); // 메모리 해제
    return 0;
}

위 코드는 런타임에 배열 크기를 결정하고 메모리를 할당합니다.

동적 배열 크기 조정


동적 배열의 크기를 변경할 때는 realloc 함수를 사용합니다.

#include <stdio.h>
#include <stdlib.h>

int main() {
    int size = 5;
    int *arr = (int *)malloc(size * sizeof(int));
    if (arr == NULL) {
        printf("메모리 할당 실패\n");
        return 1;
    }

    // 배열 크기 변경
    size = 10;
    arr = (int *)realloc(arr, size * sizeof(int));
    if (arr == NULL) {
        printf("메모리 재할당 실패\n");
        return 1;
    }

    for (int i = 0; i < size; i++) {
        arr[i] = i * 10; // 배열 초기화
    }

    for (int i = 0; i < size; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    free(arr);
    return 0;
}

위 코드는 기존 배열의 크기를 확장하면서 데이터를 유지합니다.

동적 2차원 배열 생성


동적 메모리를 사용해 2차원 배열을 생성하는 예제는 다음과 같습니다.

#include <stdio.h>
#include <stdlib.h>

int main() {
    int rows = 3, cols = 4;
    int **matrix = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int *)malloc(cols * sizeof(int));
    }

    // 초기화
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = i * cols + j;
        }
    }

    // 출력
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    // 메모리 해제
    for (int i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);

    return 0;
}

동적 2차원 배열은 행렬 연산과 같은 작업에서 유용합니다.

주의점

  1. 메모리 누수 방지: 동적 배열은 사용 후 반드시 free로 해제해야 합니다.
  2. 할당 실패 처리: 메모리 할당 함수는 실패 시 NULL을 반환하므로 이를 항상 확인해야 합니다.
  3. 초기화 필요: 동적 배열은 초기화되지 않은 상태로 할당되므로 값을 수동으로 설정해야 합니다.

동적 배열과 포인터를 적절히 사용하면 유연한 데이터 구조를 구현할 수 있으며, 복잡한 작업에서도 메모리 효율을 극대화할 수 있습니다.

배열 접근 시 발생할 수 있는 오류


포인터를 사용해 배열에 접근할 때는 다양한 오류가 발생할 수 있으며, 이는 프로그램의 안정성과 성능에 영향을 미칠 수 있습니다. 이 섹션에서는 주요 오류와 이를 방지하는 방법을 설명합니다.

배열 경계를 초과하는 접근


배열의 크기를 초과해 요소에 접근하면 정의되지 않은 동작이 발생합니다.
예:

int arr[5] = {1, 2, 3, 4, 5};
printf("%d\n", arr[10]); // 잘못된 접근
  • 원인: 배열의 경계는 컴파일러에서 자동으로 확인되지 않으므로 경계를 초과할 경우 예기치 않은 메모리를 읽거나 쓸 수 있습니다.
  • 해결 방법: 배열 크기를 확인하거나, 반복문에서 경계를 명시적으로 검사합니다.
  for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
      printf("%d\n", arr[i]);
  }

포인터 초기화 문제


포인터를 초기화하지 않거나 NULL 포인터를 역참조하면 프로그램이 충돌할 수 있습니다.
예:

int *ptr;
*ptr = 10; // 초기화되지 않은 포인터를 사용한 잘못된 접근
  • 해결 방법: 포인터는 사용 전에 반드시 유효한 주소로 초기화해야 합니다.
  int val = 10;
  int *ptr = &val; // 올바른 초기화

메모리 누수


동적 배열을 생성한 후 적절히 해제하지 않으면 메모리 누수가 발생할 수 있습니다.
예:

int *arr = (int *)malloc(5 * sizeof(int));
// free(arr); // 메모리를 해제하지 않으면 누수 발생
  • 해결 방법: 사용 후 반드시 free를 호출하여 메모리를 해제합니다.

다차원 배열 접근 오류


다차원 배열을 포인터로 접근할 때, 잘못된 인덱스 계산으로 예상치 못한 데이터에 접근할 수 있습니다.
예:

int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
int *ptr = &arr[0][0];
printf("%d\n", *(ptr + 5)); // 올바른 접근: arr[1][2]
printf("%d\n", *(ptr + 6)); // 잘못된 접근: 배열 초과
  • 해결 방법: 포인터 연산 시 올바른 인덱스 계산을 유지하고, 배열 크기를 확인합니다.

동적 배열 크기 오류


동적 배열을 할당할 때 크기를 잘못 계산하면 메모리 낭비 또는 데이터 손실이 발생할 수 있습니다.
예:

int *arr = (int *)malloc(4); // 요소 크기 계산 누락
  • 해결 방법: 항상 요소의 크기를 고려하여 메모리를 할당합니다.
  int *arr = (int *)malloc(5 * sizeof(int)); // 올바른 할당

해결을 위한 모범 사례

  • 배열 및 포인터 사용 시 경계 검사 추가.
  • 포인터 초기화와 메모리 해제 철저히 관리.
  • 동적 메모리 할당 크기를 정확히 계산.

배열 접근 오류를 예방하면 프로그램의 안정성과 신뢰성을 대폭 향상시킬 수 있습니다. 이러한 모범 사례를 실천하는 것이 중요합니다.

실전 코드 예제와 연습 문제


포인터를 활용해 배열을 다루는 다양한 실전 예제를 살펴보고, 이를 바탕으로 학습을 심화할 수 있는 연습 문제를 제공합니다.

예제 1: 배열 요소 합 계산


포인터를 사용해 배열 요소의 합을 계산하는 코드입니다.

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int *ptr = arr; // 배열의 첫 번째 요소를 가리키는 포인터
    int sum = 0;

    for (int i = 0; i < 5; i++) {
        sum += *(ptr + i); // 포인터 연산을 사용해 요소 접근
    }

    printf("배열 요소의 합: %d\n", sum);
    return 0;
}

출력 결과:

배열 요소의 합: 15

예제 2: 배열 뒤집기


포인터를 사용해 배열의 요소를 뒤집는 코드입니다.

#include <stdio.h>

int main() {
    int arr[6] = {10, 20, 30, 40, 50, 60};
    int *start = arr;
    int *end = arr + 5;

    while (start < end) {
        int temp = *start;
        *start = *end;
        *end = temp;

        start++;
        end--;
    }

    for (int i = 0; i < 6; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

출력 결과:

60 50 40 30 20 10

예제 3: 2차원 배열의 행별 합 계산


포인터를 사용해 2차원 배열의 각 행의 합을 계산하는 코드입니다.

#include <stdio.h>

int main() {
    int arr[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
    int rows = 3, cols = 4;

    for (int i = 0; i < rows; i++) {
        int sum = 0;
        for (int j = 0; j < cols; j++) {
            sum += *(*(arr + i) + j); // 포인터로 요소 접근
        }
        printf("행 %d의 합: %d\n", i + 1, sum);
    }

    return 0;
}

출력 결과:

행 1의 합: 10  
행 2의 합: 26  
행 3의 합: 42

연습 문제

  1. 최댓값 찾기
    포인터를 사용하여 배열의 최댓값을 찾는 함수를 작성하세요.
   int findMax(int *arr, int size);
  1. 동적 배열 평균 계산
    사용자가 입력한 크기와 요소를 기반으로 동적 배열을 생성하고 평균값을 계산하세요.
   double calculateAverage(int *arr, int size);
  1. 2차원 배열 전치(transpose)
    포인터를 사용하여 2차원 배열의 전치를 계산하는 코드를 작성하세요.
  2. 특정 값 찾기
    포인터를 사용하여 배열에서 특정 값을 검색하고, 해당 값의 인덱스를 반환하는 함수를 작성하세요.
   int findValue(int *arr, int size, int target);

연습 문제 해설


연습 문제를 해결하며 포인터와 배열의 활용 능력을 높이고, 실전 프로젝트에서 유용하게 적용할 수 있는 스킬을 익히세요. 필요하다면 위의 실전 예제를 참고해 풀이를 작성하세요.

요약


본 기사에서는 C언어에서 포인터를 활용해 배열 요소를 효율적으로 접근하고 관리하는 방법을 다뤘습니다. 배열과 포인터의 관계, 포인터 연산과 배열 인덱싱의 차이, 다차원 배열 및 동적 배열의 활용법을 구체적으로 설명했습니다. 또한, 발생할 수 있는 주요 오류와 이를 방지하는 방법, 실전 코드 예제와 연습 문제를 통해 실무 활용 능력을 강화할 수 있도록 했습니다. 포인터를 활용한 배열 접근은 효율적인 메모리 관리와 고성능 코드 작성에 필수적인 기술임을 다시 한번 강조합니다.

C 언어
C언어 메모리 관리 배열 포인터
목차
  1. 포인터와 배열의 관계
    1. 배열과 포인터의 메모리 구조
    2. 배열과 포인터의 차이
    3. 포인터와 배열의 유사성
    4. 활용의 중요성
  2. 포인터를 사용한 배열 접근
    1. 배열 요소에 포인터로 접근하기
    2. 포인터와 배열 인덱스의 활용
    3. 이중 포인터를 활용한 다차원 배열 접근
  3. 포인터 연산과 배열 인덱싱
    1. 포인터 연산과 배열 인덱싱의 비교
    2. 내부 동작의 차이
    3. 최적의 사용 사례
    4. 예제: 두 접근법의 사용
    5. 주의점
  4. 다차원 배열과 포인터
    1. 다차원 배열의 메모리 구조
    2. 다차원 배열을 포인터로 접근하기
    3. 이중 포인터를 활용한 다차원 배열
    4. 포인터를 이용한 효율적인 요소 접근
    5. 주의점
  5. 동적 배열과 포인터
    1. 동적 배열 생성
    2. 동적 배열 크기 조정
    3. 동적 2차원 배열 생성
    4. 주의점
  6. 배열 접근 시 발생할 수 있는 오류
    1. 배열 경계를 초과하는 접근
    2. 포인터 초기화 문제
    3. 메모리 누수
    4. 다차원 배열 접근 오류
    5. 동적 배열 크기 오류
    6. 해결을 위한 모범 사례
  7. 실전 코드 예제와 연습 문제
    1. 예제 1: 배열 요소 합 계산
    2. 예제 2: 배열 뒤집기
    3. 예제 3: 2차원 배열의 행별 합 계산
    4. 연습 문제
    5. 연습 문제 해설
  8. 요약