1. 소방기본법
2. 화재 예방 및 안전관리에 관한 법률 = 화재 예방법
3. 소방 시설 설치 및 관리에 관한 법률 = 소방 시설법

4. 다중이용업소법
5. 초고층재난관리법
6. 재난안전법
7. 위험물안전관리법

이 중 1,2,3번이 가장 중요하고 출제 비중이 높음 사유는 이 3가지가 소방안전관리자 과정에서 가장 유구한 역사를 가지고 있기 때문

소방기본법 > 예경진구조구급,공공의 안녕 및 질서 유지

화재 예방법과 소방시설법 > 원래 하나였다가 둘로 쪼개진법이기때문에 주목적이 같다. 공공의 안전과 복리증진 이바지

특정 소방 대상물은 용도를 파악해서 아예 건물안에 소방 시설을 설치해야하는 소방 대상물로 보는게 특정 소방 대상물

그리고 소방시설은 이 특정소방대상물에 집어넣는 소방 설비

소방시설등은 소방시설에 포함 안되는 기타 등등은 소방시설등이라 뭉뚱그려 말함

그리고 원칙상 소방안전관리자는 관계인엔 포함되지 않는다.

관계 지역은 가볍게 읽고

이 경우 둘다 피난층

소방안전관리대상물은 소방 대상물 중에서도 특정 소방 대상물(소화 시설 보관해야하는 건축물)이 있고, 그 특정 소방 대상물중에서도 소방안전관리자를 선임해야하는 건축물이 있는데 그걸 소방안전관리대상물이라함.

11.1 레슨에서 '함수 오버로딩'에 대해 배웠던 것 기억하시나요? 함수 오버로딩은 이름은 같지만 전달받는 재료(매개변수)가 다른 여러 개의 함수를 만들 수 있게 해주는 편리한 기능입니다. 덕분에 다루는 데이터의 종류가 달라도 매번 새로운 함수 이름을 지어낼 필요 없이 같은 이름의 함수를 사용할 수 있었죠.

C++에서는 +나 - 같은 '연산자(operator)'들도 사실은 내부적으로 함수처럼 작동합니다. 따라서 이 연산자 함수들에 함수 오버로딩 기능을 적용하면, 우리가 직접 만든 클래스 같은 새로운 데이터 타입에 맞춰 연산자의 작동 방식을 새롭게 정의할 수 있습니다. 이렇게 기존 연산자에 나만의 새로운 능력을 부여하는 것을 바로 '연산자 오버로딩'이라고 부릅니다.

이번 장에서는 이 연산자 오버로딩과 관련된 다양한 주제들을 하나씩 살펴보겠습니다.

함수로서의 연산자

다음 예시를 한번 볼까요?

int x { 2 };
int y { 3 };
std::cout << x + y << '\n';

컴파일러(코드를 컴퓨터 언어로 번역해 주는 프로그램)는 숫자(정수)들을 더할 수 있는 더하기 연산자(+)를 기본적으로 내장하고 있습니다. 이 연산자 함수는 x와 y라는 정수를 받아서 두 값을 더한 뒤, 그 결과인 정수를 돌려줍니다. 코드를 읽으실 때 x + y라는 수식을 보시면, 머릿속으로는 이것이 operator+(x, y)라는 함수를 호출하는 것과 똑같다고 생각하시면 이해하기 쉽습니다. (여기서 함수 이름이 operator+인 것이죠!)

자, 이제 아주 비슷한 다음 코드를 볼까요?

double z { 2.0 };
double w { 3.0 };
std::cout << w + z << '\n';

컴파일러는 소수점 숫자(double)를 계산할 수 있는 더하기 연산자(+) 기능도 이미 가지고 있습니다. w + z라는 코드는 operator+(w, z)라는 함수 호출로 바뀝니다. 이때 컴파일러는 똑똑하게도 '함수 오버로딩' 기능을 사용해서, 정수용 더하기 함수가 아니라 소수점용 더하기 함수를 불러와야 한다는 것을 알아냅니다.

그렇다면 우리가 직접 만든 클래스(객체) 두 개를 더하려고 하면 어떤 일이 일어날까요?

Mystring string1 { "Hello, " };
Mystring string2 { "World!" };
std::cout << string1 + string2 << '\n';

이 경우 어떤 결과가 나올까요? 직관적으로는 "Hello, World!"라는 문장이 화면에 예쁘게 출력될 것이라고 기대하게 됩니다. 하지만 Mystring은 우리가 새롭게 만들어낸 타입이기 때문에, 컴파일러는 Mystring끼리 더할 때 쓸 수 있는 + 연산자가 무엇인지 전혀 알지 못합니다. 그래서 이 코드를 실행하면 에러가 발생하게 되죠. 우리가 원하는 대로 코드가 작동하게 만들려면, 컴파일러에게 Mystring 두 개를 더할 때 + 연산자가 어떻게 행동해야 하는지 알려주는 '오버로딩된 함수'를 우리가 직접 만들어 주어야 합니다. 다음 레슨에서 그 방법을 자세히 알아보겠습니다.

오버로딩된 연산자 해결하기 (어떤 연산자를 쓸지 결정하기)

연산자가 포함된 코드를 해석할 때, 컴파일러는 다음과 같은 규칙을 따릅니다.

• 만약 연산하는 값들이 모두 int나 double 같은 C++ 기본 데이터 타입이라면, 컴파일러는 원래 가지고 있는 내장 기능을 사용합니다. 만약 내장된 기능이 없다면 에러를 발생시킵니다.
• 만약 연산하는 값 중 하나라도 우리가 직접 만든 타입(예: 직접 만든 클래스나 enum 타입)이라면, 컴파일러는 '함수 오버로딩 해결 알고리즘'을 사용해서 딱 맞는 오버로딩된 연산자가 있는지 찾아봅니다. 이 과정에서 연산자의 모양에 맞추기 위해 값의 타입을 컴파일러가 알아서(암시적으로) 변환할 수도 있습니다. 만약 내장된 연산자에 맞추기 위해 우리가 만든 타입을 기본 타입으로 자동 변환하는 과정이 일어날 수도 있습니다(이 부분은 나중에 다루겠습니다). 만약 딱 맞는 것을 찾지 못하거나, 어떤 것을 써야 할지 너무 애매하다면 컴파일러는 에러를 뿜어냅니다.

연산자 오버로딩의 한계점 (할 수 없는 것들)

첫째, C++에 있는 거의 모든 연산자를 마음대로 오버로딩할 수 있습니다. 하지만 예외가 몇 가지 있습니다. 조건부 연산자(?:), 크기 확인(sizeof), 범위 지정(::), 멤버 선택(.), 포인터 멤버 선택(.*), 타입 확인(typeid), 그리고 캐스팅(형변환) 연산자들은 오버로딩을 할 수 없습니다.

둘째, 이미 존재하는 연산자만 오버로딩할 수 있습니다. 새로운 기호를 만들어내거나 기존 기호의 이름을 바꿀 수는 없습니다. 예를 들어, 거듭제곱 계산을 하겠다고 **라는 완전히 새로운 연산자를 창조해 낼 수는 없습니다.

셋째, 오버로딩하려는 연산자의 양쪽 값 중 최소한 하나는 사용자가 직접 만든 타입이어야 합니다. 즉, operator+(int, Mystring)처럼 정수와 우리가 만든 문자열 클래스를 더하는 기능은 만들 수 있지만, operator+(int, double)처럼 C++ 기본 타입들끼리의 계산법을 마음대로 뜯어고칠 수는 없습니다.

참고로 C++ 표준 라이브러리(예: std::string)도 사용자가 만든 타입으로 간주됩니다. 그래서 이론적으로는 operator+(double, std::string) 같은 오버로딩도 가능은 합니다. 하지만 훗날 C++ 언어가 업데이트되면서 이런 연산자를 공식적으로 지원하게 되면 우리 프로그램이 망가질 수 있기 때문에, 이렇게 하는 것은 좋은 생각이 아닙니다.

권장 사항 오버로딩된 연산자는 최소한 하나 이상의 프로그램 정의 타입(우리가 직접 만든 타입)과 함께 사용되어야 합니다. 그래야 미래에 C++ 표준이 업데이트되더라도 프로그램에 문제가 생기지 않습니다.

넷째, 연산자가 원래 가지고 있는 피연산자(계산에 필요한 값)의 개수를 바꿀 수 없습니다. (예를 들어, 값 두 개가 필요한 + 연산자를 값 하나만 받도록 바꿀 수 없습니다.)

마지막으로 아주 중요한 점입니다. 모든 연산자는 원래 가지고 있던 계산 우선순위와 결합 방향을 그대로 유지하며, 이는 절대 바꿀 수 없습니다.

초보 프로그래머들은 종종 비트 기호인 ^를 '거듭제곱' 연산자로 오버로딩하려고 시도합니다. 하지만 C++에서 ^ 연산자는 +나 - 같은 기본 사칙연산보다 계산 우선순위가 훨씬 낮기 때문에 문제가 발생합니다.

일반적인 수학에서는 거듭제곱을 사칙연산보다 먼저 계산하므로, 4 + 3 ^ 2는 4 + (3의 2제곱)이 되어 4 + 9 => 13이 됩니다.

하지만 C++에서는 + 연산자가 ^ 연산자보다 먼저 계산됩니다! 따라서 C++에서 4 + 3 ^ 2라고 쓰면 (4 + 3)이 먼저 계산되어 7 ^ 2가 되고, 결과는 어이없게도 49가 되어버립니다.

이걸 제대로 작동하게 하려면 매번 4 + (3 ^ 2)처럼 명시적으로 괄호를 쳐야 하는데, 이는 직관적이지도 않고 실수하기도 딱 좋습니다.

이러한 우선순위 문제 때문에, 연산자는 원래 의도된 쓰임새와 가장 비슷한 방식으로만 오버로딩하는 것이 좋습니다.

권장 사항 연산자를 오버로딩할 때는, 해당 연산자의 원래 의도나 기능과 최대한 가깝게 만드는 것이 제일 좋습니다.

게다가 연산자들은 이름이 기호로만 되어 있어서 무슨 역할을 하는지 한눈에 알기 어려울 때가 많습니다. 예를 들어, 문자열 클래스에서 + 연산자를 '두 문자열 하나로 합치기'로 쓰는 것은 아주 자연스럽습니다. 하지만 - 연산자는 어떨까요? 문자열에서 - 연산이 무슨 의미일지 딱 떠오르지 않습니다. 이럴 때는 코드를 읽는 사람이 헷갈리기 쉽습니다.

권장 사항 오버로딩하려는 연산자의 의미가 직관적이고 명확하지 않다면, 무리해서 기호를 쓰지 말고 그냥 이해하기 쉬운 단어로 된 일반 함수를 새로 만드세요.

마지막으로, 오버로딩된 연산자는 원래 연산자와 일관된 방식으로 값을 돌려주어야(반환해야) 합니다. +나 -처럼 원래의 값을 바꾸지 않는 연산자들은 계산된 '새로운 결과값' 자체를 반환해야 합니다. 반면에 원래의 값을 변경하는 연산자(예: ++ 증가 연산자나 대입 연산자)는 변경된 대상(왼쪽 값)을 '참조(reference)' 형태로 반환하는 것이 일반적입니다.

권장 사항 원본 값을 변경하지 않는 연산자(예: 사칙연산)는 일반적으로 결과를 값(value)으로 반환해야 합니다. 왼쪽 원본 값을 변경하는 연산자(예: 전위 증감 연산자, 대입 연산자)는 일반적으로 왼쪽 원본 값을 참조(reference)로 반환해야 합니다.

이런 몇 가지 규칙들만 잘 지킨다면, 여러분이 만든 클래스에 정말 다양하고 유용한 기능들을 마음껏 추가할 수 있습니다! 문자열 클래스에 +를 써서 글자들을 덧붙이거나, 분수 클래스 두 개를 더할 수도 있죠. << 연산자를 오버로딩하면 우리가 만든 객체의 정보를 화면이나 파일에 아주 쉽게 출력할 수도 있습니다. == 연산자로 두 객체가 똑같은지 비교할 수도 있고요. 이처럼 연산자 오버로딩은 우리가 만든 클래스를 마치 C++의 기본 기능처럼 자연스럽고 편리하게 쓸 수 있게 해주기 때문에, C++에서 가장 강력하고 유용한 기능 중 하나로 꼽힙니다.

이어지는 다음 레슨들에서는 다양한 종류의 연산자들을 실제로 어떻게 오버로딩하는지 조금 더 깊이 파헤쳐 보겠습니다.

21.2 — 프렌드(friend) 함수를 사용한 산술 연산자 오버로딩

C++에서 가장 자주 쓰이는 연산자 중 하나가 바로 산술 연산자입니다. 더하기(+), 빼기(-), 곱하기(*), 나누기(/)가 여기에 속하죠. 이 산술 연산자들은 모두 이항 연산자(binary operator)라는 공통점이 있습니다. 이항 연산자란 연산자를 기준으로 양쪽에 하나씩, 총 두 개의 값(피연산자)이 필요하다는 뜻이에요. 이 네 가지 연산자는 모두 완전히 똑같은 방식으로 오버로딩(재정의)할 수 있답니다.

연산자를 오버로딩하는 방법에는 크게 세 가지가 있습니다. '멤버 함수'를 쓰는 방법, '프렌드(friend) 함수'를 쓰는 방법, 그리고 '일반 함수'를 쓰는 방법이죠.

이번 레슨에서는 프렌드 함수를 사용하는 방법을 먼저 배워볼게요. (이항 연산자에서는 이 방법이 제일 직관적이고 이해하기 쉽거든요!)

다음 레슨에서는 일반 함수를 쓰는 법을 알아보고, 이번 챕터 후반부에서는 멤버 함수를 쓰는 법을 다룰 예정입니다. 물론 각각의 방법을 언제 써야 하는지도 나중에 자세히 정리해 드릴게요.

프렌드(friend) 함수로 연산자 오버로딩하기

먼저 아래의 클래스를 한번 살펴볼까요?

class Cents
{
private:
    int m_cents {};

public:
    Cents(int cents) : m_cents{ cents } { }
    int getCents() const { return m_cents; }
};

다음 예제는 두 개의 Cents 객체를 서로 더하기 위해 더하기(+) 연산자를 어떻게 오버로딩하는지 보여줍니다.

#include <iostream>

class Cents
{
private:
    int m_cents {};

public:
    Cents(int cents) : m_cents{ cents } { }

    // 프렌드 함수를 사용하여 Cents + Cents 더하기
    friend Cents operator+(const Cents& c1, const Cents& c2);

    int getCents() const { return m_cents; }
};

// 참고: 이 함수는 멤버 함수가 아닙니다!
Cents operator+(const Cents& c1, const Cents& c2)
{
    // Cents 생성자와 기본 연산자 +(int, int)를 사용합니다
    // 프렌드 함수이기 때문에 m_cents에 직접 접근할 수 있습니다
    return c1.m_cents + c2.m_cents;
}

int main()
{
    Cents cents1{ 6 };
    Cents cents2{ 8 };
    Cents centsSum{ cents1 + cents2 };
    std::cout << "I have " << centsSum.getCents() << " cents.\n";

    return 0;
}

이 코드를 실행하면 다음과 같은 결과가 나옵니다.

I have 14 cents.

더하기(+) 연산자를 오버로딩하는 건 생각보다 아주 간단해요! operator+라는 이름의 함수를 만들고, 우리가 더하고 싶은 두 개의 값을 매개변수로 넣어준 뒤, 적절한 반환 타입(결과값의 형태)을 정해서 함수 내용을 작성하기만 하면 끝이랍니다.

우리가 만든 Cents 객체의 경우, operator+() 함수를 만드는 과정은 정말 쉽습니다. 첫째, 매개변수 타입입니다. 이번에 만들 operator+는 두 개의 Cents 객체를 더할 것이기 때문에, 함수도 두 개의 Cents 타입 객체를 받아야 합니다. 둘째, 반환 타입입니다. operator+의 계산 결과 역시 새로운 Cents 객체가 되어야 하므로, 반환 타입도 Cents로 정해줍니다.

마지막으로 함수 구현입니다. 두 개의 Cents 객체를 더한다는 건, 결국 각 객체 안에 들어있는 m_cents라는 숫자(멤버 변수)끼리 더한다는 뜻이에요. 우리가 만든 오버로딩 함수는 클래스의 '프렌드(friend)'로 등록되어 있기 때문에, 객체 안의 숨겨진(private) m_cents 변수에 직접 접근할 수 있습니다. 그리고 m_cents는 단순한 정수형(int)이기 때문에, C++이 기본적으로 제공하는 덧셈 기능을 써서 그냥 + 기호로 더해주면 됩니다.

빼기(-) 연산자를 오버로딩하는 것도 똑같이 쉽습니다!

#include <iostream>

class Cents
{
private:
    int m_cents {};

public:
    explicit Cents(int cents) : m_cents{ cents } { }

    // 프렌드 함수를 사용하여 Cents + Cents 더하기
    friend Cents operator+(const Cents& c1, const Cents& c2);

    // 프렌드 함수를 사용하여 Cents - Cents 빼기
    friend Cents operator-(const Cents& c1, const Cents& c2);

    int getCents() const { return m_cents; }
};

// 참고: 이 함수는 멤버 함수가 아닙니다!
Cents operator+(const Cents& c1, const Cents& c2)
{
    // Cents 생성자와 기본 연산자 +(int, int)를 사용합니다
    // 프렌드 함수이기 때문에 m_cents에 직접 접근할 수 있습니다
    return Cents { c1.m_cents + c2.m_cents };
}

// 참고: 이 함수는 멤버 함수가 아닙니다!
Cents operator-(const Cents& c1, const Cents& c2)
{
    // Cents 생성자와 기본 연산자 -(int, int)를 사용합니다
    // 프렌드 함수이기 때문에 m_cents에 직접 접근할 수 있습니다
    return Cents { c1.m_cents - c2.m_cents };
}

int main()
{
    Cents cents1{ 6 };
    Cents cents2{ 2 };
    Cents centsSum{ cents1 - cents2 };
    std::cout << "I have " << centsSum.getCents() << " cents.\n";

    return 0;
}

곱하기(*)나 나누기(/) 연산자 역시, 각각 operator*와 operator/라는 이름으로 함수를 정의해주기만 하면 똑같이 쉽게 오버로딩할 수 있습니다.

프렌드 함수를 클래스 내부에 정의하기

프렌드 함수는 클래스의 멤버 함수가 아니지만, 원한다면 클래스 코드 블록 안쪽에 직접 정의(작성)할 수도 있습니다.

#include <iostream>

class Cents
{
private:
    int m_cents {};

public:
    explicit Cents(int cents) : m_cents{ cents } { }

    // 프렌드 함수를 사용하여 Cents + Cents 더하기
    // 정의가 클래스 내부에 있더라도, 이 함수는 클래스의 멤버로 간주되지 않습니다.
    friend Cents operator+(const Cents& c1, const Cents& c2)
    {
        // Cents 생성자와 기본 연산자 +(int, int)를 사용합니다
        // 프렌드 함수이기 때문에 m_cents에 직접 접근할 수 있습니다
        return Cents { c1.m_cents + c2.m_cents };
    }

    int getCents() const { return m_cents; }
};

int main()
{
    Cents cents1{ 6 };
    Cents cents2{ 8 };
    Cents centsSum{ cents1 + cents2 };
    std::cout << "I have " << centsSum.getCents() << " cents.\n";

    return 0;
}

구현 내용이 아주 짧고 단순한 오버로딩 연산자라면 이렇게 클래스 안에 바로 작성하는 것도 괜찮은 방법입니다.

서로 다른 타입의 피연산자를 위한 연산자 오버로딩

연산자를 만들다 보면, 서로 다른 타입의 값을 더하거나 빼고 싶을 때가 자주 생깁니다. 예를 들어, Cents(4)라는 객체에 숫자 6(정수형)을 더해서 Cents(10)이라는 결과를 만들고 싶은 경우처럼 말이죠.

C++이 x + y라는 식을 계산할 때, 앞의 x는 첫 번째 매개변수가 되고 뒤의 y는 두 번째 매개변수가 됩니다. 만약 x와 y가 같은 타입이라면 x + y를 하든 y + x를 하든 상관이 없습니다. 둘 다 똑같은 버전의 operator+ 함수를 불러오니까요. 하지만 서로 다른 타입이라면 이야기가 달라집니다. x + y를 할 때와 y + x를 할 때 호출되는 함수가 서로 다릅니다.

예를 들어, Cents(4) + 6은 operator+(Cents, int) 함수를 호출하지만, 반대로 6 + Cents(4)는 operator+(int, Cents) 함수를 호출합니다. 결과적으로 서로 다른 타입의 값을 더하는 이항 연산자를 만들고 싶다면, 순서가 바뀌는 두 가지 경우를 위해 함수를 2개 작성해야 합니다. 아래 예제를 확인해 보세요!

#include <iostream>

class Cents
{
private:
    int m_cents {};

public:
    explicit Cents(int cents) : m_cents{ cents } { }

    // 프렌드 함수를 사용하여 Cents + int 더하기
    friend Cents operator+(const Cents& c1, int value);

    // 프렌드 함수를 사용하여 int + Cents 더하기
    friend Cents operator+(int value, const Cents& c1);


    int getCents() const { return m_cents; }
};

// 참고: 이 함수는 멤버 함수가 아닙니다!
Cents operator+(const Cents& c1, int value)
{
    // Cents 생성자와 기본 연산자 +(int, int)를 사용합니다
    // 프렌드 함수이기 때문에 m_cents에 직접 접근할 수 있습니다
    return Cents { c1.m_cents + value };
}

// 참고: 이 함수는 멤버 함수가 아닙니다!
Cents operator+(int value, const Cents& c1)
{
    // Cents 생성자와 기본 연산자 +(int, int)를 사용합니다
    // 프렌드 함수이기 때문에 m_cents에 직접 접근할 수 있습니다
    return Cents { c1.m_cents + value };
}

int main()
{
    Cents c1{ Cents{ 4 } + 6 };
    Cents c2{ 6 + Cents{ 4 } };

    std::cout << "I have " << c1.getCents() << " cents.\n";
    std::cout << "I have " << c2.getCents() << " cents.\n";

    return 0;
}

두 오버로딩 함수가 똑같은 내용으로 작성된 것을 확인하셨나요? 사실 똑같은 덧셈을 하는 건데, 단지 받는 매개변수의 순서만 다를 뿐이기 때문입니다.

또 다른 예제

다른 예제를 하나 더 살펴봅시다.

#include <iostream>

class MinMax
{
private:
    int m_min {}; // 지금까지 확인된 최솟값
    int m_max {}; // 지금까지 확인된 최댓값

public:
    MinMax(int min, int max)
        : m_min { min }, m_max { max }
    { }

    int getMin() const { return m_min; }
    int getMax() const { return m_max; }

    friend MinMax operator+(const MinMax& m1, const MinMax& m2);
    friend MinMax operator+(const MinMax& m, int value);
    friend MinMax operator+(int value, const MinMax& m);
};

MinMax operator+(const MinMax& m1, const MinMax& m2)
{
    // m1과 m2 중 더 작은 값 가져오기
    int min{ m1.m_min < m2.m_min ? m1.m_min : m2.m_min };

    // m1과 m2 중 더 큰 값 가져오기
    int max{ m1.m_max > m2.m_max ? m1.m_max : m2.m_max };

    return MinMax { min, max };
}

MinMax operator+(const MinMax& m, int value)
{
    // m과 value 중 더 작은 값 가져오기
    int min{ m.m_min < value ? m.m_min : value };

    // m과 value 중 더 큰 값 가져오기
    int max{ m.m_max > value ? m.m_max : value };

    return MinMax { min, max };
}

MinMax operator+(int value, const MinMax& m)
{
    // operator+(MinMax, int)를 호출합니다
    return m + value;
}

int main()
{
    MinMax m1{ 10, 15 };
    MinMax m2{ 8, 11 };
    MinMax m3{ 3, 12 };

    MinMax mFinal{ m1 + m2 + 5 + 8 + m3 + 16 };

    std::cout << "Result: (" << mFinal.getMin() << ", " <<
        mFinal.getMax() << ")\n";

    return 0;
}

MinMax 클래스는 지금까지 입력된 값들 중에서 최솟값과 최댓값을 기억하는 역할을 합니다. 여기서는 + 연산자를 무려 3번이나 오버로딩했네요! 이렇게 하면 두 개의 MinMax 객체끼리 더할 수도 있고, MinMax 객체에 일반 정수(int)를 더할 수도 있게 됩니다.

이 예제를 실행하면 다음과 같은 결과가 나옵니다.

Result: (3, 16)

이 결과는 우리가 mFinal을 만들기 위해 더했던 값들 중에서 가장 작은 값(3)과 가장 큰 값(16)이라는 것을 알 수 있죠!

자, 그럼 MinMax mFinal { m1 + m2 + 5 + 8 + m3 + 16 }라는 코드가 어떻게 계산되는지 조금만 더 자세히 알아볼까요? + 연산자는 왼쪽에서 오른쪽으로 차례대로 계산된다는 사실을 기억해 주세요.

1. 먼저 m1 + m2가 계산됩니다. 이는 operator+(m1, m2)를 호출하게 되어, MinMax(8, 15)라는 결과값을 만듭니다.
2. 다음으로 MinMax(8, 15) + 5가 계산됩니다. 이는 operator+(MinMax(8, 15), 5)를 호출하여 MinMax(5, 15)가 됩니다.
3. 이어서 MinMax(5, 15) + 8을 하면, 똑같은 방식으로 MinMax(5, 15)가 반환됩니다.
4. 거기에 MinMax(5, 15) + m3을 더하면 MinMax(3, 15)가 됩니다.
5. 마지막으로 MinMax(3, 15) + 16을 계산해서 최종적으로 MinMax(3, 16)이 완성됩니다.

이 최종 결과값이 바로 mFinal 객체를 처음 만들(초기화) 때 사용되는 거예요.

다시 말해, 이 코드는 MinMax mFinal = (((((m1 + m2) + 5) + 8) + m3) + 16) 와 같이 하나씩 순차적으로 계산됩니다. 매번 덧셈을 할 때마다 MinMax 객체가 반환되고, 이 객체가 다음 연산자의 왼쪽 피연산자 역할을 하면서 사슬처럼 이어지는 방식입니다.

다른 연산자를 재활용해서 연산자 구현하기

위 예제 코드 중에서 operator+(int, MinMax) 함수를 어떻게 만들었는지 다시 한번 주목해 보세요. 안에서 직접 계산하지 않고, 이미 만들어둔 operator+(MinMax, int)를 불러와서 사용했습니다. (어차피 순서만 다르고 결과는 똑같으니까요!)

이렇게 하면 operator+(int, MinMax)의 내용을 단 한 줄로 줄일 수 있습니다. 중복되는 똑같은 코드를 여러 번 작성할 필요가 없으니 코드 관리가 훨씬 쉬워지고, 함수를 읽고 이해하기도 편해집니다.

이처럼 이미 만들어진 다른 오버로딩 연산자를 호출해서 새로운 연산자를 정의하는 경우가 많습니다. 코드를 더 깔끔하고 단순하게 만들 수 있다면 이 방법을 적극적으로 사용하는 것이 좋습니다. (물론 계산 내용이 단 한 줄짜리처럼 너무 간단하다면, 굳이 다른 함수를 부르지 않고 직접 작성해도 큰 상관은 없습니다.)

이전 레슨에서 포인터는 변수의 주소를 저장하는 변수라고 배웠습니다. 함수 포인터도 이와 아주 비슷해요! 변수 대신 함수를 가리킨다는 점만 빼고요.

다음 함수를 한번 살펴볼까요?

int foo()
{
    return 5;
}

foo()라는 이름이 함수의 이름이라는 건 알 수 있습니다. 그런데 이 함수의 '타입'은 무엇일까요? 함수도 자기만의 고유한 타입을 가지고 있습니다. 이 경우, '매개변수(입력값)가 없고 정수(int)를 반환하는 함수 타입'이 됩니다.

변수처럼 함수도 컴퓨터 메모리의 지정된 주소에 살고 있습니다.

함수를 호출하면(실행하면), 컴퓨터는 그 함수가 살고 있는 메모리 주소로 훌쩍 점프해서 코드를 실행합니다.

int foo() // foo를 위한 코드는 메모리 주소 0x002717f0에서 시작합니다
{
    return 5;
}

int main()
{
    foo(); // 주소 0x002717f0으로 점프합니다

    return 0;
}

프로그래밍을 하다 보면 언젠가 이런 아주 흔한 실수를 하게 될 겁니다.

#include <iostream>

int foo() // 코드는 메모리 주소 0x002717f0에서 시작합니다
{
    return 5;
}

int main()
{
    std::cout << foo << '\n'; // foo()를 호출하려고 했는데, 실수로 foo 그 자체를 출력하고 있습니다!

    return 0;
}

foo()를 실행해서 그 결과값을 화면에 띄우는 대신, foo라는 함수 자체를 출력하라고 화면에 던져버린 셈입니다. 이럴 땐 무슨 일이 일어날까요?

괄호 없이 함수 이름만 덩그러니 쓰면, C++은 이 함수를 '함수 포인터(함수의 주소를 들고 있는 녀석)'로 바꿔버립니다. 그러고 나서 출력하려고 시도하는데, C++의 기본 출력 기능은 함수 포인터를 어떻게 화면에 보여줘야 할지 모릅니다. 그래서 규칙에 따라 이 포인터를 참/거짓을 나타내는 bool 타입으로 바꿔버리죠. 함수는 빈 곳을 가리키는 게 아니니까 언제나 '참(true)'으로 평가됩니다. 따라서 결과적으로 화면에는 숫자 1이 출력됩니다.

팁 일부 컴파일러(예: Visual Studio)는 확장 기능을 통해 숫자 1 대신 함수의 진짜 주소를 출력해주기도 합니다: 0x002717f0

만약 여러분의 컴퓨터에서 주소가 안 나오는데 꼭 확인해보고 싶다면, 함수를 'void 포인터'라는 것으로 강제로 변환해서 출력해볼 수 있습니다.

#include <iostream>
>
int foo() // code starts at memory address 0x002717f0
{
    return 5;
}
>
int main()
{
    std::cout << reinterpret_cast<void*>(foo) << '\n'; // Tell C++ to interpret function foo as a void pointer (implementation-defined behavior)
>
    return 0;
}

다만 이 방법은 시스템 환경마다 다르게 동작할 수 있으니 참고만 하세요.

일반 변수를 가리키는 포인터를 만들 수 있듯이, 함수를 가리키는 포인터도 당연히 만들 수 있습니다. 지금부터 이 '함수 포인터'를 어떻게 만들고 쓰는지 알아볼 텐데요. 사실 이건 조금 어려운 주제라서, C++의 기초만 빠르게 배우고 싶은 초보자라면 나머지 내용은 그냥 가볍게 훑어보거나 건너뛰어도 괜찮습니다!

함수를 가리키는 포인터 만들기

함수 포인터를 만드는 문법은 C++에서 가장 못생긴 문법 중 하나로 꼽힙니다.

// fcnPtr은 매개변수가 없고 정수를 반환하는 함수를 가리키는 포인터입니다
int (*fcnPtr)();

위 코드에서 fcnPtr은 '매개변수가 없고 정수를 반환하는 함수'를 가리킬 수 있는 포인터입니다. 이런 똑같은 모양의 조건을 가진 함수라면 무엇이든 가리킬 수 있어요.

*fcnPtr 주변의 괄호는 아주 중요합니다. 만약 괄호를 빼고 int* fcnPtr()이라고 쓰면, 컴퓨터는 이걸 "매개변수가 없고 정수 포인터(int*)를 반환하는 함수"로 완전히 잘못 오해하게 됩니다.

함수 포인터를 상수처럼 고정하고 싶다면(한 번 가리킨 함수를 못 바꾸게 하려면) const를 별표(*) 뒤에 붙여주면 됩니다.

int (*const fcnPtr)();

만약 const를 맨 앞의 int 앞에 쓰면, "상수 정수(const int)를 반환하는 함수"를 뜻하게 되니 위치를 조심해야 합니다.

팁 함수 포인터 문법은 진짜 눈에 안 들어옵니다. 이런 복잡한 선언을 어떻게 읽어내는지 알려주는 글들이 있으니 참고해 보세요:

• https://c-faq.com/decl/spiral.anderson.html
• https://web.archive.org/web/20110818081319/http://ieng9.ucsd.edu/~cs30x/rt_lt.rule.html

함수 포인터에 함수 지정하기

함수 포인터를 처음 만들 때 함수를 바로 연결해줄 수 있고, 나중에 다른 함수로 바꿀 수도 있습니다. 일반 변수처럼 & 기호를 써서 함수의 주소를 가져오면 됩니다.

int foo()
{
    return 5;
}

int goo()
{
    return 6;
}

int main()
{
    int (*fcnPtr)(){ &foo }; // fcnPtr이 foo 함수를 가리키도록 설정합니다
    fcnPtr = &goo; // 이제 fcnPtr은 goo 함수를 가리킵니다

    return 0;
}

초보자들이 정말 많이 하는 실수가 바로 이것입니다:

fcnPtr = goo();

이렇게 괄호를 써버리면, goo() 함수를 실행한 결과값(숫자 6)을 포인터에 넣으려고 하게 됩니다. 하지만 함수 포인터는 숫자가 아니라 '주소'를 담는 상자이므로 에러가 납니다. 괄호를 꼭 빼고 주소를 넣어주세요.

또한, 포인터의 타입(매개변수와 반환값의 종류)이 가리키려는 함수의 타입과 완벽히 똑같아야 합니다.

// 함수 원형 (미리 모양만 선언해 둔 것)
int foo();
double goo();
int hoo(int x);

// 함수 포인터에 함수 연결해보기
int (*fcnPtr1)(){ &foo };    // 성공
int (*fcnPtr2)(){ &goo };    // 실패 -- 반환하는 타입(int vs double)이 다릅니다!
double (*fcnPtr4)(){ &goo }; // 성공

fcnPtr1 = &hoo;              // 실패 -- fcnPtr1은 매개변수가 없는데, hoo()는 매개변수 x가 필요합니다
int (*fcnPtr3)(int){ &hoo }; // 성공

C++은 알아서 눈치껏 함수를 함수 포인터로 변환해 주기 때문에 사실 & 기호를 생략해도 잘 작동합니다. 하지만 함수 포인터를 'void 포인터' 같이 아예 다른 종류로는 바꿀 수 없어요.

// 함수 원형
int foo();

// 함수 포인터 초기화
int (*fcnPtr5)() { foo }; // 성공, foo가 알아서 함수 포인터로 변환됩니다
void* vPtr { foo };       // 실패, (일부 프로그램에선 억지로 될 수도 있지만 원칙적으로 안 됩니다)

아무것도 가리키지 않는다는 뜻의 빈 포인터, nullptr을 넣을 수도 있습니다:

int (*fcnptr)() { nullptr }; // 성공

함수 포인터로 함수 실행하기

함수 포인터의 진짜 쓸모는 바로 그 포인터를 이용해 함수를 짠! 하고 실행하는 겁니다. 여기엔 두 가지 방법이 있어요. 첫 번째는 정석대로 * 기호를 쓰는 방법입니다.

int foo(int x)
{
    return x;
}

int main()
{
    int (*fcnPtr)(int){ &foo }; // fcnPtr을 foo 함수로 초기화합니다
    (*fcnPtr)(5); // fcnPtr을 통해 숫자 5를 넣고 foo 함수를 실행합니다!

    return 0;
}

두 번째는 굳이 *를 쓰지 않고 자연스럽게 부르는 방법입니다.

int foo(int x)
{
    return x;
}

int main()
{
    int (*fcnPtr)(int){ &foo }; // fcnPtr을 foo 함수로 초기화합니다
    fcnPtr(5); // fcnPtr을 통해 숫자 5를 넣고 foo 함수를 실행합니다!

    return 0;
}

보시다시피 두 번째 방법이 우리가 평소에 함수를 부르던 모습이랑 완전 똑같아서 훨씬 편합니다. (실은 우리가 쓰는 일반 함수 이름도 다 함수 포인터처럼 작동하거든요!) 최신 프로그램들은 다 이 편한 방법을 지원합니다.

한 가지 주의할 점! 포인터가 빈 껍데기(nullptr)일 수도 있으니, 실행하기 전에 포인터가 비어있지 않은지 꼭 확인하는 습관을 들이세요. 빈 포인터를 실행하면 프로그램이 펑하고 터질 수 있습니다.

int foo(int x)
{
    return x;
}

int main()
{
    int (*fcnPtr)(int){ &foo }; // fcnPtr을 foo 함수로 초기화합니다

    if (fcnPtr) // fcnPtr이 빈 포인터(null)가 아닌지 확인합니다
        fcnPtr(5); // 안전하다면 실행합니다 (확인 안 하고 실행하면 오류가 날 수 있어요)

    return 0;
}

기본 인자는 함수 포인터를 통해 호출할 때 작동하지 않습니다 (고급)

보통 함수에 "값을 안 넣으면 이 값으로 쳐줘!"라는 기본값(기본 인자)이 있으면, 컴퓨터가 코드를 번역할 때(컴파일 타임) 알아서 그 빈칸을 채워줍니다.

하지만 함수 포인터를 통해 함수를 부를 때는 이야기가 달라집니다. 이건 프로그램이 실제로 돌아가는 중간(런타임)에 어떤 함수가 선택될지 결정되기 때문에, 컴퓨터가 미리 빈칸을 기본값으로 채워줄 수가 없어요.

핵심 통찰 어떤 함수를 부를지가 프로그램 실행 중(런타임)에 결정되기 때문에, 함수 포인터를 써서 실행할 때는 설정해둔 '기본 인자(기본값)'가 적용되지 않습니다.

이 특징을 잘 이용하면, 이름은 똑같고 모양만 달라서 컴퓨터가 헷갈려하는 함수들 중에 딱 하나만 콕 집어서 실행하도록 만들 수 있습니다.

#include <iostream>

void print(int x)
{
    std::cout << "print(int)\n";
}

void print(int x, int y = 10)
{
    std::cout << "print(int, int)\n";
}

int main()
{
//    print(1); // 어떤 print 함수를 부르는 건지 애매해서 컴퓨터가 에러를 냅니다

    // 단계별로 풀어서 해결하는 방법
    using vnptr = void(*)(int); // void(int) 형태의 함수 포인터에 대한 별명을 만듭니다
    vnptr pi { print }; // 우리의 함수 포인터를 print 함수와 연결합니다
    pi(1); // 함수 포인터를 통해 매개변수가 하나인 print(int) 함수만 정확히 부릅니다

    // 짧고 굵게 해결하는 방법
    static_cast<void(*)(int)>(print)(1); // print를 void(int) 형태로 변환한 뒤 숫자 1을 넣고 부릅니다

    return 0;
}

함수를 다른 함수의 인자(매개변수)로 전달하기

함수 포인터를 배우는 가장 큰 이유가 바로 여기에 있습니다. 함수 안에 다른 함수를 재료처럼 집어넣을 수 있다는 것! 이렇게 다른 함수의 매개변수로 쏙 들어가는 함수를 흔히 '콜백 함수(callback functions)'라고 부릅니다.

예를 들어 숫자들이 들어있는 배열을 정렬하는 프로그램을 만든다고 쳐볼게요. 정렬은 알아서 잘하되, 숫자를 오름차순(작은 것부터)으로 할지, 내림차순(큰 것부터)으로 할지는 사용하는 사람이 입맛대로 고르게 해주고 싶습니다.

정렬 프로그램들은 보통 '숫자 두 개를 비교해서 자리를 바꿀까 말까?'를 결정하는 방식으로 작동합니다. 즉, 이 비교하는 부분만 바꿔 끼울 수 있게 만들면 정렬 코드를 통째로 다시 짤 필요가 없다는 거죠!

우리가 예전에 만들었던 선택 정렬 코드를 볼까요?

#include <utility> // std::swap을 사용하기 위해 필요합니다

void SelectionSort(int* array, int size)
{
    if (!array)
        return;

    // 배열의 모든 요소를 하나씩 밟고 지나갑니다
    for (int startIndex{ 0 }; startIndex < (size - 1); ++startIndex)
    {
        // smallestIndex는 지금까지 발견한 가장 작은 숫자의 위치입니다.
        int smallestIndex{ startIndex };

        // 배열의 나머지 부분에서 가장 작은 숫자를 찾습니다
        for (int currentIndex{ startIndex + 1 }; currentIndex < size; ++currentIndex)
        {
            // 만약 현재 숫자가 우리가 찾았던 가장 작은 숫자보다 작다면
            if (array[smallestIndex] > array[currentIndex]) // 여기서 비교가 일어납니다!
            {
                // 이 숫자가 이번 턴의 새로운 제일 작은 숫자가 됩니다
                smallestIndex = currentIndex;
            }
        }

        // 맨 앞의 숫자와 우리가 찾은 가장 작은 숫자의 자리를 바꿉니다
        std::swap(array[startIndex], array[smallestIndex]);
    }
}

저기 > 기호로 고정되어 있는 비교 부분을 함수로 따로 빼내 보겠습니다. 두 숫자를 비교해서 자리를 바꿀지 말지(true/false) 알려주는 함수예요.

bool ascending(int x, int y)
{
    return x > y; // 첫 번째 숫자가 두 번째 숫자보다 크면 자리를 바꾸라고 알려줍니다 (오름차순)
}

이걸 원래 코드에 끼워 넣으면 이렇게 됩니다:

#include <utility> // std::swap을 사용하기 위해 필요합니다

void SelectionSort(int* array, int size)
{
    if (!array)
        return;

    // 배열의 모든 요소를 하나씩 밟고 지나갑니다
    for (int startIndex{ 0 }; startIndex < (size - 1); ++startIndex)
    {
        // smallestIndex는 지금까지 발견한 가장 작은 숫자의 위치입니다.
        int smallestIndex{ startIndex };

        // 배열의 나머지 부분에서 가장 작은 숫자를 찾습니다
        for (int currentIndex{ startIndex + 1 }; currentIndex < size; ++currentIndex)
        {
            // 만약 현재 숫자가 우리가 찾았던 가장 작은 숫자보다 작다면
            if (ascending(array[smallestIndex], array[currentIndex])) // 비교를 함수에게 맡겼습니다!
            {
                // 이 숫자가 이번 턴의 새로운 제일 작은 숫자가 됩니다
                smallestIndex = currentIndex;
            }
        }

        // 맨 앞의 숫자와 우리가 찾은 가장 작은 숫자의 자리를 바꿉니다
        std::swap(array[startIndex], array[smallestIndex]);
    }
}

자, 이제 하이라이트입니다! 우리가 직접 비교 함수를 못 박아두는 대신, 프로그램을 사용하는 사람이 직접 자기가 원하는 비교 함수를 넣을 수 있도록 빈칸(함수 포인터)을 뚫어줄 겁니다.

사용자가 넣을 함수는 두 개의 숫자를 받아서 참/거짓을 알려주는 형태니까, 함수 포인터의 모양은 이렇게 될 겁니다.

bool (*comparisonFcn)(int, int);

이제 정렬 함수의 세 번째 재료로 이 포인터를 받아서 쓰기만 하면 됩니다. 사용자가 오름차순 함수를 넣으면 오름차순으로, 내림차순 함수를 넣으면 내림차순으로 작동하는 마법 같은 정렬 함수가 완성됩니다!

#include <utility> // std::swap을 사용하기 위해 필요합니다
#include <iostream>

// 세 번째 매개변수가 바로 사용자가 직접 만들어 넣을 비교 함수입니다!
void selectionSort(int* array, int size, bool (*comparisonFcn)(int, int))
{
    if (!array || !comparisonFcn)
        return;

    // 배열의 모든 요소를 하나씩 밟고 지나갑니다
    for (int startIndex{ 0 }; startIndex < (size - 1); ++startIndex)
    {
        // bestIndex는 지금까지 발견한 가장 조건에 맞는 숫자의 위치입니다.
        int bestIndex{ startIndex };

        // 배열의 나머지 부분에서 가장 조건에 맞는 숫자를 찾습니다
        for (int currentIndex{ startIndex + 1 }; currentIndex < size; ++currentIndex)
        {
            // 사용자가 넘겨준 함수를 이용해 두 숫자를 비교합니다!
            if (comparisonFcn(array[bestIndex], array[currentIndex])) // 여기서 비교가 일어납니다
            {
                // 이 숫자가 이번 턴의 새로운 '최고의' 숫자가 됩니다
                bestIndex = currentIndex;
            }
        }

        // 맨 앞의 숫자와 우리가 찾은 최고의 숫자의 자리를 바꿉니다
        std::swap(array[startIndex], array[bestIndex]);
    }
}

// 오름차순(점점 커지게)으로 정렬해주는 비교 함수입니다
bool ascending(int x, int y)
{
    return x > y; // 첫 번째 숫자가 더 크면 자리를 바꿉니다
}

// 내림차순(점점 작아지게)으로 정렬해주는 비교 함수입니다
bool descending(int x, int y)
{
    return x < y; // 두 번째 숫자가 더 크면 자리를 바꿉니다
}

// 화면에 배열의 숫자들을 예쁘게 출력해주는 함수입니다
void printArray(int* array, int size)
{
    if (!array)
        return;

    for (int index{ 0 }; index < size; ++index)
    {
        std::cout << array[index] << ' ';
    }
    std::cout << '\n';
}

int main()
{
    int array[9]{ 3, 7, 9, 5, 6, 1, 8, 2, 4 };

    // descending() 함수를 넣어서 배열을 내림차순으로 정렬합니다
    selectionSort(array, 9, descending);
    printArray(array, 9);

    // ascending() 함수를 넣어서 배열을 오름차순으로 정렬합니다
    selectionSort(array, 9, ascending);
    printArray(array, 9);

    return 0;
}

결과가 어떻게 나올까요?

9 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 9

정말 멋지죠! 우리는 뼈대 역할을 하는 정렬 함수 하나만 만들었을 뿐인데, 사용자가 원하는 대로 입맛에 맞게 정렬 방식을 조종할 수 있게 되었습니다.

심지어 "짝수를 먼저 세워!" 같은 아주 특이한 비교 함수를 만들어서 넣어도 찰떡같이 알아듣습니다.

bool evensFirst(int x, int y)
{
    // x가 짝수이고 y가 홀수면, 짝수인 x가 먼저입니다 (자리 안 바꿈)
    if ((x % 2 == 0) && !(y % 2 == 0))
        return false;

    // x가 홀수이고 y가 짝수면, 짝수인 y가 먼저 가야 합니다 (자리 바꿈)
    if (!(x % 2 == 0) && (y % 2 == 0))
        return true;

    // 둘 다 짝수거나 둘 다 홀수면, 그냥 오름차순으로 정리합니다
    return ascending(x, y);
}

int main()
{
    int array[9]{ 3, 7, 9, 5, 6, 1, 8, 2, 4 };

    selectionSort(array, 9, evensFirst);
    printArray(array, 9);

    return 0;
}

이 코드의 결과는 이렇습니다.

2 4 6 8 1 3 5 7 9

이렇게 함수 포인터를 사용하면 내가 미리 만들어 둔 튼튼한 코드 뼈대 사이에 다른 사람이 자기만의 코드를 쏙 끼워 넣게(hook) 만들어 줄 수 있습니다. 덕분에 코드를 여러 번 다시 쓸 수 있어서 프로그래머의 퇴근 시간을 아주 앞당겨주죠!

참고로, 매개변수 자리에 그냥 함수의 원형 모양을 써도 C++이 알아서 함수 포인터로 찰떡같이 이해하고 바꿔줍니다. 즉 아래 두 코드는 완전히 같은 의미입니다.

void selectionSort(int* array, int size, bool (*comparisonFcn)(int, int))

void selectionSort(int* array, int size, bool comparisonFcn(int, int))

다만 이 편리함은 '매개변수' 자리에서만 통합니다. 일반적인 곳에서 두 번째 방식처럼 쓰면 그냥 함수를 선언하는 걸로 알아들으니 주의하세요.

기본 함수 제공하기

사용자한테 "매번 비교 함수 만들어서 넣어!"라고 하면 귀찮아하겠죠? 이럴 땐 우리가 미리 사람들이 자주 쓸 법한 ascending()이나 descending() 같은 편의점용 함수를 준비해두면 아주 좋습니다.

심지어 "아무 함수도 안 넣으면 그냥 오름차순으로 해줄게"라고 기본값을 설정할 수도 있습니다.

// 함수를 안 넣으면 기본으로 ascending(오름차순) 함수를 쓰도록 설정합니다
void selectionSort(int* array, int size, bool (*comparisonFcn)(int, int) = ascending);

이렇게 해두면 사용자가 함수 포인터 없이 그냥 정렬 함수만 부를 경우 자동으로 오름차순 정렬이 됩니다. (물론 컴퓨터가 알아먹을 수 있게 이 코드 이전에 ascending 함수가 먼저 만들어져 있어야 합니다.)

타입 별명으로 함수 포인터를 예쁘게 만들기

솔직히 인정합시다. 함수 포인터 문법은 별표에 괄호에 진짜 너무 못생겼고 복잡합니다. 다행히 using이라는 키워드로 예쁜 '별명'을 지어주면 일반 변수처럼 아주 깔끔하게 쓸 수 있습니다.

using ValidateFunction = bool(*)(int, int);

이 한 줄은 "이제부터 bool(*)(int, int)라는 복잡한 함수 포인터 모양을 그냥 ValidateFunction이라고 부를게!"라는 뜻입니다.

이제 아래의 복잡했던 코드가:

bool validate(int x, int y, bool (*fcnPtr)(int, int)); // 눈 아프고 복잡합니다

이렇게 변신합니다:

bool validate(int x, int y, ValidateFunction pfcn) // 아주 깔끔하죠!

std::function 사용하기 (Using std::function)

C++은 이런 지저분한 문법을 아예 싹 덮어버릴 수 있도록 표준 라이브러리 <functional>에 std::function이라는 아주 편리한 도구를 만들어 두었습니다. 최신 C++에서는 이게 함수 포인터의 끝판왕입니다.

#include <functional>

bool validate(int x, int y, std::function<bool(int, int)> fcn); // bool을 반환하고 두 개의 int를 받는 std::function

보시다시피 꺾쇠 < > 안에 반환타입(매개변수타입) 형태로 직관적으로 적어주면 끝입니다. 매개변수가 없으면 그냥 빈 괄호 ()를 쓰면 됩니다.

앞서 본 예제를 std::function으로 바꿔볼까요?

#include <functional>
#include <iostream>

int foo()
{
    return 5;
}

int goo()
{
    return 6;
}

int main()
{
    std::function<int()> fcnPtr{ &foo }; // 매개변수가 없고 int를 반환하는 함수를 담는 상자 만들기!
    fcnPtr = &goo; // 이제 fcnPtr은 goo 함수를 가리킵니다
    std::cout << fcnPtr() << '\n'; // 일반 함수 부르듯 편하게 씁니다

    std::function fcnPtr2{ &foo }; // C++17부터는 모양을 자동으로 유추하게 놔둘 수도 있습니다(CTAD)

    return 0;
}

이것도 이름이 너무 길다 싶으면 아까 배운 별명을 지어주는 방식을 섞어 쓰면 완벽합니다.

using ValidateFunctionRaw = bool(*)(int, int); // 옛날 방식의 날것 그대로의 함수 포인터 별명
using ValidateFunction = std::function<bool(int, int)>; // 깔끔한 std::function 방식의 별명

참고로 std::function은 fcnPtr()처럼 이름만 부르는 자연스러운 방식만 허용하고, (*fcnPtr)()처럼 앞에 별표를 굳이 붙이는 옛날 방식은 허용하지 않습니다.

함수 포인터의 타입 추론

귀찮음을 덜어주는 마법의 단어 auto 기억하시죠? 일반 변수를 만들 때처럼, 함수 포인터를 만들 때도 auto를 써서 컴퓨터가 알아서 모양을 맞춰주게 할 수 있습니다.

#include <iostream>

int foo(int x)
{
    return x;
}

int main()
{
    auto fcnPtr{ &foo }; // 알아서 foo를 가리키는 알맞은 함수 포인터를 만들어줍니다!
    std::cout << fcnPtr(5) << '\n';

    return 0;
}

코드가 아주 짧고 깔끔해지죠? 물론 이 방법은 코드가 너무 짧아진 나머지, 이 함수가 매개변수를 몇 개나 받고 뭘 반환하는지가 눈에 안 보여서 코드를 읽다가 헷갈릴 수 있다는 단점이 있긴 합니다.

결론

함수 포인터는 수많은 함수들을 배열 같은 곳에 깔끔하게 모아두고 싶을 때나, 다른 함수의 재료(콜백 함수)로 함수 자체를 넘겨주고 싶을 때 아주 유용하게 쓰입니다.

다만, 옛날 방식의 (*fcnPtr) 문법은 너무 못생겼고 실수하기 딱 좋기 때문에, 최신 기능인 std::function을 사용하는 것을 강력히 추천합니다. 딱 한 번만 쓰고 말 거라면 매개변수 자리에 std::function을 바로 쓰고, 여러 번 반복해서 쓸 거라면 예쁜 별명(using)을 지어주는 것이 가장 좋은 습관입니다!

20.2 — 스택(Stack)과 힙(Heap)

컴퓨터에서 프로그램이 실행될 때, 프로그램이 사용하는 메모리(기억 공간)는 마치 집의 방들을 용도에 따라 나누듯 몇 가지 구역으로 나뉩니다. 초보자분들도 이해하기 쉽게 정리해 볼게요!

• 코드 영역 (텍스트 영역) 우리가 짠 프로그램 코드가 들어가는 곳입니다. (보통 읽기만 가능해요.)

• bss 영역 아직 값이 정해지지 않은(0으로 초기화된) 전역 변수나 정적 변수가 사는 곳입니다.

• 데이터 영역 이미 값이 정해진 전역 변수나 정적 변수가 사는 곳입니다.

• 힙(Heap) 프로그램이 실행되는 도중에 "나 메모리 좀 빌려줘!" 할 때 동적으로 공간을 내어주는 커다란 창고입니다.

• 콜 스택(Call stack) 함수를 부를 때 필요한 재료들(매개변수)이나, 함수 안에서 잠깐 쓰는 변수들(지역 변수)이 잠시 머무는 곳입니다.

이번 강의에서는 가장 중요하고 재미있는 일들이 일어나는 힙(Heap)과 스택(Stack), 이 두 가지에만 집중해 보겠습니다.

힙(Heap) 영역

힙(Heap) 영역은 '필요할 때 언제든 메모리를 빌려 쓸 수 있는 거대한 창고'라고 생각하시면 쉽습니다. C++에서 new라는 마법의 단어(연산자)를 사용하면, 이 힙 영역에서 필요한 만큼 메모리를 빌려오게 됩니다.

만약 int형 변수 하나가 4바이트의 공간을 차지한다고 가정해 볼까요?

int* ptr { new int }; // new int는 힙 창고에서 4바이트의 공간을 빌려옵니다.
int* array { new int[10] }; // new int[10]은 힙 창고에서 40바이트의 공간을 빌려옵니다.

이렇게 빌려온 공간의 '주소'를 우리가 만든 포인터에 저장해 두고 쓰는 방식입니다. 운영체제가 빈 공간을 어떻게 찾아서 빌려주는지 그 복잡한 원리까지는 몰라도 괜찮아요! 다만 한 가지 알아둘 점은, 메모리를 연달아 빌린다고 해서 실제로 창고 안에서 나란히 붙어있는 공간을 주지는 않을 수도 있다는 것입니다.

int* ptr1 { new int };
int* ptr2 { new int };
// ptr1과 ptr2가 가리키는 주소가 창고 안에서 나란히 붙어있지 않을 수도 있습니다!

다 쓴 메모리를 delete로 삭제하면, 메모리에 있던 변수가 아예 세상에서 사라지는 게 아니라 "다 썼으니 창고에 반납할게요" 하고 운영체제에 돌려주는 것을 의미합니다. 그럼 다음에 다른 누군가가 그 공간을 다시 빌려 쓸 수 있겠죠.

힙 영역은 다음과 같은 장단점이 있습니다:

• 단점: 스택에 비해 메모리를 빌려오는 속도가 조금 느립니다.
• 주의점: 직접 반납(delete)하거나 프로그램이 완전히 끝날 때까지 메모리 공간을 계속 차지하고 있습니다. (다 쓰고 반납 안 하면 '메모리 누수'라는 골치 아픈 문제가 생겨요!)
• 단점: 포인터를 통해서만 접근해야 해서, 일반 변수를 바로 쓰는 것보다 아주 살짝 느립니다.
• 장점: 창고가 아주 넓기 때문에 엄청나게 큰 배열이나 복잡한 데이터를 저장하기에 아주 좋습니다.

콜 스택(Call stack)

콜 스택(보통 줄여서 그냥 '스택'이라고 부릅니다)은 훨씬 더 흥미로운 역할을 합니다. 스택은 프로그램이 시작된 후 지금까지 어떤 함수들이 실행 중인지 기억하고, 그 함수들이 사용하는 지역 변수들의 자리를 마련해 주는 똑똑한 비서입니다.

스택이 어떻게 일하는지 이해하려면, 먼저 '스택 자료 구조'가 무엇인지 알아야 해요.

스택(Stack) 자료 구조

'자료 구조'란 데이터를 효율적으로 쓰기 위해 정리하는 방법입니다. 여러분이 식당에 갔을 때 뷔페 한쪽에 차곡차곡 쌓여 있는 접시 더미를 떠올려 보세요. 접시가 무겁게 쌓여 있기 때문에 우리가 할 수 있는 행동은 딱 세 가지뿐입니다.

1. 맨 위에 있는 접시가 뭔지 본다.
2. 맨 위에 있는 접시를 꺼낸다.
3. 새 접시를 맨 위에 올려놓는다.

컴퓨터 프로그래밍의 스택도 똑같습니다! 스택은 데이터를 보관하는 상자인데, 아무 곳에나 마음대로 넣고 뺄 수 있는 배열과 달리 규칙이 엄격합니다.

• 스택 맨 위(꼭대기)에 있는 항목 확인하기 (보통 top()이나 peek()이라는 함수를 씁니다)
• 맨 위에서 항목 꺼내기 (팝(Pop)이라고 부릅니다)
• 맨 위에 새 항목 올려놓기 (푸시(Push)라고 부릅니다)

스택은 가장 나중에 들어온 녀석이 가장 먼저 나가는 (LIFO: Last-In, First-Out) 구조입니다. 접시를 방금 맨 위에 올려두었다면, 다음 사람이 접시를 가져갈 때 바로 그 접시를 제일 먼저 가져가게 되겠죠. 넣을 때(Push)는 위로 쌓이고, 뺄 때(Pop)는 위에서부터 줄어듭니다.

간단한 예시를 볼까요?

스택: 텅 빔 푸시 1 -> 스택: 1 푸시 2 -> 스택: 1 2 푸시 3 -> 스택: 1 2 3 팝 -> 스택: 1 2 (3이 빠짐) 팝 -> 스택: 1 (2가 빠짐)

접시 비유도 좋지만, 아래에서부터 위로 차곡차곡 고정되어 쌓여 있는 우편함을 상상하면 더 정확합니다. 가장 아래쪽 빈 우편함에 포스트잇(마커)을 붙여둡니다. 새 물건(Push)을 넣으면 포스트잇이 붙은 우편함에 넣고 포스트잇을 한 칸 위로 옮깁니다. 물건을 뺄 때(Pop)는 포스트잇을 한 칸 아래로 내린 뒤 그 우편함에서 물건을 꺼냅니다. 포스트잇 아래에 있는 것만 "스택에 들어있다"고 치고, 그 위는 신경 쓰지 않는 식입니다.

콜 스택(Call stack) 영역

콜 스택 영역은 이 스택 방식을 똑같이 사용합니다. 프로그램이 켜지면 제일 먼저 main() 함수가 스택에 쏙 들어갑니다(Push).

프로그램을 실행하다가 새로운 함수를 부르면, 그 함수도 스택 맨 위에 층층이 쌓입니다(Push). 그리고 그 함수가 일을 다 마치면 스택에서 빠져나옵니다(Pop). 따라서 현재 스택에 쌓여있는 함수들을 밑에서부터 쭉 훑어보면, 지금 실행 중인 곳까지 오기 위해 어떤 함수들을 거쳐왔는지 한눈에 알 수 있습니다.

우편함 비유를 적용해 볼게요. 여기서 물건을 넣고 빼는 단위는 함수 하나의 정보가 담긴 '스택 프레임(Stack frame)'이라는 보따리입니다. 그리고 포스트잇(마커) 역할을 하는 것은 CPU 안에 있는 '스택 포인터(SP)'라는 녀석이죠. 스택 포인터는 항상 스택의 맨 꼭대기를 가리키며 "지금 여기까지 찼어!"라고 알려줍니다.

재미있는 점은, 스택에서 함수를 뺄 때(Pop) 굳이 우편함 안의 내용물을 지우개로 빡빡 지우며 청소할 필요가 없다는 것입니다. 그냥 스택 포인터(포스트잇)만 한 칸 아래로 내리면 끝납니다! 어차피 나중에 새 함수가 들어오면 그 자리에 새 정보를 덮어씌울 테니까요. 이렇게 하면 속도가 훨씬 빨라집니다.

콜 스택의 작동 방식

함수를 부를 때 내부적으로 어떤 일들이 일어나는지 순서대로 쉽게 살펴볼게요.

1. 프로그램이 "어, 함수 호출이네!" 하고 알아챕니다.
2. 그 함수를 위한 '스택 프레임(보따리)'을 만들어 스택 맨 위에 올립니다(Push). 이 보따리 안에는 다음 내용이 들어갑니다:

• 돌아갈 주소: 함수가 끝나고 원래 하던 일로 다시 돌아올 위치를 적어둔 메모지.
• 함수에 전달할 매개변수들.
• 함수 안에서만 쓸 지역 변수들을 위한 빈 공간.

3. 이제 프로그램은 방금 부른 함수의 시작점으로 점프해서 들어갑니다.
4. 함수 안의 코드들을 열심히 실행합니다.
5. 함수가 끝에 도달하면 다음 일들이 벌어집니다:

• 스택 프레임을 스택에서 빼냅니다(Pop). 이러면 함수 안에서 쓰던 지역 변수들도 자연스럽게 공간을 반납하게 됩니다.
• 함수가 남긴 결과값(Return value)을 챙깁니다.
• 아까 보따리에 적어둔 '돌아갈 주소'를 보고 원래 하던 곳으로 무사히 점프해서 돌아갑니다.

참고로... 컴퓨터 종류에 따라 스택이 메모리 주소 0번지부터 점점 큰 숫자로 쌓이는 기계도 있고, 반대로 큰 숫자에서 0번지 쪽으로 거꾸로 쌓이는 기계도 있습니다. 아주 깊은 기술적인 내용이니 "그렇구나~" 하고 넘어가셔도 괜찮습니다.

간단한 콜 스택 예제

아주 간단한 코드로 콜 스택이 어떻게 변하는지 볼까요?

int foo(int x)
{
    // b
    return x;
} // foo 함수가 여기서 콜 스택에서 빠집니다 (pop)

int main()
{
    // a
    foo(5); // foo 함수가 여기서 콜 스택에 쌓입니다 (push)
    // c

    return 0;
}

코드 안의 a, b, c 위치에서 콜 스택의 모습은 다음과 같습니다:

a 위치:

main()

b 위치:

foo() (매개변수 x 포함) main()

c 위치:

main()

스택 오버플로우(Stack overflow)

스택은 무한정 넓은 곳이 아니라 크기가 정해져 있습니다. 윈도우(Visual Studio)에서는 기본적으로 겨우 1MB밖에 안 되고, 유닉스 환경에서도 8MB 정도입니다. 만약 이 좁은 스택에 너무 많은 정보를 구겨 넣으려고 하면 스택 오버플로우(Stack overflow, 스택이 넘침)라는 끔찍한 에러가 발생합니다!

주로 스택에 너무 큰 배열을 만들려고 하거나, 함수가 함수를 부르고 또 부르는 과정(꼬리에 꼬리를 무는 호출)이 너무 깊어질 때 발생합니다. 스택이 넘쳐버리면 운영체제는 화를 내며 프로그램을 강제로 종료시켜 버립니다(뻗어버리는 거죠).

아래 코드는 스택을 꽉 채워 터지게 만드는 예제입니다. 직접 실행해 보면 프로그램이 어떻게 죽는지 볼 수 있어요.

#include <iostream>

int main()
{
    int stack[10000000];
    std::cout << "hi" << stack[0]; // 컴파일러가 배열을 맘대로 없애버리지 못하게 stack[0]을 억지로 써줍니다.

    return 0;
}

이 프로그램은 스택이라는 좁은 방에 대략 40MB짜리 엄청나게 큰 배열을 우겨 넣으려고 합니다. 스택이 이걸 감당하지 못해서, 결국 허락되지 않은 다른 메모리 구역까지 침범하다가 프로그램이 강제 종료됩니다. 윈도우에서는 "접근 위반(access violation)"이라는 에러 코드를 뱉고, "hi"라는 글자는 출력조차 되지 않습니다.

스택이 터지는 또 다른 흔한 이유도 볼까요?

// h/t 카운터 추가 아이디어를 주신 독자 yellowEmu님께 감사드립니다.
#include <iostream>

int g_counter{ 0 };

void eatStack()
{
    std::cout << ++g_counter << ' ';

    // 컴파일러가 무한 반복이라고 경고하는 걸 막기 위해 조건문을 하나 달아줍니다.
    if (g_counter > 0)
        eatStack(); // 주목: eatStack() 함수가 자기 자신을 또 부릅니다!

    // 컴파일러가 멋대로 코드를 최적화하는 것을 막기 위한 용도입니다.
    std::cout << "hi";
}

int main()
{
    eatStack();

    return 0;
}

이 프로그램은 eatStack() 함수가 실행될 때마다 스택에 새로운 보따리(스택 프레임)를 올립니다. 그런데 이 함수가 자기 자신을 부르고, 불려온 애가 또 자기를 부르고... 끝없이 자기를 부르기 때문에 결국 스택 메모리가 꽉 차서 넘쳐(오버플로우) 버립니다.

참고 노트 원작자가 윈도우 10 컴퓨터에서 테스트해 보았을 때, 디버그 모드에서는 eatStack()이 4,848번 불린 후 프로그램이 뻗었고, 릴리스 모드에서는 128,679번 불린 후에 뻗었다고 하네요!

관련 컨텐츠 자기 자신을 계속해서 부르는 함수에 대해서는 다음 강의인 20.3 - 재귀(Recursion)에서 더 자세히 다룰 예정입니다!

정리하자면, 스택은 다음과 같은 장단점이 있습니다:

• 장점: 메모리를 빌리고 반납하는 속도가 굉장히 빠릅니다.
• 장점: 스택에 들어간 변수는 알아서 관리됩니다. 함수가 끝나서 스택에서 빠질 때 자동으로 싹 청소됩니다.
• 장점: 컴파일할 때 크기가 다 정해져서, 변수 이름으로 빠르고 직접적으로 접근할 수 있습니다.
• 주의점: 스택은 크기가 매우 작습니다! 그래서 엄청나게 큰 배열이나 무거운 데이터를 스택에 넣는 것은 절대 권장하지 않습니다.

참고 노트 이 코멘트를 보시면 스택에 있는 변수들이 어떻게 배치되고, 실제로 어떻게 주소를 받는지에 대한 추가적이고 조금 더 쉬운 설명이 있습니다.

20.3 — 재귀 (Recursion)

C++에서 재귀 함수(recursive function)란 아주 간단히 말해 '자기 자신을 다시 부르는(호출하는) 함수'를 뜻해요. 마치 거울 속에 거울이 있는 것처럼요! 먼저, 조금 잘못 만들어진 재귀 함수 예제를 하나 살펴볼까요?

#include <iostream>

void countDown(int count)
{
    std::cout << "push " << count << '\n';
    countDown(count-1); // countDown() 함수가 자기 자신을 다시 부릅니다 (재귀 호출)
}

int main()
{
    countDown(5);

    return 0;
}

이 프로그램에서 countDown(5)가 실행되면 화면에 "push 5"가 출력되고, 함수 안에서 countDown(4)를 또 부릅니다. 그러면 countDown(4)는 "push 4"를 출력하고 countDown(3)을 부르겠죠. 이런 식으로 countDown(n)이 countDown(n-1)을 부르는 과정이 끝없이 반복됩니다. 사실상 무한 루프(영원히 끝나지 않는 반복문)와 똑같은 상태가 되는 거예요.

함수가 호출될 때마다 컴퓨터는 '콜 스택(call stack)'이라는 메모리 공간에 정보를 쌓아둡니다. 하지만 위 예제에서는 countDown() 함수가 끝을 맺지 못하고 계속 자기 자신을 부르기만 하니까, 쌓인 정보가 스택에서 빠져나갈(pop) 기회가 전혀 없게 됩니다!

결국 어느 순간 컴퓨터는 스택 메모리를 모두 다 써버리게 되고, 이를 스택 오버플로우(stack overflow)라고 부릅니다. 이 상태가 되면 프로그램은 에러를 내며 튕기거나 강제로 종료돼요. 원본 글의 작성자 컴퓨터에서는 프로그램이 종료되기 전까지 무려 -11732까지 카운트다운을 했다고 하네요!

참고 노트 테일 콜(Tail call, 꼬리 호출)이란 함수의 맨 끝(꼬리 부분)에서 일어나는 함수 호출을 말합니다. 컴파일러(코드를 컴퓨터 언어로 번역해 주는 프로그램)는 이런 재귀적인 테일 콜을 반복문(재귀가 아닌 형태)으로 쉽게 최적화할 수 있어요. 만약 최적화가 적용되었다면 위 예제에서도 시스템 메모리가 부족해지는 일이 발생하지 않았을 겁니다. 위 코드를 직접 실행해 봤는데 에러 없이 영원히 실행된다면, 컴파일러가 똑똑하게 코드를 최적화했기 때문일 가능성이 높습니다.

재귀 종료 조건

재귀 함수는 일반적인 함수와 거의 똑같이 작동해요. 하지만 방금 본 예제에서 알 수 있듯, 재귀 함수를 쓸 때 가장 중요하게 기억해야 할 차이점이 있습니다. 바로 재귀 종료 조건을 반드시 만들어 주어야 한다는 점이에요. 그렇지 않으면 메모리가 바닥날 때까지 영원히 실행되니까요.

종료 조건이란 쉽게 말해 "특정 상황이 되면 자기 자신을 그만 부르고 멈춰라!"라고 알려주는 규칙입니다.

종료 조건은 보통 if 문을 사용해서 만듭니다. 아까 보았던 함수에 종료 조건을 추가해서 새롭게 고쳐볼게요 (출력 내용도 조금 추가했습니다).

#include <iostream>

void countDown(int count)
{
    std::cout << "push " << count << '\n';

    if (count > 1) // 종료 조건: count가 1보다 클 때만 자기 자신을 부릅니다.
        countDown(count-1);

    std::cout << "pop " << count << '\n';
}

int main()
{
    countDown(5);
    return 0;
}

이제 이 프로그램을 실행하면, 제일 먼저 다음과 같이 출력됩니다.

push 5
push 4
push 3
push 2
push 1

이 순간, 컴퓨터의 콜 스택(메모리가 쌓여 있는 모습)을 들여다본다면 다음과 같이 함수들이 차곡차곡 쌓여 있을 거예요.

countDown(1)
countDown(2)
countDown(3)
countDown(4)
countDown(5)
main()

이번에는 종료 조건(if (count > 1))이 있기 때문에, countDown(1)은 countDown(0)을 부르지 않아요! 조건에 맞지 않아 if 문 안의 코드가 실행되지 않고, 바로 "pop 1"을 출력한 뒤 함수가 성공적으로 끝납니다.

함수가 끝났으니 countDown(1)은 스택에서 빠져나가고(pop), 프로그램의 흐름은 자신을 불렀던 countDown(2)로 돌아갑니다. countDown(2)는 멈췄던 지점부터 다시 실행되어 "pop 2"를 출력하고 또 끝이 납니다. 이렇게 차례대로 스택에서 빠져나가면서 모든 countDown 함수가 메모리에서 지워질 때까지 이 과정이 반복돼요.

결과적으로 이 프로그램은 다음과 같은 전체 결과를 출력합니다.

push 5
push 4
push 3
push 2
push 1
pop 1
pop 2
pop 3
pop 4
pop 5

여기서 "push"는 자기 자신을 부르기 전에 실행되니까 숫자가 정방향(5부터 1)으로 나오고, "pop"은 함수가 끝나고 스택에서 빠져나올 때(들어간 순서의 역순으로 빠져나옴) 실행되니까 숫자가 역방향(1부터 5)으로 나온다는 점을 눈여겨보세요!

조금 더 쓸만한 예제

재귀 호출이 어떻게 작동하는지 기본 원리를 알아봤으니, 이번에는 조금 더 흔하게 쓰이는 실용적인 재귀 함수를 살펴볼까요?

// 1부터 sumto까지의 모든 정수를 더한 값을 반환합니다 (1과 sumto 포함)
// 음수를 넣으면 0을 반환합니다.
int sumTo(int sumto)
{
    if (sumto <= 0)
        return 0; // 기본 케이스 (종료 조건): 사용자가 0이나 음수 같은 예상치 못한 값을 넣었을 때
    if (sumto == 1)
        return 1; // 일반적인 기본 케이스 (종료 조건)

    return sumTo(sumto - 1) + sumto; // 재귀 함수 호출
}

재귀 프로그램은 코드만 눈으로 딱 보고 어떻게 돌아가는지 이해하기가 꽤 어려워요. 이럴 때는 특정 숫자를 직접 넣었을 때 어떤 일이 일어나는지 차근차근 따라가 보는 것이 가장 좋습니다. sumto에 5를 넣었다고 상상해 볼까요?

1. sumTo(5) 호출: 5 <= 1은 거짓이므로, sumTo(4) + 5를 반환하려고 합니다.
2. sumTo(4) 호출: 4 <= 1은 거짓이므로, sumTo(3) + 4를 반환하려고 합니다.
3. sumTo(3) 호출: 3 <= 1은 거짓이므로, sumTo(2) + 3을 반환하려고 합니다.
4. sumTo(2) 호출: 2 <= 1은 거짓이므로, sumTo(1) + 2를 반환하려고 합니다.
5. sumTo(1) 호출: 1 <= 1은 참이므로, 1을 반환합니다. 드디어 종료 조건을 만났네요!

이제 함수가 차례대로 결과를 돌려주며 콜 스택에서 하나씩 빠져나옵니다(unwind).

• sumTo(1)은 1을 반환합니다.
• sumTo(2)는 sumTo(1) + 2를 계산하니까, 1 + 2 = 3을 반환합니다.
• sumTo(3)은 sumTo(2) + 3을 계산하니까, 3 + 3 = 6을 반환합니다.
• sumTo(4)는 sumTo(3) + 4를 계산하니까, 6 + 4 = 10을 반환합니다.
• sumTo(5)는 sumTo(4) + 5를 계산하니까, 10 + 5 = 15를 반환합니다.

이렇게 풀어놓고 보니 1부터 넘겨받은 숫자 5까지 모든 수를 더한다는 게 훨씬 이해하기 쉽죠? 재귀 함수는 직관적으로 이해하기 어렵기 때문에, 좋은 주석(설명글)을 달아두는 것이 아주 중요합니다.

참고로 위 코드에서는 --sumto 대신 sumto - 1이라는 값을 사용해 재귀 호출을 했어요. 왜냐하면 -- 기호(값을 1 줄이는 연산자)는 변수의 실제 값 자체를 바꿔버리는 '부작용(side effect)'이 있기 때문이에요. 하나의 수식 안에서 값이 변하는 변수를 여러 번 쓰면 프로그램이 예측 불가능한 이상한 행동(정의되지 않은 동작)을 할 수 있습니다. sumto - 1을 쓰면 변수의 원래 값은 그대로 둔 채 1을 뺀 새로운 값만 전달할 수 있어서 안전하답니다.

재귀 알고리즘

재귀 함수는 보통 큰 문제를 먼저 작게 쪼개서 푼 다음(재귀적으로), 그 작은 해답들을 조합해서 전체의 정답을 찾아내는 방식으로 작동합니다. 위에서 본 알고리즘에서도 sumTo(value)를 구하기 위해, 먼저 더 작은 문제인 sumTo(value-1)을 풀고 거기에 value를 더해서 정답을 알아냈죠.

이런 재귀 알고리즘들 중에는 너무 쉬워서 계산할 필요도 없는 입력값들이 있습니다. 예를 들어 sumTo(1)은 그냥 1이죠 (머릿속으로 1초 만에 알 수 있잖아요!). 이렇게 더 이상 재귀를 할 필요 없이 바로 정답이 나오는 단순한 입력값을 기본 케이스(base case)라고 부릅니다. 이 기본 케이스들이 바로 재귀를 멈춰주는 '종료 조건' 역할을 한답니다. 기본 케이스는 보통 입력값이 0, 1, 빈 문자열(""), 혹은 데이터가 없는 상태(null)일 때 나타나는 경우가 많아요.

피보나치 수열

수학에서 가장 유명한 재귀 알고리즘 중 하나가 바로 '피보나치 수열'입니다. 피보나치 수열은 나뭇가지가 뻗어나가는 모양, 조개껍데기의 나선형, 파인애플 껍질의 무늬, 솔방울의 구조 등 자연 속 아주 많은 곳에서 발견할 수 있어요.

피보나치 나선형의 그림은 다음과 같습니다.

나선형 안에 그려진 사각형들의 한 변의 길이를 보면 피보나치 수열의 숫자들과 정확히 일치합니다.

피보나치 수는 수학적으로 이렇게 정의돼요.

$$F(n) = \begin{cases} 0 & \text{if } n = 0 \ 1 & \text{if } n = 1 \ F(n-1) + F(n-2) & \text{if } n > 1 \end{cases}$$

규칙이 수학적으로 정해져 있다 보니, n번째 피보나치 수를 계산하는 재귀 함수를 코드(효율적이지는 않지만)로 짜는 것은 무척 쉽습니다.

#include <iostream>

int fibonacci(int count)
{
    if (count == 0)
        return 0; // 기본 케이스 (종료 조건)
    if (count == 1)
        return 1; // 기본 케이스 (종료 조건)

    return fibonacci(count-1) + fibonacci(count-2);
}

// 처음 13개의 피보나치 수를 보여주는 메인 프로그램
int main()
{
    for (int count { 0 }; count < 13; ++count)
        std::cout << fibonacci(count) << ' ';

    return 0;
}

이 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

0 1 1 2 3 5 8 13 21 34 55 89 144

방금 그림에서 본 피보나치 나선형 다이어그램의 숫자들과 완전히 똑같죠?

메모이제이션 알고리즘

방금 본 피보나치 재귀 알고리즘은 사실 효율이 썩 좋지 않아요. 기본 케이스가 아닐 때마다 함수 안에서 피보나치 함수를 '두 번씩'이나 더 부르기 때문이죠. 이렇게 되면 함수 호출 횟수가 기하급수적으로 늘어납니다 (실제로 위 코드는 fibonacci() 함수를 무려 1205번이나 불렀답니다!).

이런 불필요한 호출을 줄이는 멋진 기술이 있는데, 그중 하나가 바로 메모이제이션(memoization)이에요. 메모이제이션은 복잡하고 오래 걸리는 계산 결과를 '캐시(메모리장)'에 슬쩍 저장해 두었다가, 똑같은 입력값이 다시 들어오면 귀찮게 또 계산하지 않고 저장해 둔 정답을 바로 꺼내주는 기법입니다.

캐시를 적용한(메모이즈된) 피보나치 코드를 살펴볼까요?

#include <iostream>
#include <vector>

// 이 코드의 변형을 제공해준 potterman28wxcv에게 감사를 표합니다 (h/t)
// std::vector를 좀 더 쉽게 다루기 위해 count를 std::size_t 타입으로 바꿨습니다.
int fibonacci(std::size_t count)
{
    // 계산된 결과를 저장(캐시)해 둘 static std::vector를 만듭니다.
    static std::vector results{ 0, 1 };

    // 만약 이미 계산해 본 적 있는 count라면, 저장해둔 결과를 그대로 씁니다!
    if (count < std::size(results))
        return results[count];

    // 계산해 본 적이 없다면 새로 결과를 계산해서 목록에 추가합니다.
    results.push_back(fibonacci(count - 1) + fibonacci(count - 2));
    return results[count];
}

// 처음 13개의 피보나치 수를 보여주는 메인 프로그램
int main()
{
    for (int count { 0 }; count < 13; ++count)
        std::cout << fibonacci(static_cast<std::size_t>(count)) << ' ';

    return 0;
}

이렇게 메모이제이션을 적용하면 함수를 딱 35번만 부르고도 똑같은 결과를 낼 수 있어요. 원래 1205번 불렀던 것에 비하면 엄청난 발전이죠!

재귀 vs 반복

초보자분들이 재귀 함수를 배울 때 가장 많이 하는 질문이 있어요. "for 문이나 while 문 같은 반복문(iterative)을 쓰면 다 똑같이 할 수 있는데, 왜 굳이 어렵게 재귀 함수를 쓰나요?"

맞아요, 재귀로 풀 수 있는 문제는 항상 반복문으로도 풀 수 있습니다. 하지만 복잡하고 까다로운 문제일수록 재귀를 쓰는 쪽이 코드를 작성하기도, 읽기도 훨씬 간결하고 쉬운 경우가 많습니다. 예를 들어, 피보나치수열을 반복문으로 만들 수는 있지만 재귀로 만드는 것보다는 조금 더 골치가 아픕니다! (직접 한 번 시도해 보세요!)

속도 면에서는 반복문(for 루프나 while 루프)이 거의 항상 재귀 함수보다 빠르고 효율적입니다. 함수를 새로 부를 때마다 메모리(스택)를 쌓았다 지웠다 하는 숨은 작업(오버헤드)이 필요한데, 반복문은 그런 과정을 겪지 않기 때문이에요.

그렇다고 반복문이 언제나 정답이라는 뜻은 아닙니다. 코드를 읽기 쉽고 관리하기 편하게(유지 보수) 만드는 게 더 중요할 때가 있거든요. 재귀를 쓰면 코드가 훨씬 깔끔해져서, 약간의 성능을 희생하더라도 이득을 볼 때가 많습니다. (물론 정답을 찾기 위해 함수가 수만 번씩 불려야 하는 극단적인 상황이 아니라면요!)

보통 다음 조건들 중 대부분이 맞을 때 재귀를 사용하는 것이 좋습니다.

• 재귀로 코드를 짜는 게 (반복문보다) 훨씬 간단할 때.
• 재귀가 너무 깊이 들어가지 않을 거라는 보장이 있을 때 (예: 함수가 10만 번씩 연달아 자기 자신을 부를 일이 없을 때).
• 반복문으로 만들 경우 데이터를 저장할 복잡한 스택 구조를 직접 만들어 관리해야 할 때.
• 성능이 0.001초 단위로 중요한 핵심 코드가 아닐 때.

하지만 재귀로 짜는 게 더 쉽다면, 일단 재귀로 먼저 코드를 완성한 다음 나중에 성능을 위해 반복문으로 최적화하는 것도 좋은 방법입니다.

권장 사항 재귀가 정말로 딱 들어맞는 상황이 아니라면, 일반적으로는 재귀보다는 반복문을 우선적으로 사용하는 것이 좋습니다.

20.4 — 명령줄 인수

명령줄 인수가 필요한 이유

이전 레슨(0.5 컴파일러, 링커, 라이브러리 소개)에서 배웠듯이, 코드를 컴파일하고 링크하면 실제로 실행할 수 있는 파일이 하나 만들어집니다. 이 프로그램 파일이 실행되면 언제나 main()이라는 이름의 함수부터 코드가 시작되죠. 우리는 지금까지 main 함수를 다음과 같은 모양으로 써왔습니다.

int main()

여기서 괄호 () 안이 텅 비어 있다는 점에 주목해 보세요. 이 main() 함수는 시작할 때 아무런 입력값(매개변수)도 받지 않겠다는 뜻입니다. 하지만 많은 프로그램은 일을 시작하기 위해 어떤 재료(입력값)를 필요로 합니다.

예를 들어, 큰 이미지 파일을 읽어서 작고 귀여운 썸네일(미리보기 이미지)로 만들어 주는 Thumbnail이라는 프로그램을 만든다고 가정해 볼게요. 이 프로그램은 도대체 '어떤 이미지 파일'을 열어봐야 할지 어떻게 알 수 있을까요? 당연히 사용자가 프로그램에게 어떤 파일을 열지 알려줄 수 있는 방법이 있어야 합니다. 이를 위해 보통은 다음과 같은 방식으로 코드를 짭니다.

// Program: Thumbnail
#include <iostream>
#include <string>

int main()
{
    std::cout << "Please enter an image filename to create a thumbnail for: "; // 썸네일을 만들 이미지 파일 이름을 입력하세요:
    std::string filename{};
    std::cin >> filename;

    // open image file (이미지 파일 열기)
    // create thumbnail (썸네일 생성하기)
    // output thumbnail (썸네일 출력하기)
}

하지만 이 방식에는 큰 단점이 숨어 있습니다. 프로그램을 실행할 때마다 사용자가 직접 키보드로 파일 이름을 타이핑할 때까지 프로그램이 멍하니 멈춰서 기다린다는 것입니다. 물론 여러분이 까만 명령창(터미널)에서 손으로 딱 한 번만 실행한다면 별문제가 아닐 겁니다. 하지만 여러 개의 파일을 한꺼번에 처리하고 싶거나, 내가 만든 프로그램이 아닌 다른 프로그램이 이 프로그램을 자동으로 실행하게 만들고 싶을 때는 아주 불편해집니다.

이 상황들을 조금 더 자세히 파헤쳐 볼까요?

어떤 폴더 안에 있는 모든 이미지 파일의 썸네일을 한꺼번에 다 만들고 싶다고 생각해 봅시다. 방금 짠 코드대로라면 폴더 안의 이미지 개수만큼 프로그램을 여러 번 실행하고, 매번 파일 이름을 일일이 타이핑해야 합니다. 이미지가 수백 개라면 하루 종일 키보드만 두드려야 할지도 몰라요! 이럴 때는 폴더 안의 모든 파일 이름을 확인해서, 각 파일마다 Thumbnail 프로그램을 한 번씩 자동으로 실행해 주는 프로그램을 만드는 것이 훨씬 현명한 해결책입니다.

이번에는 웹사이트를 운영하는 경우를 생각해 봅시다. 사용자가 웹사이트에 이미지를 올릴 때마다 웹사이트가 자동으로 썸네일을 만들게 하고 싶습니다. 그런데 우리가 만든 프로그램은 인터넷에서 입력을 받도록 만들어지지 않았죠. 그렇다면 사용자가 업로드할 때 프로그램에 파일 이름을 어떻게 전달할 수 있을까요? 이럴 때는 웹 서버가 이미지 업로드가 끝나면 자동으로 Thumbnail 프로그램을 켜주는 것이 좋습니다.

결국 위 두 가지 경우 모두, 프로그램이 일단 켜진 후에 사용자가 직접 파일 이름을 쳐주기를 기다리는 방식은 좋지 않습니다. 그보다는 외부 프로그램이 Thumbnail을 처음 켜는 바로 그 순간에 파일 이름이라는 재료(입력 데이터)를 한 번에 쏙 넣어주는 방법이 필요합니다.

명령줄 인수(Command line arguments)란, 프로그램이 처음 시작될 때 운영체제(윈도우, 맥 등)가 프로그램 안으로 쏙 던져주는 추가적인 '문자열(글자) 정보'를 말합니다. 프로그램은 이 정보를 입력값으로 받아서 쓸 수도 있고, 필요 없으면 무시할 수도 있습니다. 마치 함수가 다른 함수에게 매개변수를 넘겨주듯이, 명령줄 인수는 사람이나 다른 프로그램이 어떤 프로그램에게 시작부터 입력값을 쥐여주는 방법이라고 생각하면 이해하기 쉽습니다.

명령줄 인수 전달하기

우리가 만든 실행 프로그램은 까만 명령창(터미널)에서 파일 이름을 타이핑해서 직접 실행할 수 있습니다. 예를 들어, 윈도우 컴퓨터의 현재 폴더에 있는 WordCount라는 실행 파일을 켜려면 이렇게 입력합니다.

WordCount

리눅스나 맥(Unix 기반 OS)에서는 보통 이렇게 입력하죠.

./WordCount

이 WordCount 프로그램에 명령줄 인수를 전달하는 방법은 아주 간단합니다. 그냥 프로그램 이름 뒤에 띄어쓰기를 하고 원하는 인수를 쭉 적어주면 됩니다.

WordCount Myfile.txt

이제 WordCount 프로그램이 실행될 때, Myfile.txt라는 글자가 명령줄 인수로서 프로그램에 쏙 들어갑니다. 스페이스바(띄어쓰기)를 기준으로 여러 개의 인수를 전달하는 것도 가능합니다.

WordCount Myfile.txt Myotherfile.txt

만약 명령창이 아니라 코드를 짜는 프로그램(IDE)에서 실행 버튼을 눌러 테스트하고 있다면, IDE 안에도 명령줄 인수를 입력할 수 있는 설정 창이 따로 있습니다.

• Microsoft Visual Studio의 경우: 솔루션 탐색기에서 프로젝트 이름을 마우스 오른쪽 버튼으로 클릭한 뒤, 속성(Properties)을 선택하세요. 구성 속성(Configuration Properties) 아래의 디버깅(Debugging) 메뉴를 엽니다. 오른쪽 화면을 보면 명령 인수(Command Arguments)라는 칸이 있습니다. 거기에 테스트할 인수를 적어두면, 실행 버튼을 누를 때마다 그 인수가 자동으로 프로그램에 전달됩니다.
• Code::Blocks의 경우: 위쪽 메뉴에서 Project(프로젝트) -> Set program’s arguments(프로그램 인수 설정)를 선택하면 됩니다.

명령줄 인수 사용하기

자, 밖에서 프로그램 안으로 인수를 어떻게 던져주는지는 알게 되었습니다. 이제 해야 할 일은 C++ 코드 안에서 그 인수를 잘 받아서 사용하는 것이겠죠? 그러기 위해서 우리는 지금까지 썼던 텅 빈 main()과는 조금 다른 모양의 main() 함수를 써야 합니다. 이 새로운 main() 함수는 두 개의 매개변수를 받는데, C++ 세상의 관습에 따라 보통 argc와 argv라는 이름을 씁니다.

int main(int argc, char* argv[])

가끔 코드를 보다 보면 다음과 같이 쓰인 것도 볼 수 있습니다.

int main(int argc, char** argv)

컴퓨터 입장에서는 이 두 가지 코드가 완전히 똑같이 작동합니다. 하지만 첫 번째 방식이 눈으로 볼 때 배열(목록)이라는 느낌이 확 들어서 초보자가 직관적으로 이해하기 훨씬 쉽습니다. 그래서 보통 첫 번째 방식을 더 많이 사용합니다.

• argc: 이 프로그램에 전달된 인수의 총 개수를 담고 있는 정수입니다. (쉽게 외우는 꿀팁: argument count의 줄임말입니다.) 사용자가 아무런 인수를 안 줬더라도 argc는 무조건 최소 1입니다. 왜냐하면 '실행되는 프로그램의 이름 자기 자신'이 항상 첫 번째 인수로 들어가기 때문입니다. 사용자가 뒤에 인수를 하나씩 추가해서 적어줄 때마다 이 argc 숫자도 1씩 늘어납니다.
• argv: 실제로 전달된 인수 값(글자들)이 들어 있는 곳입니다. (꿀팁: argument values의 줄임말이라고 생각하세요. 정확한 명칭은 'argument vectors'입니다.) char* argv[]라는 선언 부분이 초보자에게는 살짝 무시무시하게 생겼지만, 전혀 겁먹을 필요 없습니다. argv는 그냥 여러 개의 글자 뭉치(문자열)를 줄지어 담아놓은 배열(목록)일 뿐입니다. 이 목록에 몇 개의 글자 뭉치가 들어있는지가 바로 argc인 것이죠.

전달받은 모든 명령줄 인수를 화면에 출력해 주는 MyArgs라는 짧은 프로그램을 직접 만들어 봅시다.

// Program: MyArgs
#include <iostream>

int main(int argc, char* argv[])
{
    std::cout << "There are " << argc << " arguments:\n"; // 인수가 총 argc개 있습니다:

    // Loop through each argument and print its number and value
    // (각 인수를 하나씩 차례대로 확인하면서 번호와 실제 값을 출력합니다)
    for (int count{ 0 }; count < argc; ++count)
    {
        std::cout << count << ' ' << argv[count] << '\n';
    }

    return 0;
}

이제 명령창에서 Myfile.txt와 100이라는 인수를 달아서 프로그램(MyArgs)을 실행해 보면, 화면에 다음과 같이 출력됩니다.

There are 3 arguments:
0 C:\MyArgs
1 Myfile.txt
2 100

보시다시피 0번 인수는 현재 실행 중인 프로그램의 전체 경로와 이름입니다. 1번과 2번 인수가 바로 우리가 직접 뒤에 적어서 넘겨준 두 개의 명령줄 인수입니다.

참고로... 여기서 argv 배열을 하나씩 꺼내 볼 때 C++의 편리한 기능인 '범위 기반 for문(range-based for-loop)'을 사용할 수 없습니다. argv는 크기 정보가 깎여나간 옛날 C언어 스타일의 배열이기 때문에 작동하지 않거든요. 따라서 위 코드처럼 숫자를 세며 도는 고전적인 for문을 사용해야 합니다.

숫자로 된 인수 다루기

아주 중요한 사실이 하나 있습니다. 명령줄 인수는 우리가 100처럼 숫자 형태를 적어서 넘겨주더라도, 프로그램 안으로는 무조건 '문자열(글자)' 형태로 들어옵니다. 즉 계산기처럼 숫자 100으로 인식하는 게 아니라 글자 "100"으로 인식한다는 뜻입니다.

그래서 명령줄 인수를 진짜 숫자처럼 계산에 쓰고 싶다면, 이 글자를 숫자로 바꿔주는 변환 과정이 반드시 필요합니다. 안타깝게도 C++에서는 이 과정이 초보자가 느끼기에 조금 복잡하게 느껴질 수 있습니다.

C++에서 글자를 숫자로 변환하는 대표적인 방법은 다음과 같습니다.

#include <iostream>
#include <sstream> // for std::stringstream (std::stringstream 기능을 사용하기 위해 필요합니다)
#include <string>

int main(int argc, char* argv[])
{
    if (argc <= 1)
    {
        // On some operating systems, argv[0] can end up as an empty string instead of the program's name.
        // We'll conditionalize our response on whether argv[0] is empty or not.
        // (일부 운영체제에서는 프로그램 이름이 들어와야 할 argv[0]이 빈칸으로 들어올 수도 있습니다. 
        // 따라서 argv[0]이 비어있는지 아닌지에 따라 화면에 보여줄 안내문을 다르게 만듭니다.)
        if (argv[0])
            std::cout << "Usage: " << argv[0] << " <number>" << '\n'; // 올바른 사용법: (프로그램 이름) <숫자>
        else
            std::cout << "Usage: <program name> <number>" << '\n'; // 올바른 사용법: <프로그램 이름> <숫자>

        return 1;
    }

    std::stringstream convert{ argv[1] }; // set up a stringstream variable named convert, initialized with the input from argv[1]
    // (첫 번째 인수로 들어온 글자 argv[1]을 집어넣어, 'convert'라는 이름의 stringstream 변수를 만듭니다.)

    int myint{};
    if (!(convert >> myint)) // do the conversion (변환을 시도해 봅니다)
        myint = 0; // if conversion fails, set myint to a default value (만약 숫자가 아닌 글자라서 변환에 실패하면, 기본값인 0으로 설정합니다)

    std::cout << "Got integer: " << myint << '\n'; // 정수 획득 성공: (숫자)

    return 0;
}

이 프로그램에 567이라는 입력을 같이 주어 실행하면 다음과 같이 나옵니다.

Got integer: 567

여기서 사용된 std::stringstream이라는 마법의 도구는 우리가 키보드로 입력을 받을 때 쓰는 std::cin과 작동 방식이 거의 똑같습니다. std::cin이 키보드 입력을 쭉 빨아들여서 숫자로 바꿔주듯이, 여기서는 argv[1]에 들어있는 글자("567")를 가져다 놓고 >> 기호를 사용해 쏙 뽑아내어 정수형 변수인 myint에 진짜 숫자로 저장하는 원리입니다.

std::stringstream에 대해서는 뒤에 나오는 챕터에서 훨씬 더 자세히 다룰 예정이니, 지금은 '아, 글자를 숫자로 바꿀 때 쓰는 도구구나' 정도로만 이해하셔도 충분합니다.

운영체제가 명령줄 인수를 먼저 분석합니다

명령창에 무언가를 타이핑해서 엔터를 치거나 IDE에서 프로그램을 실행할 때, 여러분의 명령을 제일 먼저 받아서 처리하는 것은 바로 운영체제(윈도우, 맥, 리눅스 등)입니다. 운영체제는 단순히 실행 파일을 더블클릭해서 켜주는 역할만 하는 게 아닙니다. 여러분이 띄어쓰기로 적어놓은 인수들을 어떻게 잘라서 프로그램에 넘겨줄지 먼저 분석(파싱)하는 아주 중요한 역할을 합니다.

일반적으로 운영체제들은 큰따옴표(")나 역슬래시(\) 같은 특수 문자를 만나면 자기만의 특별한 규칙을 적용합니다.

예를 들어 다음과 같이 띄어쓰기를 해서 입력하면:

MyArgs Hello world!

운영체제는 띄어쓰기를 기준으로 싹둑싹둑 자르기 때문에 아래처럼 두 개의 다른 인수로 들어갑니다.

There are 3 arguments:
0 C:\MyArgs
1 Hello
2 world!

하지만, 띄어쓰기가 있더라도 큰따옴표(")로 묶어주면 운영체제는 '아, 이건 떨어져 있어도 하나의 덩어리구나!'라고 똑똑하게 인식합니다.

MyArgs "Hello world!"

결과는 다음과 같이 띄어쓰기가 포함된 하나의 덩어리로 잘 나옵니다.

There are 2 arguments:
0 C:\MyArgs
1 Hello world!

그렇다면 큰따옴표 기호(") 그 자체를 글자로 넘겨주고 싶을 때는 어떻게 할까요? 대부분의 운영체제에서는 큰따옴표 앞에 역슬래시(\)를 붙여서 '이건 특수 기능이 아니라 그냥 일반 글자 큰따옴표야!'라고 알려줄 수 있습니다.

MyArgs \"Hello world!\"

이렇게 치면 앞뒤에 큰따옴표가 고스란히 달린 채로 글자가 잘 전달됩니다.

There are 3 arguments:
0 C:\MyArgs
1 "Hello
2 world!"

이 밖에도 여러분이 어떤 운영체제를 쓰느냐에 따라 특수문자를 일반 글자처럼 전달하기 위해(이스케이프 처리) 역슬래시를 붙여야 하는 문자가 더 있을 수 있습니다.

결론

명령줄 인수는 프로그램이 딱 켜지는 바로 그 순간에 사용자나 다른 프로그램이 아주 간편하게 입력 데이터를 던져줄 수 있는 훌륭한 방법입니다.

여러분이 앞으로 프로그램을 만들 때 시작하자마자 꼭 필요한 재료(데이터)가 있다면, 그것을 명령줄 인수로 받도록 설계해 보세요. 그리고 만약 깜빡하고 명령줄 인수를 안 넣고 실행했다면? 그땐 프로그램 안에서 스스로 알아채고 "파일 이름을 입력해주세요~"라고 물어보게끔 코드를 짜면 됩니다. 이렇게 두 가지 방식을 잘 섞어 쓰면, 수백 개 파일을 자동으로 돌릴 때도 편하고 직접 하나씩 실행할 때도 친절한 일석이조의 프로그램을 만들 수 있습니다.

20.5 — 생략 부호(Ellipsis)와 이를 피해야 하는 이유

지금까지 우리가 배운 모든 함수들은, 함수가 받을 '재료(매개변수)'의 개수를 미리 정확히 알고 있어야 했습니다. (기본값을 설정해 두었더라도 말이죠.) 하지만, 상황에 따라 함수에 원하는 개수만큼 마음대로 재료를 넘겨주고 싶을 때가 있습니다. C++에서는 이를 가능하게 해주는 특별한 기능인 생략 부호(ellipsis, ...)를 제공합니다.

생략 부호는 실제로 잘 사용되지 않으며, 잠재적으로 위험할 수 있어서 가급적 사용하지 않는 것을 권장합니다. 따라서 이 섹션의 내용은 가볍게 읽고 넘어가셔도 좋습니다.

생략 부호를 사용하는 함수는 다음과 같이 생겼습니다.

반환_타입 함수_이름(매개변수_목록, ...)

여기서 매개변수_목록은 우리가 평소에 쓰는 일반적인 매개변수들입니다. 중요한 점은, 생략 부호를 쓰려면 반드시 한 개 이상의 일반 매개변수가 앞에 있어야 한다는 것입니다. 함수에 전달된 값들은 먼저 일반 매개변수들의 자리를 채우게 됩니다.

점 세 개(...)로 표현되는 생략 부호는 반드시 함수의 맨 마지막 매개변수로 적어야 합니다. 이 생략 부호는 앞의 일반 매개변수들이 다 채워지고 남은 '추가 재료'들을 모두 쓸어 담는 역할을 합니다. 정확한 표현은 아니지만, 초보자분들은 이 생략 부호를 남은 매개변수들을 몽땅 담아두는 하나의 바구니(배열)라고 생각하시면 이해하기 쉽습니다.

생략 부호(Ellipsis) 예제

생략 부호를 배우는 가장 좋은 방법은 직접 코드를 보는 것입니다! 여러 개의 정수를 받아서 평균을 구해주는 간단한 프로그램을 만들어 보겠습니다. 코드는 다음과 같습니다:

#include <iostream>
#include <cstdarg> // 생략 부호를 사용하기 위해 꼭 필요합니다!

// 생략 부호(...)는 반드시 마지막 매개변수여야 합니다.
// count는 우리가 뒤에 추가로 몇 개의 숫자를 더 넘겨줄 것인지 알려줍니다.
double findAverage(int count, ...)
{
    int sum{ 0 };

    // 생략 부호에 담긴 값들을 꺼내 보려면 va_list라는 특별한 도구가 필요합니다.
    std::va_list list;

    // va_start를 사용해 va_list를 준비시킵니다.
    // 첫 번째 인자는 방금 만든 list이고,
    // 두 번째 인자는 생략 부호 바로 앞에 있던 마지막 일반 매개변수(여기선 count)입니다.
    va_start(list, count);

    // 생략 부호에 담긴 값의 개수만큼 반복문을 돌립니다.
    for (int arg{ 0 }; arg < count; ++arg)
    {
         // va_arg를 사용해 생략 부호 바구니에서 값을 하나씩 꺼냅니다.
         // 첫 번째 인자는 우리가 사용하는 list이고,
         // 두 번째 인자는 우리가 꺼낼 값의 '타입(자료형)'입니다.
         sum += va_arg(list, int);
    }

    // 작업이 다 끝났으면 va_list를 정리(청소)해 줍니다.
    va_end(list);

    return static_cast<double>(sum) / count;
}

int main()
{
    // 5개의 숫자를 추가로 넘깁니다: 1, 2, 3, 4, 5
    std::cout << findAverage(5, 1, 2, 3, 4, 5) << '\n';

    // 6개의 숫자를 추가로 넘깁니다: 1, 2, 3, 4, 5, 6
    std::cout << findAverage(6, 1, 2, 3, 4, 5, 6) << '\n';

    return 0;
}

이 코드를 실행하면 다음과 같이 출력됩니다:

3
3.5

보시다시피, 이 함수는 매번 다른 개수의 숫자들을 받아들일 수 있습니다! 자, 이제 이 마법 같은 일이 어떻게 일어나는지 하나씩 뜯어볼까요?

1. 가장 먼저 <cstdarg> 헤더 파일을 포함해야 합니다. 이 파일 안에는 생략 부호에 숨겨진 값들을 꺼내 쓰는 데 필요한 핵심 도구들(va_list, va_arg, va_start, va_end)이 들어있습니다.
2. 그런 다음 함수를 선언합니다. 일반 매개변수가 최소 하나는 있어야 하죠. 여기서는 count라는 정수를 받아서, 뒤에 몇 개의 숫자가 더 따라올지 미리 알려줍니다. 그리고 맨 마지막에 ...을 적습니다.
3. 주의할 점은 생략 부호 매개변수에는 이름이 없다는 것입니다! 대신, 우리는 va_list라는 특별한 타입을 사용해 그 안의 값들에 접근합니다. 초보자분들은 va_list를 생략 부호 바구니 안의 숫자들을 차례대로 가리키는 요술 손가락(포인터)이라고 생각하시면 좋습니다. 우리는 이 손가락의 이름을 간단히 list라고 지었습니다.
4. 이제 va_start()를 불러서 이 요술 손가락이 첫 번째 추가 숫자를 가리키게 준비시킵니다.
5. 현재 손가락이 가리키는 값을 실제로 꺼내오려면 va_arg()를 씁니다. 이때 어떤 타입(예: int)으로 꺼낼지 알려줘야 합니다. 재미있는 점은, va_arg()로 값을 하나 꺼내면, 요술 손가락이 알아서 다음 숫자를 가리키도록 옆으로 이동한다는 것입니다!
6. 모든 작업이 끝나면 va_end()를 불러서 사용했던 도구를 깔끔하게 정리해 줍니다.

참고로, 처음부터 다시 값들을 읽고 싶다면 언제든지 va_start()를 다시 불러서 손가락을 맨 처음 위치로 되돌릴 수 있습니다.

생략 부호가 위험한 이유 첫 번째: 타입 검사(Type checking)가 무시됩니다

생략 부호는 매개변수 개수를 마음대로 조절할 수 있는 엄청난 자유를 줍니다. 하지만, 큰 자유에는 큰 책임이 따르는 법이죠.

일반적으로 C++ 컴파일러는 아주 꼼꼼한 선생님 같습니다. 함수가 정수(int)를 원하는데 여러분이 문자열(string)을 넘겨주면, "타입이 안 맞잖아!"라며 경고를 주고 실행을 막아줍니다. 이를 '타입 검사'라고 합니다.

하지만 생략 부호 안으로 들어가는 값들에 대해서는 컴파일러가 이 검사를 아예 포기해 버립니다. 즉, 아무 타입이나 막 집어넣을 수 있다는 뜻입니다. 문제는, 여러분이 실수로 말도 안 되는 값을 넣어도 컴파일러가 아무런 경고를 해주지 않는다는 것입니다. 오직 함수를 호출하는 사람(여러분)이 알아서 올바른 값을 넣었기를 기도해야 합니다. 당연히 실수가 발생하기 아주 쉽겠죠?

아주 미묘하지만 치명적인 실수 예시를 보겠습니다:

// 두 번째 숫자(첫 번째 추가 숫자)로 정수 1이 아니라 소수점 1.0(double)을 넣었습니다!
std::cout << findAverage(6, 1.0, 2, 3, 4, 5, 6) << '\n';

언뜻 보면 별문제가 없어 보입니다. 컴파일도 완벽하게 됩니다. 하지만 결과는 아주 충격적입니다:

1.78782e+008

무려 1억 7천만이 넘는 엄청나게 큰 쓰레기 값이 나왔습니다. 도대체 무슨 일이 일어난 걸까요?

컴퓨터는 모든 데이터를 0과 1의 조합(비트)으로 저장합니다. 변수의 '타입'은 컴퓨터에게 이 0과 1들을 어떻게 해석할지 알려주는 설명서와 같습니다. 그런데 앞서 말했듯, 생략 부호는 이 '타입 설명서'를 갖다 버립니다! 그래서 값을 제대로 꺼내려면 va_arg()에게 "이번에 꺼낼 값은 int야!"라고 수동으로 알려줘야 합니다.

위 코드에서 우리는 함수 안에서 va_arg(list, int)를 쓰며 모든 값이 int(정수)일 것이라고 찰떡같이 믿고 있었습니다. 그런데 우리가 넣은 1.0은 double(실수) 타입이고 크기가 8바이트입니다. 반면 int는 4바이트죠. 결과적으로 va_arg는 8바이트짜리 실수 데이터의 절반(4바이트)만 뚝 잘라서 정수로 잘못 해석해 버리고, 다음번엔 나머지 절반을 또 정수로 해석합니다. 데이터가 완전히 꼬여버려서 '쓰레기 값'이 나오게 된 것입니다.

심지어 아래처럼 말도 안 되는 코드를 짜도 컴파일러는 불평 한마디 안 합니다:

int value{ 7 };
// 소수점, 문자열, 문자, 변수의 주소, 함수의 주소 등 온갖 잡동사니를 다 넣었습니다.
std::cout << findAverage(6, 1.0, 2, "Hello, world!", 'G', &value, &findAverage) << '\n';

믿기 어렵겠지만, 이 코드도 정상적으로 컴파일되며 작성자의 컴퓨터에서는 1.79766e+008이라는 쓰레기 값을 내뱉었습니다.

컴퓨터 공학에는 "쓰레기가 들어가면 쓰레기가 나온다 (Garbage in, garbage out)"라는 유명한 말이 있습니다. 컴퓨터는 바보 같아서, 사람이 아무리 터무니없는 데이터를 줘도 의심 없이 처리하고 터무니없는 결과를 돌려준다는 뜻이죠. 생략 부호가 딱 이렇습니다.

생략 부호가 위험한 이유 두 번째: 매개변수가 몇 개나 전달되었는지 모릅니다

생략 부호는 값의 '타입'만 버리는 게 아니라, 값이 '몇 개'나 들어왔는지도 잊어버립니다. 그래서 우리가 직접 몇 개의 값이 들어왔는지 추적하는 방법을 만들어내야 합니다. 보통 다음 3가지 방법 중 하나를 사용합니다.

방법 1: 길이(개수)를 매개변수로 전달하기

첫 번째 방법은, 우리가 앞서 findAverage() 예제에서 했던 것처럼 앞쪽 일반 매개변수로 "내가 추가로 O개의 값을 더 줄게!"라고 미리 개수를 알려주는 것입니다.

하지만 이 방법도 완벽하진 않습니다. 아래 코드를 볼까요?

// "6개 줄게!" 라고 해놓고 실제로는 5개(1, 2, 3, 4, 5)만 줬습니다.
std::cout << findAverage(6, 1, 2, 3, 4, 5) << '\n';

이 코드를 실행하면 699773 같은 이상한 값이 나옵니다. 왜 그럴까요? 우리는 함수에게 6개를 달라고 했지만 5개밖에 주지 않았습니다. 함수는 5개까지는 잘 꺼내지만, 6번째 값을 찾기 위해 컴퓨터 메모리의 엉뚱한 공간(스택)을 뒤져서 아무 쓰레기 값이나 가져와 버렸기 때문입니다.

더 잡기 힘든 실수도 있습니다:

// "6개 줄게!" 라고 해놓고 실수로 7개(1, 2, 3, 4, 5, 6, 7)를 줬습니다.
std::cout << findAverage(6, 1, 2, 3, 4, 5, 6, 7) << '\n';

이 결과는 3.5가 나옵니다. 얼핏 맞게 나온 것 같지만, 사실 함수는 6번째 숫자인 6까지만 계산하고 맨 마지막에 있는 7은 완전히 무시해 버렸습니다. 이런 종류의 실수는 버그를 찾아내기가 정말 힘듭니다.

방법 2: 보초값(Sentinel value) 사용하기

두 번째 방법은 끝을 알리는 특별한 표지판, 즉 '보초값'을 사용하는 것입니다. 문자열의 끝을 알리는 널 종료 문자(\0)를 생각하시면 됩니다. 생략 부호에서는 보통 맨 마지막 값으로 이 보초값을 줍니다. 끝을 알리는 표지판으로 -1을 사용하는 예제를 살펴봅시다:

#include <iostream>
#include <cstdarg> 

// 생략 부호는 마지막에 와야 합니다.
double findAverage(int first, ...)
{
    // 첫 번째 숫자는 따로 처리해 줍니다.
    int sum{ first };

    std::va_list list;

    // 첫 번째 매개변수(first)를 기준으로 va_list를 초기화합니다.
    va_start(list, first);

    int count{ 1 };
    // 무한 반복을 돕니다.
    while (true)
    {
        // 값을 하나 꺼냅니다.
        int arg{ va_arg(list, int) };

        // 만약 꺼낸 값이 우리가 정한 보초값(-1)이라면 반복문을 탈출합니다!
        if (arg == -1)
            break;

        sum += arg;
        ++count;
    }

    va_end(list);

    return static_cast<double>(sum) / count;
}

int main()
{
    // 맨 마지막에 끝을 알리는 -1을 꼭 넣어줍니다.
    std::cout << findAverage(1, 2, 3, 4, 5, -1) << '\n';
    std::cout << findAverage(1, 2, 3, 4, 5, 6, -1) << '\n';

    return 0;
}

이제 첫 번째 매개변수로 "몇 개를 줄 건지" 미리 말하지 않아도 됩니다. 대신 끝에 보초값만 잘 꽂아주면 되죠.

하지만 여기에도 단점이 있습니다. 첫째, C++ 규칙상 생략 부호 앞에는 일반 매개변수가 꼭 하나 있어야 합니다. 그래서 평균을 낼 첫 번째 숫자를 일반 매개변수(first)로 억지로 빼내어 따로 처리해야 하는 번거로움이 생겼습니다. 둘째, 사용자가 맨 끝에 보초값 넣는 것을 깜빡하면 함수는 -1이 우연히 나올 때까지 메모리를 끝없이 헤집고 다니며 무한 루프를 돌거나 프로그램이 팅겨버립니다. 셋째, 만약 우리가 음수(-1)까지 포함해서 평균을 내고 싶다면 어떻게 될까요? -1을 더 이상 끝을 알리는 신호로 쓸 수 없게 됩니다. 보초값은 '내가 계산하려는 실제 데이터 중에는 절대 나올 수 없는 값'으로 정해야만 안전합니다.

방법 3: 해독 문자열(Decoder string) 사용하기

세 번째 방법은, 마치 암호문 같은 "해독 문자열"을 넘겨주어 프로그램에게 매개변수의 개수와 타입을 친절하게 알려주는 방식입니다.

#include <iostream>
#include <string_view>
#include <cstdarg>

// 첫 번째 매개변수로 해독 문자열(decoder)을 받습니다.
double findAverage(std::string_view decoder, ...)
{
    double sum{ 0 };

    std::va_list list;
    va_start(list, decoder);

    // 해독 문자열의 글자를 하나씩 확인합니다.
    for (auto codetype: decoder)
    {
        switch (codetype)
        {
        case 'i': // 글자가 'i'이면 정수(int)로 꺼냅니다.
            sum += va_arg(list, int);
            break;

        case 'd': // 글자가 'd'이면 실수(double)로 꺼냅니다.
            sum += va_arg(list, double);
            break;
        }
    }

    va_end(list);

    // 해독 문자열의 길이(std::size)가 곧 매개변수의 개수입니다.
    return sum / std::size(decoder);
}

int main()
{
    // "iiiii" -> 5개의 정수(i)가 뒤따라온다는 뜻입니다.
    std::cout << findAverage("iiiii", 1, 2, 3, 4, 5) << '\n';

    // "iiiiii" -> 6개의 정수(i)가 뒤따라옵니다.
    std::cout << findAverage("iiiiii", 1, 2, 3, 4, 5, 6) << '\n';

    // "iiddi" -> 정수, 정수, 실수, 실수, 정수 순서로 온다는 뜻입니다!
    std::cout << findAverage("iiddi", 1, 2, 3.5, 4.5, 5) << '\n';

    return 0;
}

이 방식의 가장 큰 장점은 여러 가지 다양한 타입(정수, 실수 등)을 섞어서 받을 수 있다는 것입니다. 하지만 암호문 문자열을 작성하는 게 조금 복잡해 보일 수 있고, 만약 여러분이 실수로 암호문과 실제 데이터를 다르게 적는다면 여전히 끔찍한 에러가 발생합니다.

(C 언어를 배워보신 분이라면 눈치채셨겠지만, 여러분이 흔히 쓰던 printf 함수가 정확히 이 방식(%d, %f 등)을 사용합니다!)

생략 부호를 더 안전하게 사용하는 권장 사항

1. 가장 좋은 방법은 생략 부호를 아예 쓰지 않는 것입니다! 조금 번거롭더라도 더 안전한 다른 대안들이 많습니다. 예를 들어, 위의 평균 구하기 예제라면 개수를 마음대로 늘렸다 줄일 수 있는 동적 배열(std::vector 같은 것)을 넘겨주는 것이 훨씬 좋습니다. 그러면 컴파일러가 강력한 타입 검사를 해줘서 이상한 값이 들어오는 걸 막아주면서도, 원하는 개수만큼 데이터를 넘길 수 있습니다.
2. 부득이하게 생략 부호를 꼭 써야 한다면, 모든 추가 매개변수의 타입을 똑같이 통일하는 것이 좋습니다. (전부 다 int로 하거나 전부 다 double로 하는 식으로요.) 정수와 실수를 막 섞어 쓰면 타입이 꼬여서 쓰레기 값이 나올 확률이 폭발적으로 늘어납니다.
3. 개수를 직접 알려주거나 해독 문자열을 쓰는 방식(방법 1, 3)이 보초값을 쓰는 방식(방법 2)보다 그나마 안전합니다. 적어도 사용자가 횟수를 명확히 정해주기 때문에, 잘못된 값이 들어가더라도 무한 루프에 빠지는 대참사는 막을 수 있기 때문입니다.

고급 학습자를 위한 내용 기존 생략 부호의 단점을 개선하기 위해, C++11에서는 매개변수 팩(parameter packs)과 가변 인자 템플릿(variadic templates)이라는 기능을 도입했습니다. 이는 생략 부호처럼 개수가 자유로우면서도 강력한 타입 검사를 지원합니다. 하지만 사용법이 너무 어려워 널리 쓰이지는 못했습니다. 이후 C++17에서 폴드 표현식(fold expressions)이 추가되면서 매개변수 팩의 사용성이 크게 개선되었고, 현재는 생략 부호를 대체할 아주 실용적인 선택지가 되었습니다. 이 사이트의 향후 업데이트에서 이 멋진 주제들에 대한 강의를 추가할 예정입니다.

20.6 — 람다(익명 함수) 소개

18.3 레슨(표준 라이브러리 알고리즘 소개)에서 다루었던 다음 코드를 한번 살펴볼까요?

#include <algorithm>
#include <array>
#include <iostream>
#include <string_view>

// 요소가 일치하면 이 함수는 true를 반환합니다.
bool containsNut(std::string_view str)
{
    // std::string_view::find는 부분 문자열을 찾지 못하면 std::string_view::npos를 반환합니다.
    // 찾았다면 str 안에서 해당 부분 문자열이 시작하는 인덱스(위치)를 반환합니다.
    return str.find("nut") != std::string_view::npos;
}

int main()
{
    constexpr std::array<std::string_view, 4> arr{ "apple", "banana", "walnut", "lemon" };

    // 배열을 훑어보면서 "nut"이라는 글자가 포함된 요소가 있는지 확인합니다.
    auto found{ std::find_if(arr.begin(), arr.end(), containsNut) };

    if (found == arr.end())
    {
        std::cout << "No nuts\n";
    }
    else
    {
        std::cout << "Found " << *found << '\n';
    }

    return 0;
}

이 코드는 문자열 배열을 검색해서 "nut"이라는 글자가 들어간 첫 번째 단어를 찾습니다. 실행하면 다음과 같은 결과가 나옵니다.

Found walnut

코드가 잘 작동하긴 하지만, 좀 더 깔끔하게 고칠 수 있습니다. 가장 큰 문제는 std::find_if 함수를 사용할 때 함수 포인터를 넘겨주어야 한다는 점입니다. 겨우 딱 한 번 쓰고 말 함수인데도 굳이 이름을 지어줘야 하고, 함수 안에 함수를 만들 수 없으니 코드 맨 바깥쪽(전역 범위)에 덩그러니 만들어야 하죠. 게다가 함수 내용이 너무 짧아서, 함수 이름이나 주석을 읽는 것보다 그냥 코드 한 줄을 보는 게 이해하기 더 빠를 정도입니다.

람다는 이름이 없는 익명 함수입니다

람다 표현식(간단히 람다 또는 클로저라고도 부릅니다)을 사용하면 함수 안에서 '이름이 없는 함수'를 뚝딱 만들 수 있습니다. 이렇게 함수 안에 함수를 중첩해서 만들면 이름이 겹쳐서 코드가 지저분해지는 것(이름 공간 오염)을 막을 수 있고, 함수를 실제로 사용하는 곳 바로 옆에 정의할 수 있어서 코드를 읽기 훨씬 편해집니다.

C++에서 람다 문법은 처음 보면 굉장히 특이하게 생겨서 적응할 시간이 조금 필요합니다. 람다는 다음과 같은 모양을 가집니다.

[ 캡처_블록 ] ( 매개변수 ) -> 반환_타입
{
    실행할_코드;
}

• 캡처 블록 (Capture clause): 바깥쪽 변수를 가져다 쓸 필요가 없다면 비워두어도 됩니다 [].
• 매개변수 (Parameters): 함수에 전달할 값이 없다면 비워둘 수 있습니다 (). 반환 타입을 따로 적지 않는다면 괄호 자체를 아예 생략할 수도 있습니다.
• 반환 타입 (Return type): 생략 가능합니다. 생략하면 컴파일러가 auto처럼 알아서 결과값을 보고 타입을 유추해 줍니다. 일반 함수에서는 반환 타입을 컴파일러에게 맡기는 것을 피하라고 했지만, 람다는 보통 코드가 아주 짧고 단순하기 때문에 컴파일러에게 맡겨도 괜찮습니다.

그리고 람다는 이름이 없는(익명) 함수이므로 이름을 지어줄 필요가 전혀 없습니다.

참고로... 가장 단순한 형태의 람다는 다음과 같이 생겼습니다.

#include <iostream>
>
int main()
{
  [] {}; // 반환 타입 생략, 캡처 없음, 매개변수 생략된 가장 단순한 람다입니다.
>
  return 0;
}

이제 처음 보았던 예제를 람다를 사용해서 다시 써보겠습니다.

#include <algorithm>
#include <array>
#include <iostream>
#include <string_view>

int main()
{
  constexpr std::array<std::string_view, 4> arr{ "apple", "banana", "walnut", "lemon" };

  // 함수가 필요한 바로 그 자리에 함수를 직접 정의합니다.
  auto found{ std::find_if(arr.begin(), arr.end(),
                           [](std::string_view str) // 여기가 람다입니다. 캡처 블록은 비어있습니다.
                           {
                             return str.find("nut") != std::string_view::npos;
                           }) };

  if (found == arr.end())
  {
    std::cout << "No nuts\n";
  }
  else
  {
    std::cout << "Found " << *found << '\n';
  }

  return 0;
}

함수 포인터를 사용했을 때와 완벽하게 똑같이 작동하며, 결과도 동일합니다. 새로 만든 람다를 원래 있던 containsNut 함수와 비교해 보세요. 매개변수와 안의 내용이 완전히 똑같죠? 외부 변수를 쓸 일이 없으니 캡처 블록([])은 비워두었고(캡처 블록에 대해서는 다음 레슨에서 자세히 배웁니다), 코드를 짧게 쓰기 위해 반환 타입(-> bool)도 생략했습니다. != 연산자가 어차피 bool(참/거짓)을 반환하기 때문에 람다도 알아서 bool을 반환하게 됩니다.

권장 사항 코드는 항상 가장 좁은 범위에서, 그리고 처음 사용하는 곳과 가장 가까운 곳에 정의하는 것이 좋습니다. 다른 함수에 인자로 넘겨주기 위해 딱 한 번만 사용할 아주 단순한 함수가 필요하다면, 일반 함수를 만드는 것보다 람다를 사용하는 것이 훨씬 좋습니다.

람다의 타입

위 예제에서는 람다가 필요한 자리에 곧바로 람다를 적어 넣었습니다. 이렇게 사용하는 것을 함수 리터럴(function literal)이라고 부르기도 합니다.

하지만 함수를 호출하는 줄에 람다를 통째로 길게 적으면 코드가 읽기 힘들어질 때가 있습니다. 숫자나 문자를 변수에 미리 저장해두고 나중에 꺼내 쓰는 것처럼, 람다도 변수에 저장해두었다가 나중에 사용할 수 있습니다. 람다에 뜻을 알기 쉬운 이름을 붙여서 변수에 저장해두면 코드를 읽기가 훨씬 편해집니다.

예를 들어, 아래 코드는 배열의 모든 숫자가 짝수인지 확인하는 코드입니다.

// 나쁨: 이 코드가 무슨 일을 하는지 이해하려면 람다 내부 코드를 직접 읽어봐야 합니다.
return std::all_of(array.begin(), array.end(), [](int i){ return ((i % 2) == 0); });

이 코드를 변수를 활용해 읽기 쉽게 바꾸면 다음과 같습니다.

// 좋음: 대신 람다를 이름 있는 변수에 저장하고 그 변수를 함수에 전달합니다.
auto isEven{
  [](int i)
  {
    return (i % 2) == 0;
  }
};

return std::all_of(array.begin(), array.end(), isEven);

마지막 줄을 소리 내어 읽어보세요. "배열(array)의 모든(all_of) 요소가 짝수인지(isEven) 확인해서 반환하라"처럼 아주 자연스럽게 읽힙니다!

핵심 통찰 람다를 변수에 저장하면 람다에 유용한 이름을 붙여줄 수 있어서 코드가 훨씬 읽기 편해집니다. 또한, 람다를 변수에 저장해두면 똑같은 람다를 여러 번 재사용할 수도 있습니다.

그런데 여기서 질문! 변수 isEven의 데이터 타입(자료형)은 대체 무엇일까요?

놀랍게도 람다에는 우리가 직접 코드에 적을 수 있는 명확한 타입 이름이 없습니다. 우리가 람다를 만들면 컴파일러가 알아서 세상에 단 하나뿐인 고유한 비밀 타입을 만들어냅니다.

고급 학습자를 위한 내용 사실 람다는 진짜 함수가 아닙니다 (이것이 C++에서 함수 안에 함수를 못 만드는 규칙을 피해 갈 수 있는 비결이기도 합니다). 람다는 함수처럼 호출해서 쓸 수 있도록 operator()가 오버로딩된 함수 객체(functor)라는 특별한 형태의 객체입니다.

우리가 람다의 진짜 타입 이름은 알 수 없지만, 만든 람다를 변수에 저장하는 방법은 여러 가지가 있습니다. 람다의 캡처 블록이 비어있다면([] 안에 아무것도 없다면) 일반적인 함수 포인터에 저장할 수 있습니다. 또는 캡처 블록이 비어있지 않더라도 std::function이나 auto 키워드를 사용해 저장할 수 있습니다.

#include <functional>

int main()
{
  // 1. 일반 함수 포인터. 캡처 블록이 비어있을 때(빈 [])만 사용할 수 있습니다.
  double (*addNumbers1)(double, double){
    [](double a, double b) {
      return a + b;
    }
  };

  addNumbers1(1, 2);

  // 2. std::function 사용. 캡처 블록이 비어있지 않아도 사용할 수 있습니다 (다음 레슨에서 다룹니다).
  std::function addNumbers2{ // 참고: C++17 이전 버전에서는 std::function<double(double, double)> 라고 써야 합니다.
    [](double a, double b) {
      return a + b;
    }
  };

  addNumbers2(3, 4);

  // 3. auto 사용. 람다의 진짜(숨겨진) 타입 그대로 변수에 저장합니다.
  auto addNumbers3{
    [](double a, double b) {
      return a + b;
    }
  };

  addNumbers3(5, 6);

  return 0;
}

람다의 '진짜 타입'을 그대로 살려서 저장하는 유일한 방법은 auto를 사용하는 것뿐입니다. 게다가 auto를 사용하면 std::function을 사용할 때 발생하는 미세한 성능 저하(오버헤드)도 피할 수 있습니다.

그렇다면 다른 함수에 람다를 인자로 넘겨주고 싶을 때는 어떻게 해야 할까요? 여기에는 4가지 방법이 있습니다.

#include <functional>
#include <iostream>

// 방법 1: `std::function` 매개변수 사용
void repeat1(int repetitions, const std::function<void(int)>& fn)
{
    for (int i{ 0 }; i < repetitions; ++i)
        fn(i);
}

// 방법 2: 타입 템플릿 매개변수를 가진 함수 템플릿 사용
template <typename T>
void repeat2(int repetitions, const T& fn)
{
    for (int i{ 0 }; i < repetitions; ++i)
        fn(i);
}

// 방법 3: 축약된 함수 템플릿 문법 사용 (C++20부터)
void repeat3(int repetitions, const auto& fn)
{
    for (int i{ 0 }; i < repetitions; ++i)
        fn(i);
}

// 방법 4: 함수 포인터 사용 (캡처가 없는 람다에만 가능)
void repeat4(int repetitions, void (*fn)(int))
{
    for (int i{ 0 }; i < repetitions; ++i)
        fn(i);
}

int main()
{
    auto lambda = [](int i)
    {
        std::cout << i << '\n';
    };

    repeat1(3, lambda);
    repeat2(3, lambda);
    repeat3(3, lambda);
    repeat4(3, lambda);

    return 0;
}

• 방법 1은 std::function을 사용합니다. 매개변수로 무엇을 받고 무엇을 반환하는지 명확하게 보여서 좋습니다. 하지만 함수를 호출할 때마다 람다를 은근슬쩍 변환해야 해서 미세한 성능 저하가 생깁니다. 코드를 헤더 파일과 .cpp 파일로 나누기 쉽다는 장점도 있습니다.
• 방법 2는 템플릿(T)을 사용합니다. 코드가 실행될 때 람다의 진짜 타입에 맞춰 가장 빠르고 효율적으로 작동하지만, 매개변수나 반환 타입을 한눈에 파악하기 어렵다는 단점이 있습니다.
• 방법 3은 C++20의 auto를 사용한 방법으로, 내부적으로는 방법 2와 완전히 똑같은 템플릿을 만들어냅니다.
• 방법 4는 함수 포인터를 사용합니다. 캡처가 없는 단순한 람다는 함수 포인터로 자동 변환되기 때문에 가능한 방법입니다.

권장 사항 람다를 변수에 저장할 때는 무조건 auto를 사용하세요. 람다를 다른 함수로 넘겨줄 때는:

• C++20 이상을 사용 중이라면 매개변수 타입으로 auto를 사용하세요.
• 그 이전 버전을 사용 중이라면 함수 템플릿이나 std::function을 사용하세요 (캡처가 없는 단순 람다라면 함수 포인터도 괜찮습니다).

제네릭 람다

기본적으로 람다의 매개변수는 일반 함수의 매개변수와 똑같이 작동합니다. 하지만 아주 중요한 차이점이 하나 있는데, C++14부터 람다의 매개변수 타입으로 auto를 사용할 수 있다는 점입니다 (참고로 C++20부터는 일반 함수도 매개변수에 auto를 쓸 수 있게 되었습니다).

매개변수에 auto를 적어두면, 람다를 호출할 때 넘겨주는 값을 보고 컴파일러가 알아서 알맞은 데이터 타입을 맞춰줍니다. 이렇게 auto 매개변수를 가져서 어떤 데이터 타입이든 유연하게 받아낼 수 있는 람다를 제네릭 람다(generic lambdas)라고 부릅니다.

고급 학습자를 위한 내용 람다에서 auto를 사용하는 것은 사실 템플릿 매개변수를 짧게 줄여 쓴 것과 같습니다.

제네릭 람다를 사용하는 예제를 볼까요?

#include <algorithm>
#include <array>
#include <iostream>
#include <string_view>

int main()
{
  constexpr std::array months{ // C++17 이전에는 std::array<const char*, 12> 라고 써야 합니다.
    "January",
    "February",
    "March",
    "April",
    "May",
    "June",
    "July",
    "August",
    "September",
    "October",
    "November",
    "December"
  };

  // 같은 알파벳으로 시작하는 연속된 두 달을 찾습니다.
  const auto sameLetter{ std::adjacent_find(months.begin(), months.end(),
                                      [](const auto& a, const auto& b) {
                                        return a[0] == b[0];
                                      }) };

  // 두 달을 무사히 찾았는지 확인합니다.
  if (sameLetter != months.end())
  {
    // std::next는 sameLetter 바로 다음 요소를 가리킵니다.
    std::cout << *sameLetter << " and " << *std::next(sameLetter)
              << " start with the same letter\n";
  }

  return 0;
}

결과는 다음과 같습니다.

June and July start with the same letter

이 예제에서는 auto 매개변수를 사용해 문자열을 전달받았습니다. 어떤 종류의 문자열이든 대괄호([])를 사용해 첫 번째 글자를 가져올 수 있기 때문에, 사용자가 넘겨준 값이 std::string이든 그냥 옛날 방식의 문자열이든 신경 쓸 필요가 없습니다. 덕분에 나중에 months 배열의 데이터 타입을 바꾸더라도 람다 코드는 하나도 고칠 필요가 없습니다.

하지만 auto가 항상 최고의 선택인 것은 아닙니다. 다음 예제를 보세요.

#include <algorithm>
#include <array>
#include <iostream>
#include <string_view>

int main()
{
  constexpr std::array months{ // C++17 이전에는 std::array<const char*, 12> 라고 써야 합니다.
    "January",
    "February",
    "March",
    "April",
    "May",
    "June",
    "July",
    "August",
    "September",
    "October",
    "November",
    "December"
  };

  // 알파벳 5글자로 된 달이 몇 개인지 셉니다.
  const auto fiveLetterMonths{ std::count_if(months.begin(), months.end(),
                                       [](std::string_view str) {
                                         return str.length() == 5;
                                       }) };

  std::cout << "There are " << fiveLetterMonths << " months with 5 letters\n";

  return 0;
}

결과는 다음과 같습니다.

There are 2 months with 5 letters

이 예제에서 만약 auto를 썼다면 컴파일러는 데이터 타입을 다루기 까다로운 const char*(옛날 C언어 방식 문자열)로 추론했을 것입니다. 길이를 재려면 복잡해지죠. 그래서 여기서는 명시적으로 std::string_view 타입이라고 딱 정해주는 것이 좋습니다. 그러면 사용자가 C언어 방식 문자열을 넘겨주더라도 길이를 쉽게 구할 수(str.length()) 있기 때문입니다.

Constexpr 람다

C++17부터 람다가 만들어내는 결과가 상수 표현식(항상 변하지 않는 고정된 값)의 조건을 만족하면 암묵적으로 컴파일 시간에 계산되는 constexpr로 취급됩니다. 보통 다음 두 가지 조건을 만족해야 합니다.

1. 람다에 캡처가 아예 없거나, 캡처하는 모든 것이 constexpr이어야 합니다.
2. 람다 안에서 호출하는 함수들도 모두 constexpr이어야 합니다. 참고로 표준 라이브러리의 많은 알고리즘과 수학 함수들은 C++20이나 C++23이 되어서야 constexpr로 만들어졌습니다.

위의 '5글자 달 세기' 예제는 C++17에서는 constexpr이 될 수 없지만, std::count_if 함수가 constexpr로 개선된 C++20부터는 가능해집니다. 즉, C++20부터는 다음과 같이 결과를 컴파일 시간에 미리 계산해둘 수 있습니다.

constexpr auto fiveLetterMonths{ std::count_if(months.begin(), months.end(),
                                     [](std::string_view str) {
                                       return str.length() == 5;
                                     }) };

제네릭 람다와 정적(static) 변수

11.7 레슨에서 함수 템플릿 안에 정적(static) 변수가 있으면, 템플릿에서 만들어지는 각각의 함수마다 자기만의 고유한 정적 변수를 따로 가지게 된다고 배웠습니다. 제네릭 람다 안의 auto 매개변수도 원리가 똑같기 때문에 같은 일이 벌어집니다. 넘겨받는 데이터 타입이 달라질 때마다 완전히 새로운 람다가 하나씩 복제되어 만들어집니다.

아래 예제를 보면 하나의 제네릭 람다가 어떻게 두 개의 독립적인 람다로 나뉘는지 확인할 수 있습니다.

#include <algorithm>
#include <array>
#include <iostream>
#include <string_view>

int main()
{
  // 값을 출력하고, 이 람다가 지금까지 몇 번 호출되었는지 횟수를 셉니다.
  auto print{
    [](auto value) {
      static int callCount{ 0 };
      std::cout << callCount++ << ": " << value << '\n';
    }
  };

  print("hello"); // 0: hello
  print("world"); // 1: world

  print(1); // 0: 1
  print(2); // 1: 2

  print("ding dong"); // 2: ding dong

  return 0;
}

결과는 다음과 같습니다.

0: hello
1: world
0: 1
1: 2
2: ding dong

문자열("hello", "world" 등)을 넘겨줬을 때와 숫자(1, 2)를 넘겨줬을 때 각각 다른 버전의 람다가 만들어집니다. 대부분의 경우에는 별문제가 없지만, 람다 안에 static 변수가 있다면 이야기가 달라집니다. 문자열 전용 람다와 숫자 전용 람다가 각자의 callCount 변수를 따로 관리하게 되는 것이죠! 출력 결과를 보면 문자열을 넣었을 때와 숫자를 넣었을 때 숫자가 따로 올라가는 것을 볼 수 있습니다.

모든 람다가 하나의 변수(callCount)를 같이 공유하게 만들려면 람다 바깥에 전역 변수나 정적 지역 변수를 만들어야 합니다. 하지만 이전 레슨에서 배웠듯이 이런 변수들은 버그를 만들고 코드를 복잡하게 할 수 있습니다. 이 문제는 다음 레슨에서 '람다 캡처'를 배우면 깔끔하게 해결할 수 있습니다.

반환 타입 추론과 후행 반환 타입

람다에서 반환 타입을 생략해서 컴파일러에게 추론을 맡길 경우, 람다 안에 있는 return 문장들을 보고 타입을 결정합니다. 이때 람다 안의 모든 return 문장은 반드시 똑같은 데이터 타입을 반환해야 합니다 (그렇지 않으면 컴파일러가 도대체 어느 타입에 맞춰야 할지 몰라 혼란에 빠집니다).

예를 들어볼까요:

#include <iostream>

int main()
{
  auto divide{ [](int x, int y, bool intDivision) { // 참고: 반환 타입이 명시되지 않음
    if (intDivision)
      return x / y; // 반환 타입은 int (정수)
    else
      return static_cast<double>(x) / y; // 에러: 이전 반환 타입(int)과 일치하지 않음 (double)
  } };

  std::cout << divide(3, 2, true) << '\n';
  std::cout << divide(3, 2, false) << '\n';

  return 0;
}

이 코드는 에러가 납니다. 첫 번째 return은 정수(int)를 돌려주려고 하는데, 두 번째 return은 소수(double)를 돌려주려고 하기 때문입니다.

이렇게 상황에 따라 다른 타입을 반환하고 싶다면 두 가지 해결책이 있습니다.

1. 모든 return 값이 똑같은 타입이 되도록 직접 형태를 변환(캐스팅)해주거나,
2. 람다의 반환 타입을 명시적으로 딱 정해줘서 컴파일러가 알아서 알맞게 변환하도록 맡기는 것입니다.

보통은 두 번째 방법이 훨씬 깔끔하고 좋습니다.

#include <iostream>

int main()
{
  // 참고: -> double을 써서 반환 값이 double 타입임을 명확히 적어줍니다.
  auto divide{ [](int x, int y, bool intDivision) -> double {
    if (intDivision)
      return x / y; // 결과값(int)을 알아서 double로 변환해 줍니다.
    else
      return static_cast<double>(x) / y;
  } };

  std::cout << divide(3, 2, true) << '\n';
  std::cout << divide(3, 2, false) << '\n';

  return 0;
}

이렇게 명확하게 -> double이라고 적어두면, 나중에 반환 타입을 고치고 싶을 때 람다 내부의 복잡한 코드는 건드릴 필요 없이 저 -> double 부분만 수정하면 되어서 무척 편리합니다.

표준 라이브러리 함수 객체

덧셈, 음수 만들기, 대소 비교 같이 아주 뻔하고 자주 쓰는 기능들을 위해 매번 람다를 직접 만들 필요는 없습니다. C++ 표준 라이브러리인 <functional> 헤더에는 이미 만들어져 있는 유용한 함수 객체들이 아주 많습니다.

아래 예제를 보세요.

#include <algorithm>
#include <array>
#include <iostream>

bool greater(int a, int b)
{
  // a가 b보다 크면 a를 b보다 앞에 배치합니다.
  return a > b;
}

int main()
{
  std::array arr{ 13, 90, 99, 5, 40, 80 };

  // 정렬 함수인 std::sort에 greater 함수를 넘겨줍니다.
  std::sort(arr.begin(), arr.end(), greater);

  for (int i : arr)
  {
    std::cout << i << ' ';
  }

  std::cout << '\n';

  return 0;
}

결과는 다음과 같습니다.

99 90 80 40 13 5

이 코드를 위해 greater라는 함수를 람다로 일일이 바꾸는 것은 귀찮은 일입니다. 대신 이미 C++에 만들어져 있는 std::greater를 가져다 쓰면 아주 간단합니다.

#include <algorithm>
#include <array>
#include <iostream>
#include <functional> // std::greater를 사용하기 위해 포함합니다.

int main()
{
  std::array arr{ 13, 90, 99, 5, 40, 80 };

  // std::greater를 std::sort에 넘겨줍니다.
  std::sort(arr.begin(), arr.end(), std::greater{}); // 참고: 객체를 생성하기 위해 중괄호 {} 가 필요합니다.

  for (int i : arr)
  {
    std::cout << i << ' ';
  }

  std::cout << '\n';

  return 0;
}

결과는 다음과 같습니다.

99 90 80 40 13 5

결론

람다와 알고리즘 라이브러리를 함께 쓰는 것이 처음에는 for나 while 같은 일반적인 반복문(loop)을 쓰는 것보다 불필요하게 복잡해 보일 수 있습니다. 하지만 이 조합을 잘 활용하면 단 몇 줄의 코드만으로도 굉장히 강력한 기능을 만들 수 있고, 나중에는 오히려 반복문보다 읽기 훨씬 편해집니다.

무엇보다도, 알고리즘 라이브러리는 일반 반복문으로는 쉽게 하기 힘든 강력하고 편리한 병렬 처리(동시에 여러 작업 처리) 기능을 제공합니다. 일반 반복문으로 짠 코드를 업그레이드하는 것보다 라이브러리를 사용한 코드를 업그레이드하는 것이 훨씬 쉽고 안전합니다.

람다는 정말 훌륭한 기능이지만, 세상 모든 일반 함수를 람다로 교체해야 한다는 뜻은 아닙니다. 코드가 길고 복잡하거나 여러 곳에서 반복해서 재사용해야 하는 기능이라면 기존처럼 일반 함수를 만드는 것이 훨씬 좋습니다.

20.7 — 람다 캡처

캡처 절과 값으로 캡처하기

이전 레슨(20.6 -- 람다(익명 함수) 소개)에서 아래와 같은 예제를 다루었습니다.

#include <algorithm>
#include <array>
#include <iostream>
#include <string_view>

int main()
{
  std::array<std::string_view, 4> arr{ "apple", "banana", "walnut", "lemon" };

  auto found{ std::find_if(arr.begin(), arr.end(),
                           [](std::string_view str)
                           {
                             return str.find("nut") != std::string_view::npos;
                           }) };

  if (found == arr.end())
  {
    std::cout << "No nuts\n"; // 견과류 없음
  }
  else
  {
    std::cout << "Found " << *found << '\n'; // 찾음
  }

  return 0;
}

이제 이 "nut(견과류)" 찾기 예제를 조금 바꿔서, 사용자가 직접 검색할 단어를 입력하도록 만들어 보겠습니다. 생각보다 직관적으로 바로 동작하지는 않을 겁니다.

#include <algorithm>
#include <array>
#include <iostream>
#include <string_view>
#include <string>

int main()
{
  std::array<std::string_view, 4> arr{ "apple", "banana", "walnut", "lemon" };

  // 사용자에게 무엇을 검색할지 물어봅니다.
  std::cout << "search for: ";

  std::string search{};
  std::cin >> search;

  auto found{ std::find_if(arr.begin(), arr.end(), [](std::string_view str) {
    // "nut" 대신 @search 변수를 검색합니다.
    return str.find(search) != std::string_view::npos; // 에러: 이 범위에서는 search에 접근할 수 없습니다.
  }) };

  if (found == arr.end())
  {
    std::cout << "Not found\n"; // 찾지 못함
  }
  else
  {
    std::cout << "Found " << *found << '\n'; // 찾음
  }

  return 0;
}

이 코드는 컴파일(실행)되지 않습니다. 일반적인 중첩 블록 { } 안에서는 바깥에 있는 변수를 자유롭게 쓸 수 있지만, 람다는 다릅니다. 람다는 기본적으로 바깥에 있는 변수를 볼 수 없습니다. 예외적으로 아래와 같은 특별한 변수들만 볼 수 있죠.

• 프로그램이 끝날 때까지 살아있는 변수 (전역 변수나 static 변수 등)
• 컴파일할 때 값이 정해지는 상수 (constexpr 객체)

우리가 만든 search 변수는 위 조건에 해당하지 않기 때문에, 람다 안에서는 search가 무엇인지 전혀 알지 못합니다. 투명인간 취급을 하는 거죠.

팁 람다는 람다 외부에 정의된 특정 종류의 객체(예: 전역 변수, 정적 지역 변수 같은 정적 저장소 기간을 가진 객체나 constexpr 객체)에만 접근할 수 있습니다.

람다 안에서 search 변수를 사용하려면 캡처 절(capture clause) 이라는 것을 사용해야 합니다.

캡처 절

'캡처 절'은 람다가 원래는 볼 수 없는 바깥쪽 변수를 사용할 수 있게 (간접적으로) 허락해 주는 문법입니다. 방법은 아주 간단합니다. 람다의 대괄호 [] 안에 람다 안에서 쓰고 싶은 변수 이름을 적어주기만 하면 됩니다.

여기서는 search 변수의 값을 람다 안에서 쓰고 싶으니, 캡처 절에 search를 추가해 보겠습니다.

#include <algorithm>
#include <array>
#include <iostream>
#include <string_view>
#include <string>

int main()
{
  std::array<std::string_view, 4> arr{ "apple", "banana", "walnut", "lemon" };

  std::cout << "search for: ";

  std::string search{};
  std::cin >> search;

  // @search 변수를 캡처합니다                    vvvvvv
  auto found{ std::find_if(arr.begin(), arr.end(), [search](std::string_view str) {
    return str.find(search) != std::string_view::npos;
  }) };

  if (found == arr.end())
  {
    std::cout << "Not found\n"; // 찾지 못함
  }
  else
  {
    std::cout << "Found " << *found << '\n'; // 찾음
  }

  return 0;
}

이제 사용자가 입력한 단어로 배열 안의 요소를 성공적으로 검색할 수 있습니다!

출력 결과

search for: nana
Found banana

캡처는 실제로 어떻게 작동할까요?

위의 코드를 보면 람다가 main 함수 안에 있는 search 변수를 직접 가져다 쓰는 것처럼 보이지만, 사실은 그렇지 않습니다. 람다는 겉보기엔 그냥 괄호 블록처럼 생겼지만, 내부적으로는 조금 다르게 작동합니다(이 차이를 아는 것이 매우 중요합니다).

람다가 만들어질 때, 캡처 절에 적어둔 변수들은 람다 내부로 똑같은 이름으로 복제 됩니다. 마법처럼 원본 변수의 값을 그대로 복사해서 람다 전용 변수를 새로 하나 만드는 것입니다.

즉, 위 예제에서 람다 객체가 생성될 때, 람다는 자신만의 search라는 변수를 따로 갖게 됩니다. 이 복제된 search는 원본 search와 값만 똑같을 뿐, 완전히 다른 독립적인 변수입니다. 마치 원본을 만지는 것 같지만 실제로는 복사본을 만지고 있는 것이죠.

이렇게 이름은 같아도, 복제된 변수의 타입이 원본과 항상 똑같은 것은 아닙니다. 이에 대해서는 이어지는 내용에서 더 살펴보겠습니다.

핵심 통찰 람다가 캡처한 변수는 바깥쪽 변수의 진짜 '원본'이 아니라, 값만 똑같이 베껴온 '복사본' 입니다.

고급 학습자를 위한 내용 람다는 겉보기엔 함수 같지만, 실제로는 함수처럼 호출할 수 있는 객체(object) 입니다. (이를 함수 객체, 즉 '펑터(functor)'라고 부르며, 나중에 직접 만드는 법을 배울 것입니다.) 컴파일러가 람다를 발견하면, 람다를 위한 맞춤형 객체를 하나 몰래 만들어냅니다. 이때 캡처된 변수들은 이 객체의 '멤버 변수(데이터 멤버)'가 됩니다. 프로그램이 실행되다가 람다를 정의한 코드를 만나면 이 람다 객체가 생성(인스턴스화)되고, 그때 캡처된 변수들도 초기화됩니다.

캡처는 기본적으로 const(상수)로 취급됩니다

람다를 실행할 때 내부적으로 operator()라는 것이 호출됩니다. 그런데 기본적으로 람다는 자신이 캡처해 온 복사본들을 수정하지 못하도록 꽉 잠가버립니다(const 취급). 아래 예제에서 ammo(총알) 변수를 캡처한 뒤, 람다 안에서 총알 개수를 줄여보려고 시도해 보겠습니다.

#include <iostream>

int main()
{
  int ammo{ 10 }; // 총알 10발

  // 람다를 정의하고 "shoot(쏘다)"이라는 변수에 저장합니다.
  auto shoot{
    [ammo]() {
      // 에러 발생! ammo는 수정할 수 없습니다.
      --ammo;

      std::cout << "Pew! " << ammo << " shot(s) left.\n"; // 빵! 총알 ~발 남음.
    }
  };

  // 람다를 호출합니다.
  shoot();

  std::cout << ammo << " shot(s) left\n"; // 총알 ~발 남음.

  return 0;
}

이 코드는 컴파일되지 않습니다. 람다 안에서 ammo는 값을 바꿀 수 없는 const로 취급되기 때문입니다.

변경 가능한 캡처

만약 람다가 캡처한 복사본의 값을 꼭 수정해야 한다면, 람다에 mutable(변경 가능한)이라는 마법의 키워드를 붙여주면 됩니다.

#include <iostream>

int main()
{
  int ammo{ 10 }; // 총알 10발

  auto shoot{
    [ammo]() mutable { // 이제 변경이 가능합니다 (mutable 추가)
      // 이제 ammo를 수정할 수 있습니다.
      --ammo;

      std::cout << "Pew! " << ammo << " shot(s) left.\n";
    }
  };

  shoot(); // 빵!
  shoot(); // 빵!

  std::cout << ammo << " shot(s) left\n"; // 원본 총알 확인

  return 0;
}

출력 결과:

Pew! 9 shot(s) left.
Pew! 8 shot(s) left.
10 shot(s) left

이제 에러 없이 실행은 되지만, 논리적으로 이상한 점이 있습니다. 람다 안에서는 총알이 9발, 8발로 줄어들었는데, 마지막에 원본 총알을 확인해 보니 그대로 10발입니다! 왜 그럴까요? 앞서 설명했듯이 람다는 ammo의 복사본을 가져갔기 때문입니다. 람다는 원본이 아니라 자기 주머니에 있는 '복사본 총알'만 소비한 것입니다.

그리고 한 가지 더 신기한 점은, 람다를 여러 번 호출해도 람다 안의 ammo 복사본 값이 계속 유지된다는 점입니다 (9 -> 8로 줄어듦).

주의 사항 캡처된 변수들은 람다 객체 내부의 멤버 변수로 저장되기 때문에, 람다를 여러 번 호출해도 그 값이 사라지지 않고 계속 유지됩니다!

참조로 캡처하기

일반 함수에서 원본 데이터를 바꾸기 위해 '참조(reference)'를 사용하는 것처럼, 람다에서도 변수를 참조로 캡처하면 원본 변수를 직접 수정할 수 있습니다.

변수를 참조로 캡처하려면 캡처 절의 변수 이름 앞에 & 기호를 붙이면 됩니다. 복사본(값)으로 캡처할 때와 달리, 참조로 캡처한 변수는 원본 자체가 const가 아닌 이상 람다 안에서 자유롭게 수정할 수 있습니다. 무거운 데이터(문자열, 복잡한 객체 등)를 함수에 넘길 때 복사를 피하기 위해 참조를 쓰는 것처럼, 람다에서도 특별한 이유가 없다면 값으로 캡처하는 것보다 참조로 캡처하는 것을 권장합니다.

아래는 ammo를 참조로 캡처하도록 수정한 코드입니다.

#include <iostream>

int main()
{
  int ammo{ 10 };

  auto shoot{
    // 원본을 직접 만지므로 이제 mutable 키워드가 필요 없습니다.
    [&ammo]() { // &ammo는 ammo를 참조로 캡처한다는 뜻입니다.
      // 람다 안의 ammo를 바꾸면 main 함수의 원본 ammo도 바뀝니다.
      --ammo;

      std::cout << "Pew! " << ammo << " shot(s) left.\n";
    }
  };

  shoot();

  std::cout << ammo << " shot(s) left\n"; // 원본 총알 확인

  return 0;
}

이제 우리가 기대했던 대로 작동합니다!

Pew! 9 shot(s) left.
9 shot(s) left

이번에는 배열을 정렬할 때 std::sort가 비교를 몇 번이나 수행하는지 세어보는 예제에 참조 캡처를 활용해 보겠습니다.

#include <algorithm>
#include <array>
#include <iostream>
#include <string_view>

struct Car
{
  std::string_view make{};  // 제조사
  std::string_view model{}; // 모델명
};

int main()
{
  std::array<Car, 3> cars{ { { "Volkswagen", "Golf" },
                             { "Toyota", "Corolla" },
                             { "Honda", "Civic" } } };

  int comparisons{ 0 }; // 비교 횟수

  std::sort(cars.begin(), cars.end(),
    // @comparisons 변수를 참조로 캡처합니다.
    [&comparisons](const auto& a, const auto& b) {
      // 참조로 캡처했기 때문에 "mutable" 없이도 값을 수정할 수 있습니다.
      ++comparisons;

      // 자동차 제조사(make)를 기준으로 정렬합니다.
      return a.make < b.make;
  });

  std::cout << "Comparisons: " << comparisons << '\n';

  for (const auto& car : cars)
  {
    std::cout << car.make << ' ' << car.model << '\n';
  }

  return 0;
}

예상 출력 결과

Comparisons: 2
Honda Civic
Toyota Corolla
Volkswagen Golf

여러 변수 캡처하기

쉼표(,)를 사용하면 여러 개의 변수를 한 번에 캡처할 수 있습니다. 값으로 캡처하는 변수와 참조로 캡처하는 변수를 섞어서 쓰는 것도 얼마든지 가능합니다!

int health{ 33 };
int armor{ 100 };
std::vector<CEnemy> enemies{};

// health와 armor는 값으로(복사해서) 캡처하고, enemies는 참조로(원본을) 캡처합니다.
[health, armor, &enemies](){};

기본 캡처

람다 안에서 쓰는 변수가 많아지면, 캡처 절 [] 안에 일일이 변수 이름을 적어주는 것이 귀찮고 실수하기도 쉽습니다. 다행히 컴파일러에게 "내가 람다 안에서 쓰는 변수들은 알아서 다 캡처해 줘!"라고 부탁할 수 있는 기능이 있습니다.

이를 기본 캡처라고 부르며, 람다 안에서 언급된 변수들만 자동으로 캡처해 줍니다. (언급되지 않은 변수는 캡처하지 않습니다.)

• 사용된 모든 변수를 값(복사본) 으로 자동 캡처하려면 =를 씁니다. ([=])
• 사용된 모든 변수를 참조(원본) 로 자동 캡처하려면 &를 씁니다. ([&])

다음은 =를 사용해 기본 캡처를 하는 예제입니다.

#include <algorithm>
#include <array>
#include <iostream>

int main()
{
  std::array areas{ 100, 25, 121, 40, 56 };

  int width{};
  int height{};

  std::cout << "Enter width and height: ";
  std::cin >> width >> height;

  auto found{ std::find_if(areas.begin(), areas.end(),
                           [=](int knownArea) { // 람다 안에서 쓰인 width와 height를 자동으로 값으로 캡처합니다.
                             return width * height == knownArea; // 여기서 두 변수가 사용되었기 때문입니다.
                           }) };

  if (found == areas.end())
  {
    std::cout << "I don't know this area :(\n"; // 이 면적은 없네요 :(
  }
  else
  {
    std::cout << "Area found :)\n"; // 면적을 찾았습니다 :)
  }

  return 0;
}

기본 캡처 기능은 일반 캡처와 섞어서 쓸 수도 있습니다. 다만, 똑같은 변수를 두 번 캡처하려고 하면 에러가 납니다.

int health{ 33 };
int armor{ 100 };
std::vector<CEnemy> enemies{};

// health와 armor는 값으로, enemies는 참조로 캡처합니다.
[health, armor, &enemies](){};

// 기본적으로 모두 값(=)으로 캡처하되, enemies만 예외적으로 참조(&)로 캡처합니다.
[=, &enemies](){};

// 기본적으로 모두 참조(&)로 캡처하되, armor만 예외적으로 값으로 캡처합니다.
[&, armor](){};

// 에러: 이미 모든 것을 참조(&)로 캡처한다고 했는데, 또 참조(&armor)로 하겠다고 중복 선언했습니다.
[&, &armor](){};

// 에러: 이미 모든 것을 값(=)으로 캡처한다고 했는데, 또 값(armor)으로 하겠다고 중복 선언했습니다.
[=, armor](){};

// 에러: armor를 두 번 적었습니다.
[armor, &health, &armor](){};

// 에러: 기본 캡처 기호(& 나 =)는 무조건 맨 앞에 와야 합니다.
[armor, &](){};

람다 캡처 안에서 새로운 변수 정의하기

때로는 기존 변수를 살짝 가공해서 캡처하거나, 아예 람다 안에서만 쓸 새로운 변수를 만들고 싶을 때가 있습니다. 이럴 때는 캡처 절 안에서 데이터 타입 없이 변수를 직접 정의할 수 있습니다.

#include <array>
#include <iostream>
#include <algorithm>

int main()
{
  std::array areas{ 100, 25, 121, 40, 56 };

  int width{};
  int height{};

  std::cout << "Enter width and height: ";
  std::cin >> width >> height;

  // 배열에는 면적(area)이 저장되어 있지만, 사용자는 너비(width)와 높이(height)를 입력했습니다.
  // 따라서 검색을 하려면 먼저 너비와 높이를 곱해 면적을 계산해 두어야 합니다.
  auto found{ std::find_if(areas.begin(), areas.end(),
                           // 람다 안에서만 볼 수 있는 새로운 변수를 선언합니다.
                           // userArea의 타입은 자동으로 int로 결정(추론)됩니다.
                           [userArea{ width * height }](int knownArea) {
                             return userArea == knownArea;
                           }) };

  if (found == areas.end())
  {
    std::cout << "I don't know this area :(\n";
  }
  else
  {
    std::cout << "Area found :)\n";
  }

  return 0;
}

여기서 userArea라는 변수는 람다가 만들어질 때 단 한 번만 계산됩니다. 계산된 결과는 람다 객체 안에 잘 보관되어, 람다를 여러 번 호출해도 다시 계산할 필요 없이 똑같이 사용됩니다. 만약 람다가 mutable이고 캡처 절에서 만든 이 변수를 수정한다면, 수정된 값이 계속 덮어씌워져 유지됩니다.

권장 사항 캡처 절 안에서 변수를 초기화하는 것은 값이 짧고(단순하고) 타입이 명확할 때만 사용하세요. 코드가 길어지고 복잡해진다면, 람다 바깥에서 먼저 변수를 계산해 둔 다음 그걸 캡처하는 것이 더 좋습니다.

Dangling 캡처 변수

변수들은 람다가 만들어지는 바로 그 시점에 캡처됩니다. 만약 참조로 캡처한 변수가 람다보다 먼저 수명을 다해 파괴되어 버리면 어떻게 될까요? 람다는 허공을 가리키는, 이른바 '매달린 참조(Dangling reference)' 를 쥐고 있게 됩니다.

예를 살펴볼까요?

#include <iostream>
#include <string>

// 람다를 반환하는 함수
auto makeWalrus(const std::string& name)
{
  // name을 참조로 캡처한 람다를 만들어서 반환합니다.
  return [&]() {
    std::cout << "I am a walrus, my name is " << name << '\n'; // 정의되지 않은 동작(위험!)
  };
}

int main()
{
  // 이름이 Roofus인 새로운 바다코끼리를 만듭니다.
  // sayName은 makeWalrus 함수가 만들어준 람다를 담고 있습니다.
  auto sayName{ makeWalrus("Roofus") };

  // makeWalrus가 반환한 람다 함수를 호출해 봅니다.
  sayName();

  return 0;
}

이 코드에서 makeWalrus("Roofus")를 호출하면, 문자열 "Roofus"를 담은 임시 변수가 만들어집니다. 람다는 이 임시 변수를 '참조(원본 그대로)'로 캡처했습니다. 그런데 문제는 makeWalrus 함수의 실행이 끝나면 이 임시 변수는 메모리에서 완전히 파괴되어 사라진다는 겁니다! 하지만 우리의 sayName 람다는 여전히 그 파괴된 변수가 있던 자리를 기억하고 있습니다. 나중에 sayName()을 실행해서 그 자리에 접근하려고 하면, 이미 데이터가 날아간 쓰레기 메모리를 건드리게 되어 프로그램이 뻗거나 이상한 행동(정의되지 않은 동작)을 하게 됩니다.

만약 makeWalrus 함수가 name을 참조가 아니라 값(복사본)으로 받았더라도 똑같은 문제가 생깁니다. 함수가 끝나면 매개변수 name은 사라지기 때문입니다.

주의 사항 변수를 참조로 캡처할 때는 정말 조심해야 합니다! 특히 [&] 처럼 기본 참조 캡처를 무심코 쓸 때 위험합니다. 캡처 당하는 변수는 반드시 람다보다 오래 살아남아야 합니다.

만약 람다를 나중에 실행할 때도 name 변수를 안전하게 쓰고 싶다면, 참조가 아니라 값(복사본) 으로 캡처해야 합니다 (직접 [name]이라고 적거나 [=]를 사용). 그러면 람다가 자신만의 튼튼한 복사본을 가지게 되어 원본이 파괴되든 말든 신경 쓰지 않아도 됩니다.

변경 가능한 람다의 의도치 않은 복사

앞서 람다는 내부적으로 '객체(object)'라고 말씀드렸습니다. 객체라는 말은 곧 다른 곳으로 복사될 수 있다는 뜻입니다. 그리고 이 점이 가끔 골치 아픈 문제를 만듭니다.

#include <iostream>

int main()
{
  int i{ 0 };

  // count라는 이름의 람다를 만듭니다 (변경 가능)
  auto count{ [i]() mutable {
    std::cout << ++i << '\n';
  } };

  count(); // count 실행 (1 출력)

  auto otherCount{ count }; // count를 그대로 복사해서 otherCount를 만듭니다

  // 원본과 복사본을 각각 실행해 봅니다.
  count();
  otherCount();

  return 0;
}

출력 결과

1
2
2

1, 2, 3이 출력될 줄 알았는데 2가 두 번 출력되었습니다! 이유는 간단합니다. otherCount를 만들 때, 그 시점에서의 count 상태를 통째로 복사(도장 찍기)했기 때문입니다. 처음 count()를 한 번 실행해서 람다 안의 i가 1이 되었죠? 그래서 복사본인 otherCount도 똑같이 i=1인 상태를 물려받고 시작한 겁니다. 둘은 복사된 이후 각자의 길을 걷기 때문에 독립적인 i를 가지고 따로따로 1씩 증가시킨 것입니다.

이제 조금 더 알아차리기 힘든 예제를 볼까요?

#include <iostream>
#include <functional>

void myInvoke(const std::function<void()>& fn)
{
    fn();
}

int main()
{
    int i{ 0 };

    // 자신이 가진 복사본 @i를 증가시키고 출력하는 람다
    auto count{ [i]() mutable {
      std::cout << ++i << '\n';
    } };

    myInvoke(count);
    myInvoke(count);
    myInvoke(count);

    return 0;
}

출력 결과:

1
1
1

방금 전 예제와 똑같은 문제가 아주 은밀하게 숨어 있습니다. myInvoke(count)를 호출할 때, 컴파일러는 우리가 만든 '람다 타입'과 함수가 요구하는 std::function 타입이 다르다는 걸 눈치챕니다. 그래서 컴파일러가 알아서 람다를 std::function이라는 임시 박스에 포장(변환)해서 넘겨줍니다. 이 포장 과정에서 람다의 복사본이 만들어져 버립니다! 결국 1, 2, 3 누적 카운트는 count 원본에서 이루어지는 게 아니라, 호출할 때마다 새로 만들어지는 일회용 복사본에서만 이루어지기 때문에 계속 1만 출력되는 것입니다.

이런 끔찍한 복사 문제를 막고 싶다면 두 가지 방법이 있습니다. 첫째, 람다 안에서 복사본을 수정하는(mutable) 방식을 버리고, 차라리 클래스를 직접 만들거나 다른 구조를 사용하는 것입니다. (하지만 코드가 복잡해질 수 있습니다.) 둘째, 아예 처음부터 람다를 std::function 박스 안에 명시적으로 담아두는 것입니다. 그러면 함수로 넘길 때 추가적인 복사 포장 작업이 일어나지 않습니다.

#include <iostream>
#include <functional>

void myInvoke(const std::function<void()>& fn)
{
    fn();
}

int main()
{
    int i{ 0 };

    // 람다 객체를 생성하자마자 바로 std::function에 담아둡니다.
    std::function count{ [i]() mutable { 
      std::cout << ++i << '\n';
    } };

    myInvoke(count); // 이제 포장된 채로 넘어가므로 복사본이 생기지 않습니다!
    myInvoke(count); // 복사 생기지 않음
    myInvoke(count); // 복사 생기지 않음

    return 0;
}

이제 원하던 출력 결과가 나옵니다:

1
2
3

또 다른 멋진 해결책으로는 참조 래퍼(reference wrapper) 를 사용하는 방법이 있습니다. C++의 <functional> 헤더에는 일반 객체를 마치 참조(reference)인 것처럼 속여서 전달하게 해주는 std::reference_wrapper라는 유용한 도구가 있습니다. std::ref() 함수를 쓰면 람다를 아주 쉽게 참조 형태로 감쌀 수 있죠. 이렇게 람다를 한 겹 감싸주면, 누군가 람다를 복사하려고 할 때 람다 원본이 복사되는 게 아니라 껍데기(참조)만 복사되므로, 안전하게 원본 하나만 유지할 수 있습니다.

std::ref를 활용해 수정한 코드를 보겠습니다.

#include <iostream>
#include <functional> // std::reference_wrapper와 std::ref를 사용하기 위한 헤더

void myInvoke(const std::function<void()>& fn)
{
    fn();
}

int main()
{
    int i{ 0 };

    // 자신이 가진 복사본 @i를 증가시키고 출력하는 람다
    auto count{ [i]() mutable {
      std::cout << ++i << '\n';
    } };

    // std::ref(count)는 count가 참조처럼 취급되도록 보장해 줍니다.
    // 누군가 count를 복사하려고 하면 실제로는 '참조'만 복사되기 때문에, 
    // 결과적으로 실제 count 객체는 세상에 단 하나만 존재하게 됩니다.
    myInvoke(std::ref(count));
    myInvoke(std::ref(count));
    myInvoke(std::ref(count));

    return 0;
}

이제 원하던 출력 결과가 나옵니다:

1
2
3

이 방식이 정말 강력한 이유는, myInvoke 함수가 매개변수를 참조(&)가 아니라 값으로(복사해서) 받도록 설계되어 있어도 정상적으로 1, 2, 3을 카운트한다는 점입니다!

규칙 C++ 표준 라이브러리 함수들은 종종 함수 객체(람다 포함)를 내부적으로 복사합니다. 만약 여러분이 캡처된 변수를 수정하는 mutable 람다를 라이브러리 함수에 넘겨줘야 한다면, 복사 방지를 위해 std::ref를 사용해서 넘겨주는 것이 좋습니다.

권장 사항 가장 좋은 방법은 애초에 mutable 람다를 최대한 쓰지 않는 것입니다. 데이터를 내부에서 수정하지 않는 람다가 읽기도 훨씬 쉽고, 위와 같은 골치 아픈 복사 버그나 나중에 병렬 처리(멀티 스레드)를 할 때 생기는 무서운 에러들을 피할 수 있습니다.

20.x — 20장 요약 및 퀴즈

챕터 복습

또 하나의 챕터를 무사히 마쳤네요!

함수에 데이터(인수)를 넘겨줄 때는 값(value), 참조(reference), 주소(address) 이렇게 세 가지 방법을 쓸 수 있습니다. 상황에 맞게 골라 쓰는 것이 아주 중요해요!

• 값으로 전달 (Pass by value): 기본 데이터 타입(int, double 등)이나 열거형을 넘길 때 씁니다. 원본은 놔두고 '복사본'만 함수에 던져주는 안전하고 단순한 방법입니다.
• 참조로 전달 (Pass by reference): 구조체나 클래스처럼 덩치가 큰 데이터이거나, 함수 안에서 원본 데이터를 직접 수정해야 할 때 씁니다. 원본을 직접 연결해 주므로 복사하는 수고를 덜어줍니다.
• 주소로 전달 (Pass by address): 포인터나 C 스타일의 기본 배열을 넘길 때 씁니다.
• 팁: 참조나 주소로 데이터를 넘길 때, 함수 안에서 원본이 멋대로 바뀌면 안 된다면 가급적 const를 붙여서 안전하게 보호해 주세요.

함수가 결과값을 돌려줄 때(반환)도 마찬가지로 값, 참조, 주소 세 가지 방식을 쓸 수 있습니다.

• 대부분의 경우에는 그냥 '값으로 반환'하는 것으로 충분합니다.
• 하지만 동적으로 할당된 데이터(필요할 때 메모리를 빌려 쓴 데이터), 구조체, 클래스처럼 무거운 데이터를 다룰 때는 '참조나 주소로 반환'하는 것이 아주 효율적이고 유용합니다.
• 주의할 점: 참조나 주소로 결과값을 돌려줄 때는, 함수가 끝나면 메모리에서 사라져 버릴 데이터(지역 변수 등)를 가리키고 있지는 않은지 반드시 확인해야 합니다. 사라진 데이터를 가리키면 프로그램이 뻗을 수 있거든요!

함수 포인터를 사용하면 함수 자체를 다른 함수에 데이터처럼 넘겨줄 수 있습니다. 이 기능은 리스트를 정렬하는 방식처럼, 함수를 호출하는 쪽에서 함수의 세부적인 동작을 입맛대로 바꾸고 싶을 때(커스터마이징) 아주 유용합니다.

프로그램이 실행되는 도중에 필요한 만큼 메모리를 빌려 쓰는 동적 메모리는 '힙(Heap)'이라는 특별한 메모리 공간에 만들어집니다.

콜 스택(Call stack)은 프로그램이 시작된 후부터 지금까지 실행 중인 모든 함수들(호출되었지만 아직 끝나지 않은 함수들)의 목록을 차곡차곡 기록해 두는 곳입니다. 우리가 함수 안에서 만드는 일반적인 변수(지역 변수)들은 이 '스택(Stack)'이라는 공간에 만들어져요. 단, 스택은 크기가 제한되어 있어서 너무 많이 쓰면 넘쳐버릴 수 있습니다. (스택처럼 동작하는 구조를 직접 만들고 싶다면 std::vector를 활용하면 좋습니다!)

재귀 함수(Recursive function)는 자기 자신을 다시 부르는 신기한 함수입니다. 끝없이 자기 자신을 부르다 프로그램이 멈추지 않도록, 모든 재귀 함수에는 반드시 "여기까지만 하고 끝내!"라는 종료 조건(termination condition)이 있어야 합니다.

명령줄 인수(Command line arguments)를 사용하면, 프로그램을 처음 켤 때 사용자나 다른 프로그램이 우리 프로그램에 초기 데이터를 쏙 넣어줄 수 있습니다. 단, 이렇게 들어오는 데이터는 무조건 텍스트(C 스타일 문자열) 형태이기 때문에, 만약 숫자로 쓰고 싶다면 우리가 직접 숫자로 바꿔주어야(변환해야) 합니다.

생략 부호(Ellipsis, ...)를 사용하면 함수에 넘겨주는 데이터(인수)의 개수를 그때그때 다르게(가변적으로) 할 수 있습니다. 하지만 이 방법을 쓰면 컴파일러가 "이 데이터 타입이 맞나?" 하고 검사하는 기능을 꺼버리고, 데이터가 몇 개나 들어왔는지도 알 수 없게 됩니다. 그래서 이 세부 사항들을 관리하는 건 전적으로 프로그래머의 몫이 되니 주의해서 써야 합니다.

람다 함수(Lambda functions)는 다른 함수 안에 쏙 집어넣을 수 있는 함수입니다. 이름이 없어도(익명) 쓸 수 있고, C++의 알고리즘 라이브러리(데이터를 쉽게 다루는 도구들)와 함께 쓸 때 정말 무궁무진하게 활용할 수 있답니다!

동적 메모리 할당이 필요한 이유

C++에는 메모리(데이터를 저장하는 공간)를 빌리는 세 가지 기본적인 방법이 있습니다. 여러분은 이미 그중 두 가지를 경험해 보셨을 거예요.

1. 정적(Static) 메모리 할당: 프로그램이 켜질 때 딱 한 번 메모리를 빌리고, 프로그램이 끝날 때까지 계속 그 자리를 차지하는 방식입니다. (전역 변수 등이 여기에 속해요.)
2. 자동(Automatic) 메모리 할당: 함수 안으로 들어갈 때 메모리를 빌리고, 함수가 끝날 때 자동으로 메모리를 반납하는 방식입니다. 필요할 때마다 자동으로 이루어지죠. (우리가 평소에 쓰는 일반적인 지역 변수들이 속합니다.)
3. 동적(Dynamic) 메모리 할당: 바로 이 글에서 우리가 배울 주인공입니다!

정적 할당과 자동 할당에는 두 가지 큰 공통점(이자 단점)이 있습니다.

• 변수나 배열의 '크기'를 코드를 짤 때(컴파일할 때) 미리 정확히 알고 있어야 합니다.
• 메모리를 빌리고 반납하는 과정이 자동으로 알아서 처리됩니다.

보통은 이 두 가지 특징이 전혀 문제 되지 않습니다. 하지만 외부 요인 (사용자의 입력이나 파일 읽기 등)을 다룰 때는, 이 제약 때문에 곤란한 상황이 발생하곤 해요.

예를 들어볼까요? 누군가의 이름을 저장하고 싶은데, 사용자가 이름을 입력하기 전까지는 그 이름이 몇 글자인지 알 수가 없죠. 또는 컴퓨터 디스크에서 기록을 불러오고 싶은데, 기록이 몇 개나 있는지 미리 알 수 없는 경우도 있습니다. 게임을 만들 때도 몬스터가 죽고 새로 태어나면서 몬스터의 수가 계속 변하는데, 몇 마리인지 딱 정해놓을 수가 없잖아요?

만약 코드를 짤 때 모든 크기를 미리 정해둬야만 한다면, 우리가 할 수 있는 최선은 그저 "이 정도면 충분하겠지?" 하고 최댓값을 어림짐작해서 찍는 것뿐입니다.

char name[25]; // 이름이 25자 미만이길 바래야죠!
Record record[500]; // 기록이 500개 미만이길!
Monster monster[40]; // 몬스터는 최대 40마리
Polygon rendering[30000]; // 이 3D 렌더링 폴리곤이 3만 개를 넘지 않기를!

하지만 이런 식의 '찍기'는 적어도 4가지 이유에서 아주 안 좋은 해결책입니다.

1. 메모리 낭비: 할당해 둔 메모리를 다 쓰지 않으면 아까운 공간을 낭비하게 됩니다. 모든 이름을 25글자로 맞춰 놨는데 실제 평균 이름이 12글자라면, 절반 이상의 메모리를 그냥 버리는 셈이죠.
2. 사용 중인 공간 확인의 어려움: 어디까지가 진짜 데이터고 어디부터가 빈 공간인지 알기 어렵습니다. 문자열은 끝에 \0이 있어서 구분하기 쉽지만, monster[24] 같은 경우는 어떨까요? 이 몬스터가 살아있는지, 죽었는지, 아예 처음부터 존재하긴 했는지 알려면 상태를 체크하는 복잡한 코드가 추가로 필요해집니다.
3. 비좁은 공간 (스택 오버플로우): 일반적인 변수나 고정된 배열은 스택(Stack)이라는 메모리 공간에 저장됩니다. 문제는 이 스택이라는 공간이 보통 아주 작다는 거예요. (Visual Studio의 경우 기본적으로 딱 1MB만 줍니다.) 이 용량을 넘치게 쓰면 '스택 오버플로우(Stack overflow)'라는 에러가 터지면서 프로그램이 강제로 꺼져버립니다.

Visual Studio에서 아래 코드를 실행해 보면 바로 프로그램이 뻗는 걸 볼 수 있습니다.

int main() {
    int array[1000000]; // 정수 100만 개 할당 (약 4MB 메모리 차지)
}

4. 가장 큰 문제, 억지스러운 제한과 에러: 공간을 미리 정해두면 프로그램이 유연하지 못하게 됩니다. 디스크에서 600개의 기록을 불러와야 하는데 우리가 500개짜리 공간만 만들어 뒀다면 어떻게 될까요? 사용자에게 에러를 띄우거나, 500개만 간신히 읽거나, 최악의 경우엔 공간이 터져버리면서(배열 오버플로우) 끔찍한 오류를 보게 될 것입니다.

다행히도, 이 모든 골칫거리는 동적 메모리 할당을 통해 아주 쉽게 해결할 수 있습니다! 동적 메모리 할당이란 프로그램이 실행되는 도중에 "운영 체제야, 나 지금 메모리가 좀 필요한데 빌려줄래?" 하고 요청하는 방법입니다. 이 메모리는 비좁은 스택(Stack)이 아니라, 운영 체제가 넉넉하게 관리하는 힙(Heap)이라는 아주 거대한 메모리 창고에서 가져오게 됩니다. 요즘 컴퓨터에서 힙의 크기는 무려 기가바이트(GB) 단위랍니다!

단일 변수 동적으로 할당하기

변수 한 개를 동적으로 할당하려면(빌리려면), 배열이 아닌 일반 형태의 new 연산자를 사용하면 됩니다.

new int; // 정수용 메모리를 동적으로 할당 (그리고 결과는 버림)

위 코드는 운영 체제에게 정수(int) 하나를 담을 만큼의 메모리를 달라고 요청하는 것입니다. new 연산자는 그 메모리를 사용해서 공간을 만든 다음, 그 공간이 어디에 있는지 알려주는 '주소(포인터)'를 반환합니다.

보통은 이 반환된 주소를 잃어버리지 않게 포인터 변수에 잘 저장해 둡니다. 그래야 나중에 그 공간을 찾아갈 수 있거든요.

int* ptr{ new int }; // 정수 메모리를 동적으로 할당하고, 나중에 접근할 수 있게 그 주소를 ptr에 저장

이제 포인터가 가리키는 곳으로 찾아가서(역참조) 메모리를 사용할 수 있습니다.

*ptr = 7; // 할당받은 메모리에 7이라는 값을 저장

만약 지금까지 포인터를 왜 쓰는지 헷갈리셨다면, 이제 확실히 아시겠죠? 방금 빌린 넉넉한 메모리의 '주소'를 기억해둘 포인터가 없다면, 우리는 그 메모리를 두 번 다시 찾아가서 사용할 방법이 없기 때문입니다!

다만 주의할 점이 있어요. 힙(Heap)에 있는 데이터는 스택(Stack)에 있는 데이터보다 접근하는 속도가 살짝 느립니다. 스택에 있는 데이터는 컴파일러가 위치를 정확히 알고 있어서 바로 찾아가지만, 힙에 있는 데이터는 포인터라는 지도(주소)를 한 번 읽고, 그 주소로 다시 찾아가야 하는 두 번의 단계를 거쳐야 하기 때문이죠.

동적 메모리 할당은 어떻게 작동할까요?

여러분의 컴퓨터에는 프로그램들이 쓸 수 있는 넉넉한 메모리가 있습니다. 프로그램을 실행하면 운영 체제가 이 메모리의 일부에 프로그램을 올려놓죠. 프로그램이 쓰는 메모리는 구역별로 역할이 나뉘어 있습니다. 어떤 곳은 코드가 들어가고, 어떤 곳은 함수나 지역 변수(스택)를 다루는 데 쓰입니다.

하지만 남아도는 엄청나게 많은 메모리는 누군가 "나 좀 쓸게!"라고 요청할 때까지 가만히 대기하고 있습니다. 여러분이 동적으로 메모리를 할당(new)한다는 것은, 운영 체제에게 "이 남는 메모리 중 일부를 내 프로그램 전용으로 예약해 줘"라고 부탁하는 것과 같습니다. 운영 체제가 수락하면, 그 메모리의 주소를 넘겨주죠. 이때부터 그 공간은 여러분 마음대로 쓸 수 있습니다. 그리고 다 쓰고 나면, 다른 프로그램이 쓸 수 있게 다시 운영 체제에 꼭 돌려줘야 합니다.

자동으로 정리되는 일반 메모리(스택)와 달리, 동적으로 빌린 메모리(힙)는 프로그램이 스스로 직접 요청하고 직접 반납해야 할 책임이 있습니다.

핵심 통찰 스택(Stack) 객체를 만들고 없애는 건 전부 자동으로 처리됩니다. 우리가 메모리 주소 같은 걸 신경 쓸 필요가 전혀 없죠. 하지만 힙(Heap) 객체는 자동으로 관리되지 않습니다. 우리가 직접 개입해야 해요! 다 썼을 때 정확히 어떤 객체를 부숴야 하는지 알기 위해, 우리는 그 객체를 가리키는 고유한 '메모리 주소'가 필요합니다. new 연산자를 사용하면 새로 만든 객체의 주소가 담긴 포인터가 튀어나옵니다. 우리는 이 주소를 잘 저장해 뒀다가, 나중에 데이터를 읽거나 다 쓰고 버려달라고(파괴해 달라고) 요청할 때 써먹어야 합니다.

동적으로 할당된 변수 초기화하기

동적으로 변수를 만들 때, 값을 텅 비워두지 않고 곧바로 원하는 값을 넣어서(초기화해서) 만들 수도 있습니다.

int* ptr1{ new int (5) }; // 직접 초기화(direct initialization) 사용
int* ptr2{ new int { 6 } }; // 유니폼 초기화(uniform initialization) 사용

단일 변수 삭제(반환)하기

동적으로 빌린 메모리를 다 썼다면, C++에게 "이 메모리 이제 다시 가져가도 돼!"라고 명확하게 말해줘야 합니다. 변수 하나를 반납할 때는 delete 연산자를 사용합니다.

// ptr이 이전에 new 연산자로 할당되었다고 가정합니다
delete ptr; // ptr이 가리키는 메모리를 운영 체제에 반환합니다
ptr = nullptr; // ptr을 빈 포인터(null pointer)로 설정합니다

메모리를 삭제한다는 것은 무슨 의미일까요?

delete라는 단어 때문에 무언가를 완전히 '삭제'해버린다고 오해하기 쉽지만, 사실 이 연산자는 아무것도 지우지 않습니다! 그저 우리가 빌려 썼던 방을 운영 체제에게 다시 "반납"할 뿐입니다. 그러면 운영 체제는 빈 방이 된 그 공간을 다른 프로그램이나 나중에 다시 쓸 수 있게 준비해 둡니다.

문법만 보면 마치 ptr이라는 변수 자체를 지우는 것처럼 보이지만, 절대 그렇지 않아요! 포인터 변수 ptr 자체는 여전히 살아서 존재하며, 다른 변수들처럼 새로운 값(예: nullptr)을 다시 넣어줄 수도 있습니다.

동적으로 할당받지 않은 엉뚱한 포인터에 대고 delete를 하면 프로그램에 아주 심각한 문제가 생길 수 있으니 꼭 주의하세요.

댕글링 포인터 (허공을 맴도는 포인터)

메모리를 반납(delete)하고 나면, C++는 반납된 메모리 안에 있던 데이터나 포인터의 값이 어떻게 될지 아무것도 보장해주지 않습니다. 대부분의 경우 운영 체제에 반납된 공간에는 원래 있던 숫자들이 그대로 남아있게 되고, 우리의 포인터 변수 역시 방금 반납해서 더 이상 우리 것이 아닌 그 메모리 주소를 여전히 가리킨 채로 남아있게 됩니다.

이렇게 더 이상 내 것이 아닌, 이미 반납된 메모리를 가리키고 있는 포인터를 댕글링 포인터(Dangling pointer)라고 부릅니다. (마치 끊어진 밧줄에 대롱대롱 매달려 있다는 뜻이죠!) 이 댕글링 포인터의 값을 읽으려 하거나 또 delete 하려고 하면, 프로그램이 어떻게 미쳐 날뛸지 모르는 '알 수 없는 행동(undefined behavior)'이 발생합니다.

#include <iostream>

int main() {
    int* ptr{ new int }; // 정수를 동적으로 할당
    *ptr = 7; // 해당 메모리 위치에 값을 넣음

    delete ptr; // 메모리를 운영 체제에 반환. 이제 ptr은 허공을 가리키는 '댕글링 포인터'가 됨.

    std::cout << *ptr; // 댕글링 포인터에 접근하면 알 수 없는 행동(undefined behavior) 발생
    delete ptr; // 이미 반환한 메모리를 또 반환하려고 해도 알 수 없는 행동 발생.

    return 0;
}

위 프로그램에서, 우리가 아까 넣었던 7이라는 숫자는 운 좋게 그대로 남아있을 수도 있지만, 다른 숫자로 바뀌어 버렸을 수도 있습니다. 더 무서운 점은, 그 메모리 공간이 이미 다른 프로그램의 차지가 되어버렸을 수도 있다는 거예요. 그런 남의 땅을 함부로 건드리려고 하면 운영 체제가 화를 내며 우리 프로그램을 강제로 종료시켜 버릴 겁니다.

메모리를 반납할 때 댕글링 포인터가 여러 개 생겨버릴 수도 있습니다. 다음 코드를 볼까요?

#include <iostream>

int main() {
    int* ptr{ new int{} }; // 정수를 동적으로 할당
    int* otherPtr{ ptr }; // otherPtr도 이제 같은 메모리 위치를 가리킴

    delete ptr; // 메모리를 운영 체제에 반환. ptr과 otherPtr 둘 다 댕글링 포인터가 됨.
    ptr = nullptr; // ptr은 이제 안전한 빈 포인터(nullptr)가 됨

    // 하지만, otherPtr은 여전히 위험한 댕글링 포인터로 남아있음!

    return 0;
}

이런 골치 아픈 일을 막기 위한 꿀팁들이 있습니다. 첫째, 여러 개의 포인터가 똑같은 동적 메모리 하나를 가리키게 만드는 일은 웬만하면 피하세요. 어쩔 수 없다면, 정확히 어떤 포인터가 이 메모리의 '진짜 주인(삭제할 책임이 있는 녀석)'인지, 그리고 어떤 포인터가 그냥 놀러 온 '손님(접근만 하는 녀석)'인지 명확히 구분해야 합니다. 둘째, delete로 포인터를 지웠다면, 그 포인터가 곧바로 사라질 상황이 아니라면 무조건 nullptr로 설정해서 비워두세요.

권장 사항 포인터를 delete 한 직후에 포인터 자체가 수명을 다해 사라지는 게 아니라면, 무조건 nullptr (빈 포인터)로 설정하세요.

new 연산자도 실패할 수 있어요

드문 일이긴 하지만, 운영 체제한테 메모리를 달라고 부탁했을 때 운영 체제가 "미안, 남은 공간이 없어!" 하고 거절할 수도 있습니다.

기본적으로 new가 실패하면 bad_alloc이라는 '예외(Exception)'가 터집니다. 아직 우리는 예외 처리 방법을 배우지 않았기 때문에, 이런 일이 생기면 프로그램은 그냥 픽 쓰러져서(크래시) 꺼져버릴 겁니다.

프로그램이 이렇게 픽픽 꺼지는 건 보통 원하지 않으실 테니, new가 실패했을 때 프로그램을 끄지 말고 조용히 '빈 포인터(null pointer)'를 반환하게 만드는 방법이 있습니다. new와 타입 사이에 (std::nothrow)라는 마법의 주문을 넣으면 됩니다.

int* value { new (std::nothrow) int }; // 정수 할당에 실패하면 value는 빈 포인터(null pointer)가 됨

만약 공간을 빌리는 데 실패하면, 주소 대신 null(아무것도 없음)이 들어옵니다. 주의할 점은, 실패해서 텅 비어버린 포인터를 억지로 읽으려고 하면 프로그램이 뻗어버린다는 것입니다. 그래서 가장 좋은 습관은 메모리를 달라고 요청한 뒤에 "진짜 제대로 빌렸나?" 하고 먼저 확인해 보는 것입니다.

int* value { new (std::nothrow) int{} }; // 정수 크기의 메모리를 요청
if (!value) // new가 null을 반환한 경우 (실패한 경우) 처리
{
    // 여기서 에러 처리를 합니다
    std::cerr << "메모리를 할당할 수 없습니다\n";
}

물론 최신 컴퓨터에선 메모리가 꽉 차서 실패하는 일이 거의 없기 때문에 (특히 연습할 때는 더더욱요), 이 확인 과정을 깜빡 잊기 아주 쉽답니다!

빈 포인터(Null pointer)와 동적 메모리 할당

빈 포인터(아무것도 가리키지 않는 nullptr)는 동적 메모리를 다룰 때 엄청나게 유용합니다. 동적 할당의 세계에서 빈 포인터는 사실상 "나 아직 메모리 공간 못 받았어"라는 뜻과 같습니다. 덕분에 이런 식의 스마트한 코드를 짤 수 있어요.

// ptr이 아직 할당되지 않았다면, 새로 할당합니다
if (!ptr)
    ptr = new int;

참고로 빈 포인터에 대고 delete를 하면 그냥 아무 일도 일어나지 않고 무사히 넘어갑니다. 따라서 굳이 아래처럼 복잡하게 쓸 필요가 없습니다.

if (ptr) // ptr이 빈 포인터가 아니라면
    delete ptr; // 삭제해라
// 그렇지 않으면 아무것도 하지 마라

그냥 쿨하게 한 줄만 쓰면 됩니다.

delete ptr;

ptr에 진짜 메모리가 들어있다면 깔끔하게 반납될 것이고, 비어있는(null) 상태라면 아무 일도 일어나지 않을 테니까요.

권장 사항 빈 포인터(null pointer)를 delete 하는 건 완벽하게 안전하며 아무 일도 일으키지 않습니다. 굳이 if 문을 써서 검사할 필요가 없습니다.

메모리 누수

동적으로 빌린 메모리는 우리가 명시적으로 "반납할게!"(delete)라고 하거나, 프로그램이 아예 끝날 때까지 끈질기게 자기 자리를 지킵니다. (물론 똑똑한 운영 체제가 끝나면 알아서 치워주긴 하지만요.) 하지만 이 메모리의 주소를 들고 있는 '포인터 변수' 자체는 일반 변수라서 함수가 끝나면 수명이 다해 사라져 버립니다. 여기서 아주 치명적인 엇박자가 발생합니다.

다음 함수를 한 번 보세요.

void doSomething() {
    int* ptr{ new int{} };
}

이 함수는 안에서 정수 하나를 동적으로 빌리지만, delete를 통해 반납하지는 않고 있습니다. 포인터 변수 ptr은 그저 평범한 지역 변수일 뿐이라서, 함수가 끝나는 순간 뿅 하고 사라집니다. 문제는 ptr만이 그 빌린 메모리의 주소를 알고 있는 유일한 변수였다는 점이죠. ptr이 사라지면서, 프로그램은 동적으로 빌린 메모리가 어디 있는지 알 수 있는 지도를 영영 잃어버리게 됩니다. 지도가 없으니 영원히 찾아가서 반납할(delete) 수가 없는 상태가 돼버리는 거죠.

이런 끔찍한 상황을 메모리 누수(Memory leak)라고 부릅니다. 운영 체제에 돌려주지도 않은 채로 메모리 주소를 까먹어 버린 상황이죠. 우리 프로그램은 지도를 잃어버려서 지울 수 없고, 운영 체제 입장에서는 "아직 쟤네 프로그램이 저 공간 쓰고 있네"라고 생각해서 다른 곳에 빌려주지도 못합니다. 그야말로 우주 미아가 되어버린 공간이죠.

이런 메모리 누수들이 자꾸 쌓이면 프로그램이 빈 메모리를 야금야금 다 갉아먹게 됩니다. 우리 프로그램뿐만 아니라 컴퓨터에 켜져 있는 다른 프로그램들까지 쓸 메모리가 부족해지죠. 누수가 심한 프로그램은 메모리를 싹 다 먹어 치워서 컴퓨터 전체를 렉 걸리게 만들거나 심지어 블루스크린을 띄울 수도 있습니다. 프로그램이 완전히 종료되고 나서야 운영 체제가 빗자루를 들고 와서 잃어버렸던 메모리들을 싹 청소하고 되찾아갑니다.

포인터 변수가 사라질 때만 메모리 누수가 생기는 건 아닙니다. 메모리 주소를 들고 있던 포인터에 덮어쓰기로 다른 값을 넣어버려도 똑같이 지도를 잃어버리게 됩니다.

int value = 5;
int* ptr{ new int{} }; // 메모리 할당
ptr = &value; // 기존에 할당받은 주소를 잃어버림. 메모리 누수 발생!

이럴 때는 새 주소를 넣기 전에 원래 갖고 있던 메모리를 확실하게 먼저 반납해주면 됩니다.

int value{ 5 };
int* ptr{ new int{} }; // 메모리 할당
delete ptr; // 메모리를 운영 체제에 다시 돌려줌
ptr = &value; // 포인터에 value의 주소를 새로 지정

비슷한 이유로, 같은 포인터에 메모리 할당을 두 번 연속으로 해도 메모리 누수가 발생합니다.

int* ptr{ new int{} };
ptr = new int{}; // 예전 주소를 잃어버림. 메모리 누수 발생!

두 번째로 빌려온 메모리의 주소가 첫 번째 주소를 덮어써 버리기 때문에, 처음 빌렸던 메모리의 주소는 영영 잃어버리게 됩니다! 이 역시 덮어쓰기 전에 꼭 먼저 delete를 해줘서 예방해야 합니다.

결론

• new와 delete 연산자를 사용하면 프로그램에 필요한 단일 변수를 동적으로 빌리고 반납할 수 있습니다.
• 동적으로 빌린 메모리는 여러분이 직접 반납하거나 프로그램이 끝날 때까지 계속 살아남습니다.
• 이미 반납해서 내 것이 아닌 곳을 가리키는 포인터(댕글링 포인터)나 텅 빈 포인터를 억지로 읽으려고 하면 큰일이 나니 항상 조심하세요.

다음 강의에서는 new와 delete를 사용해서 배열을 동적으로 만들고 지우는 방법에 대해 알아보겠습니다!

19.2 — 배열 동적 할당하기

변수 하나를 필요할 때 그때그때(동적으로) 만들 수 있는 것처럼, 여러 변수가 이어져 있는 '배열'도 필요할 때마다 동적으로 만들 수 있습니다.

일반적인 '고정 배열'은 프로그램을 만들기 전(컴파일 타임)에 미리 그 크기를 딱 정해두어야 하죠. 하지만 배열을 동적으로 할당하면, 프로그램이 실행 중인 상태(런타임)에서 우리가 원하는 만큼 배열의 길이를 마음대로 정할 수 있답니다! (즉, 배열의 길이가 항상 고정된 상수, 즉 constexpr일 필요가 없다는 뜻이에요.)

일반적인 '고정 배열'은 프로그램을 만들기 전(컴파일 타임)에 미리 그 크기를 딱 정해두어야 하죠. 하지만 배열을 동적으로 할당하면, 프로그램이 실행 중인 상태(런타임)에서 우리가 원하는 만큼 배열의 길이를 마음대로 정할 수 있답니다! (즉, 배열의 길이가 항상 고정된 상수, 즉 constexpr일 필요가 없다는 뜻이에요.)

저자의 노트 이번 강의에서는 가장 흔하게 쓰이는 방식인 'C언어 스타일의 배열'을 동적으로 할당해 볼 거예요. 참고로 최신 C++ 기능인 std::array를 동적으로 할당할 수도 있지만, 보통 이런 상황에서는 굳이 동적 할당을 직접 하기보다는 알아서 크기가 조절되는 std::vector를 사용하는 것이 훨씬 편하고 좋습니다.

배열을 동적으로 만들려면, 일반적인 방법 대신 new와 delete의 배열 전용 버전 (보통 new[] 와 delete[]라고 부름)을 사용해야 합니다.

#include <cstddef>
#include <iostream>

int main()
{
    std::cout << "Enter a positive integer: ";
    std::size_t length{};
    std::cin >> length;

    int* array{ new int[length]{} }; // 배열 전용 new를 사용합니다. 길이가 상수일 필요가 없다는 점에 주목하세요!

    std::cout << "I just allocated an array of integers of length " << length << '\n';

    array[0] = 5; // 0번째 요소를 값 5로 설정합니다.

    delete[] array; // 배열 전용 delete를 사용하여 배열 메모리를 해제합니다.

    // 어차피 이 코드 직후에 범위를 벗어나기 때문에(스코프 종료), 여기서 array를 nullptr이나 0으로 설정할 필요는 없습니다.

    return 0;
}

우리가 "배열을 만들어줘!"라고 대괄호([])를 사용해 명령했기 때문에, C++은 똑똑하게 일반 new 대신 배열용 new를 써야 한다는 걸 알아챕니다. 코드에서 new 글자 바로 옆에 []가 붙어있지는 않지만, 내부적으로는 new[] 기능이 작동하는 것이죠.

동적으로 만든 배열의 길이는 std::size_t라는 타입을 가집니다. 만약 일반 int 타입(상수가 아닌 것)을 길이로 사용하려고 하면, 컴퓨터가 "데이터가 손실될 수도 있어!"라며 경고를 보낼 수 있습니다. 이럴 때는 안전하게 static_cast를 써서 std::size_t로 타입을 바꿔주는 것이 좋습니다.

여기서 아주 중요한 사실이 있어요! 동적 배열은 일반 고정 배열과는 완전히 다른 넉넉한 공간에서 메모리를 빌려옵니다. 그래서 크기를 엄청나게 크게 만들 수 있죠. 위 프로그램을 직접 실행해서 배열 길이를 1,000,000(백만)이나 심지어 100,000,000(일억)으로 입력해도 문제없이 돌아갑니다. 한번 직접 해보세요!

이런 엄청난 장점 때문에, C++에서 메모리를 아주 많이 써야 하는 프로그램들은 대부분 이렇게 '동적 할당' 방식을 사용한답니다.

동적으로 할당된 배열 삭제하기

동적으로 빌려온 배열을 다 쓰고 나서 돌려줄(삭제할) 때는, 반드시 배열 전용 삭제 기호인 delete[]를 사용해야 합니다.

이것은 컴퓨터(CPU)에게 "변수 하나만 덜렁 지우는 게 아니라, 여러 개가 묶인 배열 전체를 싹 다 청소해야 해!"라고 알려주는 역할을 합니다. 초보 프로그래머들이 정말 자주 하는 치명적인 실수 중 하나가, 배열을 지울 때 delete[] 대신 그냥 delete를 써버리는 것입니다. 배열에 일반 delete를 쓰면 데이터가 꼬이거나, 메모리가 줄줄 새거나, 프로그램이 갑자기 튕기는 등 아주 끔찍한 일(정의되지 않은 동작)이 발생할 수 있습니다.

여기서 많은 분들이 궁금해하는 점이 있습니다. *"컴퓨터는 배열을 지울 때 도대체 얼마나 큰 메모리를 지워야 하는지 어떻게 아는 걸까요?"* 정답은, 처음에 new[]로 배열을 만들 때 컴퓨터가 몰래 '이 변수에 얼마나 큰 메모리를 빌려줬는지' 기록해두기 때문입니다. 그래서 나중에 delete[]를 부르면 알아서 딱 그만큼만 정확히 지워줍니다. 하지만 아쉽게도 프로그래머가 이 '숨겨진 길이 정보'를 코드에서 직접 꺼내 볼 수는 없습니다.

동적 배열은 고정 배열과 거의 똑같습니다

예전 '17.8 강의'에서 고정 배열은 '첫 번째 데이터가 있는 메모리 주소'를 들고 있다는 걸 배웠습니다. 또한, 배열이 첫 번째 데이터를 가리키는 '포인터'로 자연스럽게 변신(Decay)할 수 있다는 것도 배웠죠. 이렇게 포인터로 변해버리면 배열의 전체 길이나 크기(sizeof())를 알 수 없게 되지만, 그 외에는 작동 방식에 큰 차이가 없습니다.

동적 배열도 처음 태어날 때부터 아예 '첫 번째 데이터를 가리키는 포인터'로 시작합니다. 그래서 고정 배열이 포인터로 변했을 때처럼, 스스로 자기 길이가 얼마인지 모른다는 똑같은 단점을 가지고 있어요.

한마디로, 동적 배열은 포인터로 변신한 고정 배열과 기능적으로 완전히 똑같습니다. 단 하나, 프로그래머가 다 쓴 뒤에 직접 delete[]를 써서 청소해 줘야 한다는 책임감만 추가된 셈이죠!

동적으로 할당된 배열 초기화하기

동적으로 만든 배열의 모든 칸을 깔끔하게 0으로 채우고(초기화하고) 싶다면, 작성법은 아주 간단합니다. 끝에 빈 중괄호 {}만 붙여주면 돼요!

int* array{ new int[length]{} };

옛날 버전인 C++11 이전에는, 동적 배열에 0이 아닌 다른 숫자들을 한 번에 넣기가 무척 어려웠습니다. (여러 숫자를 한 번에 넣는 초기화 리스트는 고정 배열에서만 쓸 수 있었거든요.) 그래서 아래처럼 일일이 배열 칸을 하나씩 돌면서 값을 지정해 줘야만 했습니다.

int* array = new int[5];
array[0] = 9;
array[1] = 7;
array[2] = 5;
array[3] = 3;
array[4] = 1;

정말 귀찮고 번거로운 일이었죠! 하지만 C++11 버전부터는 드디어 동적 배열에도 중괄호 {}(초기화 리스트)를 써서 원하는 값들을 한방에 쏙쏙 넣을 수 있게 되었습니다!

int fixedArray[5] = { 9, 7, 5, 3, 1 }; // C++11 이전: 고정 배열 초기화 방식
int* array{ new int[5]{ 9, 7, 5, 3, 1 } }; // C++11 이후: 동적 배열 초기화 방식

// 똑같은 타입 이름(int)을 두 번씩 쓰기 귀찮다면 auto를 쓸 수도 있습니다. 이름이 긴 타입일 때 아주 유용해요.
auto* array{ new int[5]{ 9, 7, 5, 3, 1 } };

여기서 주의할 점은, 배열 길이([5])와 중괄호({...}) 사이에는 등호(=)가 들어가지 않는다는 것입니다.

코드를 헷갈리지 않고 일관성 있게 쓰기 위해, 일반 고정 배열을 만들 때도 위와 비슷한 중괄호 방식(균일 초기화)을 쓸 수 있습니다.

int fixedArray[]{ 9, 7, 5, 3, 1 }; // C++11에서 고정 배열 초기화하기
char fixedArray[]{ "Hello, world!" }; // C++11에서 고정 배열(문자열) 초기화하기

이때 대괄호 [] 안에 배열의 크기를 굳이 적어주지 않아도 컴퓨터가 알아서 세어주니 생략해도 괜찮습니다.

배열 크기 조절하기

동적 할당을 사용하면 처음에 배열을 만들 때 우리가 원하는 만큼 길이를 정할 수 있죠. 하지만 아쉽게도 C++에는 '이미 만들어진 배열의 크기'를 나중에 고무줄처럼 쭈욱 늘리거나 줄이는 기능이 기본적으로 없습니다. 만약 크기를 꼭 바꿔야 한다면 어떻게 해야 할까요?

1. 더 큰 새 배열을 새로 할당하고,
2. 옛날 배열에 있던 데이터를 하나씩 복사해서 옮긴 다음,
3. 옛날 배열을 지워버리는

이런 복잡한 꼼수를 써야 합니다. 하지만 이 과정은 실수하기 딱 좋고, 데이터가 복잡한 객체(클래스)일 경우에는 만들어지는 규칙이 까다로워서 예상치 못한 오류가 뻥뻥 터지기 쉽습니다.

결론적으로, 이렇게 복잡하게 배열 크기를 직접 조절하려고 애쓰지 마세요! 크기가 유연하게 변하는 배열이 필요하다면 C++에서 제공하는 아주 똑똑한 도구인 std::vector를 대신 사용하는 것을 강력히 추천합니다. 복잡한 과정은 얘가 알아서 다 해주거든요!

19.3 — 소멸자 (Destructors)

소멸자(destructor)는 클래스로 만든 객체가 파괴될(사라질) 때 실행되는 또 다른 특별한 멤버 함수입니다. 쉽게 비유하자면, 생성자가 '방에 들어올 때 불을 켜는(초기화) 역할'이라면, 소멸자는 '방에서 나갈 때 불을 끄고 청소하는(정리) 역할'이라고 생각하시면 됩니다!

객체가 정해진 수명을 다해서 자연스럽게 사라지거나, 우리가 delete 키워드를 써서 직접 지웠을 때, 메모리에서 완전히 지워지기 직전에 필요한 뒷정리를 하도록 소멸자가 자동으로 불립니다. 단순한 값을 저장하는 기본 클래스들은 C++이 알아서 깔끔하게 치워주기 때문에 굳이 소멸자를 만들 필요가 없습니다.

하지만 만약 여러분의 클래스 객체가 특별한 자원(예: 동적 메모리 공간, 파일, 데이터베이스 등)을 쥐고 있거나 객체가 사라지기 전에 꼭 마무리해야 할 작업이 있다면 소멸자가 아주 유용하게 쓰입니다. 소멸자는 객체가 세상에서 사라지기 직전에 마지막으로 실행되는 곳이니까요!

소멸자 이름 짓기

생성자처럼 소멸자도 이름을 짓는 특별한 규칙이 있습니다:

• 클래스 이름과 완전히 똑같아야 하며, 맨 앞에 물결표(~)를 붙여야 합니다.
• 매개변수(괄호 안에 넣는 값)를 받을 수 없습니다.
• 반환 타입(return type)이 없습니다.
• 하나의 클래스에는 단 한 개의 소멸자만 만들 수 있습니다.

일반적으로는 코드에서 소멸자를 직접 부를(호출할) 필요가 없습니다. 객체가 죽을 때 알아서 불리기 때문이죠. 굳이 한 번 청소한 곳을 두 번 청소할 이유는 없으니까요! 하지만 소멸자가 실행되는 동안 객체가 아직 완전히 파괴된 것은 아니기 때문에, 소멸자 안에서 다른 멤버 함수를 부르는 것은 안전합니다.

소멸자 예제

소멸자를 사용하는 간단한 클래스를 코드로 살펴볼까요?

#include <iostream>
#include <cassert>
#include <cstddef>

class IntArray
{
private:
    int* m_array{};
    int m_length{};

public:
    IntArray(int length) // 생성자: 객체가 태어날 때 실행됨
    {
        assert(length > 0);

        m_array = new int[static_cast<std::size_t>(length)]{};
        m_length = length;
    }

    ~IntArray() // 소멸자: 객체가 사라질 때 실행됨
    {
        // 앞에서 동적으로 빌려왔던 배열 메모리를 깨끗하게 삭제(반납)합니다.
        delete[] m_array;
    }

    void setValue(int index, int value) { m_array[index] = value; }
    int getValue(int index) { return m_array[index]; }

    int getLength() { return m_length; }
};

int main()
{
    IntArray ar ( 10 ); // 10개의 정수 공간을 가진 배열을 할당합니다.
    for (int count{ 0 }; count < ar.getLength(); ++count)
        ar.setValue(count, count+1);

    std::cout << "5번째 요소의 값은: " << ar.getValue(5) << '\n';

    return 0;
} // 여기서 ar 객체의 수명이 끝나고 파괴되므로, ~IntArray() 소멸자 함수가 자동으로 불립니다!

팁 위 예제를 실행(컴파일)할 때 만약 다음과 같은 에러가 뜬다면: error: 'class IntArray' has pointer data members [-Werror=effc++]| error: but does not override 'IntArray(const IntArray&)' [-Werror=effc++]| error: or 'operator=(const IntArray&)' [-Werror=effc++]| 이 예제를 실행할 때는 컴파일 설정에서 -Weffc++ 플래그를 빼주시거나, 클래스 안에 다음 두 줄의 코드를 추가해 주시면 됩니다. IntArray(const IntArray&) = delete; IntArray& operator=(const IntArray&) = delete; 멤버에 =delete를 사용하는 방법은 나중에 '14.14 - 복사 생성자 소개' 강의에서 자세히 다룰 예정이니 지금은 걱정하지 마세요!

이 프로그램을 실행하면 다음과 같은 결과가 나옵니다: 5번째 요소의 값은: 6

천천히 살펴볼게요. main() 함수의 첫 번째 줄에서 우리는 ar이라는 이름의 IntArray 객체를 만들고, 크기로 10을 넘겨주었습니다. 이때 생성자가 불리면서 배열을 위한 메모리 공간을 컴퓨터로부터 빌려옵니다(이것을 동적 할당이라고 합니다). 배열의 크기를 코드를 짤 때 미리 알 수 없고 사용하는 사람이 정하기 때문에, 이렇게 직접 메모리를 빌려와야만 합니다.

그리고 main() 함수가 끝날 때, ar 객체의 수명이 다해서 죽게 됩니다. 그러면 똑똑한 C++은 자동으로 ~IntArray() 소멸자를 부르고, 생성자에서 빌려왔던 메모리를 잊지 않고 깨끗하게 반납(delete)해 줍니다!

알림 지난 '16.2 - std::vector와 list 생성자 소개'에서, 배열이나 리스트 같은 컨테이너 클래스의 '길이'를 정해서 초기화할 때는 괄호 ()를 사용하는 것이 좋다고 배웠습니다. (요소들의 목록을 직접 넣을 때와 구분하기 위해서요!) 그래서 이 예제에서도 IntArray ar ( 10 ); 처럼 괄호를 사용해 초기화했습니다.

생성자와 소멸자의 타이밍

앞에서 말했듯이, 생성자는 객체가 태어날 때 불리고 소멸자는 객체가 사라질 때 불립니다. 진짜로 그런지 cout (출력) 기능을 사용해서 언제 불리는지 직접 눈으로 확인해 보겠습니다.

#include <iostream>

class Simple
{
private:
    int m_nID{};

public:
    Simple(int nID)
        : m_nID{ nID }
    {
        std::cout << nID << "번 Simple 생성 중 (Constructing)\n";
    }

    ~Simple()
    {
        std::cout << m_nID << "번 Simple 소멸 중 (Destructing)\n";
    }

    int getID() { return m_nID; }
};

int main()
{
    // 1번: 일반적인 방식(스택 메모리)으로 Simple 객체를 만듭니다.
    Simple simple{ 1 };
    std::cout << simple.getID() << '\n';

    // 2번: 동적 할당(new 키워드)으로 Simple 객체를 만듭니다.
    Simple* pSimple{ new Simple{ 2 } };

    std::cout << pSimple->getID() << '\n';

    // pSimple은 동적으로 빌려왔기 때문에, 우리가 꼭 delete로 직접 지워줘야 합니다.
    delete pSimple;

    return 0;
} // 1번 객체(simple)는 함수가 끝나는 여기서 수명이 다해 파괴됩니다.

이 프로그램을 실행하면 다음과 같은 결과가 나옵니다: 1번 Simple 생성 중 (Constructing) 1 2번 Simple 생성 중 (Constructing) 2 2번 Simple 소멸 중 (Destructing) 1번 Simple 소멸 중 (Destructing)

결과를 잘 보세요! '1번'이 먼저 만들어졌지만, 소멸(파괴)될 때는 '2번'이 먼저 죽고 '1번'이 나중에 죽었습니다. 그 이유는 우리가 delete pSimple; 코드를 통해 함수가 끝나기도 전에 '2번'을 직접 지워버렸기 때문입니다. 반면에 '1번(simple)'은 main() 함수가 완전히 끝날 때까지 살아있다가 마지막에 알아서 사라진 것이죠.

참고로, 전체 프로그램 어디서든 쓸 수 있는 전역 변수(Global variables)는 main() 함수가 시작되기도 전에 먼저 만들어지고, main() 함수가 끝난 후 제일 마지막에 파괴됩니다.

RAII (Resource Acquisition Is Initialization)

이름이 조금 어렵고 길죠? RAII(자원 획득은 초기화다)는 C++에서 아주 중요하게 쓰이는 프로그래밍 규칙입니다. 가장 핵심적인 아이디어는 "자원(메모리, 파일 등)을 사용하는 기간을 객체가 살아있는 기간과 똑같이 맞추자!"라는 것입니다.

C++에서는 이 훌륭한 아이디어를 생성자와 소멸자로 실천합니다. 객체가 태어날 때(생성자) 메모리나 파일 같은 자원을 빌려옵니다. 그리고 살아있는 동안 그 자원을 유용하게 씁니다. 마지막으로 객체가 죽을 때(소멸자) 쥐고 있던 자원을 자동으로 반납합니다.

이 RAII 방식의 가장 큰 장점은 컴퓨터의 자원이 새어나가는 것(메모리 누수)을 완벽하게 막아준다는 것입니다. 우리가 깜빡하고 자원 반납을 잊어버려도 객체가 죽을 때 알아서 청소해주기 때문이죠!

이 수업 맨 처음 살펴본 IntArray 클래스가 바로 이 RAII를 보여주는 완벽한 예시입니다. (생성자에서 메모리를 할당받고, 소멸자에서 반환했죠). 여러분이 즐겨 쓰시는 std::string이나 std::vector 같은 표준 기능들도 모두 이 똑똑한 RAII 방식을 따르고 있어서 알아서 메모리를 관리해 준답니다.

std::exit() 함수 사용 시 주의사항

만약 코드 중간에 프로그램 작동을 멈추기 위해 std::exit() 함수를 사용하면, 프로그램이 바로 강제 종료되면서 어떤 소멸자도 불리지 않습니다. 소멸자가 로그를 남기거나 중요한 데이터를 저장하는 등 꼭 필요한 마무리 작업을 하도록 만들어 두었다면, 이 함수를 쓸 때 매우 주의해야 합니다! 작업이 마무리되지 않은 채로 프로그램이 꺼져버리니까요.

요약

정리하자면, 생성자와 소멸자를 짝꿍처럼 잘 활용하면 클래스가 스스로 초기화도 하고 마무리 청소까지 알아서 척척 해냅니다. 개발자가 메모리를 지우는 걸 깜빡하는 등의 실수를 할 확률을 확 줄여주고, 클래스를 사용하는 사람 입장에서도 훨씬 편안하게 코드를 짤 수 있게 해주는 아주 고마운 기능입니다!

19.4 — 포인터의 포인터(이중 포인터)와 동적 다차원 배열

고급 학습자를 위한 내용 이 레슨은 선택 사항이며, C++에 대해 더 깊이 알고 싶은 분들을 위한 내용입니다. 앞으로의 레슨에서 이 내용을 몰라도 문제없으니 편하게 읽어보세요!

포인터의 포인터(이중 포인터)는 이름 그대로예요. 바로 '다른 포인터의 주소를 저장하는 포인터'랍니다.

포인터의 포인터 (Pointers to pointers)

일반적으로 정수(int)를 가리키는 포인터는 별표(*) 하나를 써서 만듭니다.

int* ptr; // int를 가리키는 포인터, 별표 한 개

int를 가리키는 포인터의 주소를 담는 '포인터의 포인터'는 별표를 두 개 씁니다.

int** ptrptr; // int 포인터를 가리키는 포인터, 별표 두 개

포인터의 포인터도 일반 포인터와 똑같이 작동해요. '역참조'(dereference, * 기호를 써서 가리키는 곳의 값을 가져오는 것)를 하면 원래 포인터가 가지고 있던 값을 꺼내올 수 있죠. 그리고 그 꺼내온 값 역시 포인터이기 때문에, 한 번 더 역참조를 하면 마침내 맨 처음 저장했던 진짜 숫자 값을 얻을 수 있습니다. 이렇게 역참조를 연달아 할 수 있어요.

int value { 5 };
int* ptr { &value };
std::cout << *ptr << '\n'; // int 포인터를 역참조해서 int 값을 가져옴

int** ptrptr { &ptr };
std::cout << **ptrptr << '\n'; // 한 번 역참조해서 int 포인터를 가져오고, 한 번 더 역참조해서 최종 int 값을 가져옴

위 프로그램을 실행하면 다음과 같이 나옵니다. 5 5

주의할 점은, 포인터의 포인터에 일반 변수의 주소를 다이렉트로 바로 넣을 수는 없다는 거예요.

int value { 5 };
int** ptrptr { &&value }; // 이렇게 하면 안 됩니다! (오류 발생)

왜냐하면 주소를 가져오는 & 연산자는 메모리에 자리가 확실히 있는 온전한 변수(lvalue)에만 쓸 수 있는데, &value 자체는 잠깐 생겼다 사라지는 임시 값(rvalue)이기 때문이에요.

하지만, 포인터의 포인터를 텅 비워둘 수는 있습니다 (null로 설정).

int** ptrptr { nullptr };

포인터 배열 (Arrays of pointers)

포인터의 포인터는 몇 가지 쓰임새가 있는데요. 가장 흔하게 쓰이는 곳은 바로 '포인터들을 담아두는 배열'을 동적으로 만들 때입니다.

int** array { new int*[10] }; // 10개의 int 포인터를 담을 수 있는 배열 할당

이건 우리가 아는 동적 배열과 똑같이 작동해요. 다만 배열 안에 들어가는 내용물이 단순한 숫자가 아니라, "정수를 가리키는 포인터"라는 점만 다릅니다.

동적으로 할당된 2차원 배열

포인터의 포인터를 쓰는 또 다른 흔한 이유는 다차원 배열을 동적으로 만들기 위해서예요 (다차원 배열이 기억나지 않는다면 이전 레슨인 '17.12 -- C스타일 다차원 배열'을 훑어보세요!).

크기가 정해져 있는 2차원 배열은 평소처럼 이렇게 쉽게 만들 수 있죠.

int array[10][5];

하지만 2차원 배열을 '동적'으로 만드는 건 조금 더 까다롭습니다. 아마 이렇게 직관적으로 해보고 싶으실 거예요.

int** array { new int[10][5] }; // 작동하지 않아요!

안타깝게도 이 코드는 에러가 납니다.

여기엔 두 가지 해결책이 있어요. 만약 배열의 맨 오른쪽 크기(여기선 5)가 변하지 않는 고정된 값(constexpr)이라면 이렇게 할 수 있습니다.

int x { 7 }; // 상수가 아님 (변할 수 있는 값)
int (*array)[5] { new int[x][5] }; // 맨 오른쪽 크기(5)는 반드시 고정된 상수여야 함

여기서 괄호 ()는 꼭 필요해요! 그래야 컴퓨터가 "아, 이 array는 5개의 int가 들어있는 배열을 가리키는 포인터구나"라고 알아듣거든요. 괄호가 없으면 컴퓨터는 int* array[5]로 읽어서, 'int 포인터 5개를 담은 배열'로 잘못 해석해 버립니다.

이럴 때는 컴퓨터가 알아서 타입을 맞춰주는 auto를 쓰면 정말 편합니다.

int x { 7 }; // 상수가 아님
auto array { new int[x][5] }; // 훨씬 간단하죠!

하지만 안타깝게도, 배열의 맨 오른쪽 크기가 컴파일할 때 정해진 상수가 아니라면 이 간단한 방법은 쓸 수 없어요. 그럴 때는 조금 복잡해집니다. 먼저 앞서 배운 대로 '포인터들을 담는 배열'을 만듭니다. 그런 다음, 반복문을 돌면서 각 포인터마다 또 다른 동적 배열을 달아주는 거예요. 즉, 우리의 동적 2차원 배열은 '동적 1차원 배열들을 엮어 놓은 동적 1차원 배열'이 되는 셈이죠!

int** array { new int*[10] }; // 10개의 int 포인터 배열을 할당합니다 — 이것들이 '행(가로줄)'이 됩니다.
for (int count { 0 }; count < 10; ++count)
    array[count] = new int[5]; // 각각의 행마다 5개짜리 배열을 달아줍니다 — 이것들이 '열(세로칸)'이 됩니다.

이렇게 만들어 두면 평소처럼 배열을 쓸 수 있어요.

array[9][4] = 3; // 이건 (array[9])[4] = 3; 과 똑같은 뜻이에요.

이 방법을 쓰면 각각의 가로줄(행)을 따로따로 만들기 때문에, 굳이 네모 반듯한 직사각형 배열이 아니어도 괜찮아요. 예를 들어, 계단처럼 생긴 삼각형 배열도 만들 수 있습니다.

int** array { new int*[10] }; // 10개의 int 포인터 배열 할당 — 이것들이 '행'
for (int count { 0 }; count < 10; ++count)
    array[count] = new int[count+1]; // 행 번호가 커질수록 배열 길이도 길어집니다 — 이것들이 '열'

위 코드에서 array[0]은 길이가 1인 배열, array[1]은 길이가 2인 배열... 이런 식으로 점점 길어지는 걸 볼 수 있죠.

다 쓰고 나서 이 방법으로 만든 2차원 배열을 지울(메모리 해제) 때도 똑같이 반복문이 필요해요.

for (int count { 0 }; count < 10; ++count)
    delete[] array[count];
delete[] array; // 이 부분은 반드시 맨 마지막에 해야 합니다!

주의하세요! 배열을 지울 때는 우리가 만든 순서의 반대로 지워야 합니다 (안에 있는 알맹이 배열부터 지우고, 마지막에 껍데기 배열을 지워요). 껍데기(array)를 먼저 지워버리면, 그 안에 있던 알맹이 배열들의 위치를 찾을 길이 없어져서 컴퓨터가 엉뚱한 행동(정의되지 않은 동작)을 하게 됩니다.

이렇게 2차원 배열을 동적으로 만들고 지우는 건 복잡하고 실수하기 딱 좋아요. 그래서 가로 길이가 x, 세로 길이가 y인 2차원 배열이 필요하다면, 그냥 x * y 크기의 길쭉한 1차원 배열 하나로 쫙 펴서(flatten) 쓰는 게 훨씬 편할 때가 많습니다.

// 이렇게 복잡하게 하는 대신:
int** array { new int*[10] }; // 10개의 int 포인터 배열 할당 — 행
for (int count { 0 }; count < 10; ++count)
    array[count] = new int[5]; // 열

// 이렇게 해보세요!
int *array { new int[50] }; // 10x5 2차원 배열을 50개짜리 1차원 배열 하나로 쫙 폅니다.

이렇게 1차원 배열로 펴놓고, 아주 간단한 수학 계산만 쓰면 2차원 느낌으로 몇 번째 줄, 몇 번째 칸인지 쉽게 찾아낼 수 있답니다.

int getSingleIndex(int row, int col, int numberOfColumnsInArray)
{
     return (row * numberOfColumnsInArray) + col;
}

// 쫙 펴놓은 1차원 배열에서 [9][4] 위치에 3을 넣기
array[getSingleIndex(9, 4, 5)] = 3;

주소로 포인터 전달하기

우리가 함수에 변수의 주소를 넘겨줘서 변수 값을 바꿀 수 있었던 것처럼, 포인터의 포인터를 함수에 넘겨주면 그 포인터가 가리키는 '포인터 자체'의 값을 바꿀 수도 있습니다 (벌써 머리가 아파오나요?).

하지만, 함수에서 포인터가 가리키는 대상을 바꾸게 하고 싶다면, 이중 포인터를 쓰는 것보다 포인터에 대한 참조(reference to a pointer)를 쓰는 게 훨씬 깔끔하고 좋습니다. 이 내용은 '12.11 -- 주소로 전달하기 (2부)' 레슨에서 다루고 있어요.

포인터의 포인터의 포인터...

별표를 세 개 써서 포인터의 포인터의 포인터를 만드는 것도 가능하긴 해요.

int*** ptrx3;

이걸 쓰면 동적인 3차원 배열을 만들 수 있겠죠. 하지만 그러려면 반복문 안에 반복문을 또 넣어야 하고, 에러 없이 제대로 돌아가게 만들기가 엄청나게 복잡해집니다.

심지어 별표 4개짜리도 만들 수 있어요.

int**** ptrx4;

원한다면 그 이상도 얼마든지 덧붙일 수 있죠. 하지만 현실에서는 이렇게까지 겹겹이 포인터를 타고 들어갈 일이 거의 없기 때문에 잘 보지 못하실 겁니다.

결론

어쩔 수 없는 상황이 아니라면, 포인터의 포인터는 되도록 쓰지 않는 것을 강력히 추천합니다. 쓰기 너무 복잡하고 자칫하면 위험해질 수 있거든요. 일반 포인터만 써도 텅 비거나 엉뚱한 곳을 가리키는 오류(null or dangling pointer)를 내기 십상인데, 이중 포인터는 값을 가져오려면 두 번이나 역참조를 해야 하니 그 위험성이 두 배로 커집니다!

19.5 — Void pointers (void 포인터)

void 포인터(제네릭 포인터, 또는 '만능 포인터'라고도 불러요)는 어떤 종류의 데이터 타입이든 가리지 않고 모두 가리킬 수 있는 아주 특별한 포인터입니다! 일반 포인터를 만들 때와 똑같이 선언하지만, 타입 자리에 void라는 키워드를 사용합니다.

void* ptr {}; // ptr은 void 포인터입니다

이 만능 포인터는 숫자(int), 소수(float), 심지어 직접 만든 복잡한 데이터(struct)까지 어떤 것이든 가리킬 수 있어요.

int nValue {};
float fValue {};
struct Something{
    int n;
    float f;
};

Something sValue {};
void* ptr {};
ptr = &nValue; // 가능 (valid)
ptr = &fValue; // 가능 (valid)
ptr = &sValue; // 가능 (valid)

하지만 치명적인 단점이 하나 있습니다! void 포인터는 자신이 '정확히 어떤 종류의 데이터'를 가리키고 있는지 스스로 알지 못해요. 그래서 별표(*)를 붙여서 그 안의 실제 값을 꺼내오는 행동(이것을 역참조라고 합니다)을 하면 에러가 납니다. 값을 꼭 보고 싶다면, 값을 꺼내기 전에 반드시 다른 포인터 타입으로 '변신(캐스팅, cast)'시켜주어야 합니다.

int value{ 5 };
void* voidPtr{ &value };

// std::cout << *voidPtr << '\n'; // 에러: void 포인터는 역참조(값을 꺼내오는 것)를 할 수 없어요!

int* intPtr{ static_cast<int*>(voidPtr) }; // 하지만, void 포인터를 int 포인터로 변환(캐스팅)해준다면...

std::cout << *intPtr << '\n'; // 변환된 결과값을 통해 정상적으로 실제 값을 꺼내올 수 있습니다

이 코드는 다음과 같이 출력됩니다: 5

그럼 당연히 이런 궁금증이 생기겠죠? *"void 포인터가 자기가 뭘 가리키는지 모른다면, 도대체 무슨 타입으로 변환해 줘야 할지 우리가 어떻게 아나요?"* 정답은... 프로그래머인 여러분이 직접 잘 기억하고 추적해야 한다는 것입니다!

실제로 void 포인터가 어떻게 쓰이는지 예시를 통해 볼까요?

#include <cassert>
#include <iostream>

enum class Type{
    tInt, // 참고: "int"는 이미 예약된 키워드라 사용할 수 없어요. 대신 "tInt"를 사용합니다
    tFloat,
    tCString
};

void printValue(void* ptr, Type type){
    switch (type)
    {
    case Type::tInt:
        std::cout << *static_cast<int*>(ptr) << '\n'; // int 포인터로 변환(캐스팅)한 후, 값을 꺼내옵니다(역참조)
        break;
    case Type::tFloat:
        std::cout << *static_cast<float*>(ptr) << '\n'; // float 포인터로 변환한 후, 값을 꺼내옵니다
        break;
    case Type::tCString:
        std::cout << static_cast<char*>(ptr) << '\n'; // char 포인터로 변환합니다 (값을 따로 꺼내올 필요 없음)
        // std::cout은 char*를 C스타일 문자열로 취급해서 전체를 출력해 줍니다
        // 만약 여기서 별표(*)를 붙여 값을 꺼내왔다면, 문자열 전체가 아니라 맨 앞의 글자 하나만 출력되었을 거예요
        break;
    default:
        std::cerr << "printValue(): invalid type provided\n";
        assert(false && "type not found");
        break;
    }
}

int main(){
    int nValue{ 5 };
    float fValue{ 7.5f };
    char szValue[]{ "Mollie" };

    printValue(&nValue, Type::tInt);
    printValue(&fValue, Type::tFloat);
    printValue(szValue, Type::tCString);

    return 0;
}

이 프로그램의 출력 결과입니다: 5 7.5 Mollie

void 포인터 관련 기타 지식

void 포인터도 아무것도 가리키지 않는 텅 빈 상태(null)로 만들 수 있습니다.

void* ptr{ nullptr }; // ptr은 현재 null 포인터인 void 포인터입니다

앞서 void 포인터는 자신이 가리키는 데이터의 정체(크기)를 모른다고 했죠? 그래서 void 포인터에 대고 바로 delete를 사용해 메모리를 지워버리면, 컴퓨터가 얼만큼을 지워야 할지 몰라 예측할 수 없는 심각한 오류(미정의 동작)가 발생합니다. 만약 메모리를 해제해야 한다면, 반드시 먼저 알맞은 원래의 데이터 타입으로 static_cast를 통해 변신시켜준 다음에 지워야 해요.

마찬가지로 void 포인터로는 포인터 연산(포인터에 +1, -1을 해서 다음 칸으로 이동하는 것)도 할 수 없어요. 다음 칸으로 넘어가려면 지금 데이터가 메모리에서 얼만큼의 크기를 차지하는지 알아야 하는데, void 포인터는 그 크기를 모르기 때문입니다.

참고로... C++에 'void 레퍼런스(참조)'라는 것은 존재하지 않아요. 만약 존재한다면 void& 같은 형태일 텐데, 자신이 참조하는 값이 어떤 타입인지 알 수 없는 빈 껍데기가 되어버리기 때문입니다.

결론 및 요약

결론적으로 말씀드리면, 정말 꼭 필요한 상황이 아니라면 void 포인터는 최대한 피하는 것이 좋습니다.

왜냐하면 컴파일러가 '이 데이터 타입이 맞는지' 검사해 주는 안전장치를 아예 꺼버리는 것과 같거든요. 실수로 전혀 말이 안 되는 코드를 짜더라도 컴파일러가 경고조차 해주지 않습니다. 예를 들어 아래 코드는 에러 없이 무사히 실행됩니다.

int nValue{ 5 };
printValue(&nValue, Type::tCString);

하지만 저 코드가 실제로 어떤 엉뚱한 결과를 뱉어낼지는 아무도 모르죠!

앞서 본 예시 함수(printValue)가 여러 데이터 타입을 한 번에 처리하는 멋지고 깔끔한 방법처럼 보일 수 있어요. 하지만 C++에는 타입 검사도 안전하게 다 해주면서 똑같은 기능을 구현할 수 있는 훨씬 훌륭한 방법인 함수 오버로딩(function overloading)이 있습니다. 오용을 막아주는 든든한 기능이죠. 또한, 예전에는 여러 타입을 다루기 위해 void 포인터를 썼던 많은 곳들이, 요즘은 강력한 타입 검사 기능을 제공하는 템플릿(templates)으로 훨씬 안전하게 대체되었습니다.

아주 가끔 프로그래밍을 하다 보면 void 포인터가 꼭 필요한 합리적인 상황을 만날 수도 있습니다. 하지만 그럴 때는 항상 *"C++의 다른 안전한 언어 기능(오버로딩, 템플릿 등)으로 똑같이 해결할 방법은 없을까?"*를 먼저 꼼꼼히 고민해 보시길 바랍니다!

정렬이 필요한 이유

배열 정렬이란 배열 안에 있는 데이터들을 특정한 순서대로 보기 좋게 나열하는 과정을 말합니다. 정렬은 우리가 컴퓨터를 사용하는 일상생활 곳곳에서 아주 유용하게 쓰이고 있어요. 예를 들어, 이메일 프로그램은 보통 가장 최근에 받은 메일을 먼저 보여주기 위해 시간순으로 이메일을 정렬합니다. 연락처 목록을 볼 때는 이름이 가나다순이나 알파벳순으로 정렬되어 있죠? 그래야 원하는 사람의 이름을 찾기 훨씬 쉬우니까요. 이렇게 화면에 정보를 띄워주기 전에 데이터를 미리 찾기 쉽게 다듬는 것이 바로 정렬의 역할입니다.

정렬은 사람뿐만 아니라 컴퓨터가 데이터를 검색할 때도 훨씬 빠르고 효율적으로 일할 수 있게 도와줍니다. 이름 목록에서 특정 이름이 있는지 확인해야 하는 상황을 상상해 볼까요? 만약 이름이 뒤죽박죽 섞여 있다면, 컴퓨터는 그 이름이 있는지 확인하기 위해 배열의 처음부터 끝까지 하나하나 전부 다 검사해야만 합니다. 데이터가 엄청나게 많다면 이 작업은 시간이 아주 오래 걸리고 힘든(비용이 많이 드는) 작업이 될 거예요.

하지만 이제 이름들이 알파벳순으로 예쁘게 정렬되어 있다고 생각해 보세요. 이 경우에는 우리가 찾는 이름보다 알파벳 순서가 더 뒤에 있는 이름을 마주치는 순간, 검색을 바로 멈추면 됩니다! 그 뒤에 남은 이름들은 전부 우리가 찾는 이름보다 알파벳 순서가 늦을 것이 확실하기 때문에, 굳이 끝까지 찾아볼 필요조차 없는 것이죠.

사실 이렇게 이미 정렬된 배열 안에서 데이터를 찾는 데는 훨씬 더 훌륭하고 똑똑한 방법들이 존재합니다. 아주 간단한 검색 방법만 사용하더라도 100만 개나 되는 데이터 속에서 단 20번만 값을 비교해보고 원하는 것을 찾아낼 수 있을 정도니까요! 물론 단점도 있습니다. 애초에 흩어진 배열을 순서대로 '정렬'하는 작업 자체가 컴퓨터에게는 꽤 번거로운 일입니다. 그래서 데이터를 여러 번 반복해서 검색해야 하는 상황이 아니라면, 검색 한 번 빨리 하겠다고 굳이 정렬을 먼저 하는 것은 오히려 손해일 수도 있습니다.

어떤 경우에는 정렬을 해두는 것만으로도 아예 '검색' 자체가 필요 없어지기도 합니다. 학생들의 시험 점수 중에서 가장 높은 1등 점수를 찾는다고 해볼까요? 점수가 막 섞여 있다면 모든 점수를 다 훑어봐야 1등 점수를 알 수 있습니다. 하지만 이미 점수가 순서대로 정렬되어 있다면, 그냥 맨 앞자리나 맨 뒷자리(오름차순이냐 내림차순이냐에 따라 다름)만 쏙 확인하면 끝납니다. 찾고 자시고 할 것도 없죠!

정렬은 어떻게 이루어질까?

정렬은 보통 두 개의 데이터를 짝지어 서로 비교해 본 다음, 우리가 정해둔 기준에 맞지 않으면 두 데이터의 위치를 서로 바꾸는(swap) 과정을 계속 반복하면서 이루어집니다. 어떤 정렬 방식을 선택하느냐에 따라 이 데이터들을 비교하는 순서가 달라지고, 어떤 순서로 정렬할지 (예: 작은 것부터 큰 것으로 가는 오름차순, 큰 것부터 작은 것으로 가는 내림차순)에 따라 자리를 바꾸는 기준이 달라집니다.

C++에서는 두 데이터의 자리를 바꿀 때, C++ 표준 라이브러리의 <utility> 헤더에 미리 만들어져 있는 std::swap()이라는 함수를 아주 편리하게 사용할 수 있습니다.

#include <iostream>
#include <utility>

int main()
{
    int x{ 2 };
    int y{ 4 };
    std::cout << "Before swap: x = " << x << ", y = " << y << '\n';
    std::swap(x, y); // x와 y의 값을 서로 바꿉니다.
    std::cout << "After swap:  x = " << x << ", y = " << y << '\n';

    return 0;
}

이 프로그램을 실행하면 화면에 다음과 같이 출력됩니다:

Before swap: x = 2, y = 4
After swap:  x = 4, y = 2

std::swap()을 거치고 난 후, x와 y가 가진 값이 서로 완벽하게 맞바뀐 것을 볼 수 있습니다!

선택 정렬 (Selection sort)

배열을 정렬하는 방법은 아주 여러 가지가 존재합니다. 그중에서도 선택 정렬(Selection sort)은 아마도 정렬 방법 중에서 가장 이해하기 쉬운 녀석일 것입니다. 비록 속도는 다른 정렬 방법들에 비해 조금 느린 편이지만, 작동 원리가 매우 직관적이라서 초보자들에게 정렬의 개념을 가르칠 때 아주 좋은 교재가 됩니다.

선택 정렬을 이용해서 숫자를 가장 작은 것부터 가장 큰 것 순서(오름차순)로 줄 세우는 과정은 다음과 같습니다:

1. 배열의 맨 처음(인덱스 0)부터 시작해서 끝까지 쭉 훑어보며 가장 작은 값을 찾습니다.
2. 찾은 가장 작은 값을 배열의 맨 첫 번째 자리(인덱스 0)에 있는 값과 서로 자리를 바꿉니다.
3. 이제 첫 번째 자리는 완성되었으니 신경 쓰지 말고, 그다음 자리(인덱스 1)부터 시작해서 위 1번과 2번의 과정을 남은 배열 끝까지 계속 반복합니다.

쉽게 말해, 전체에서 제일 작은 녀석을 골라내서 맨 앞에 갖다 놓고, 남은 애들 중에서 제일 작은 녀석을 골라내서 두 번째 자리에 갖다 놓는 작업을 계속하는 거예요. 데이터가 바닥날 때까지 말이죠!

5개의 숫자가 들어있는 배열을 통해 이 과정이 어떻게 진행되는지 직접 눈으로 따라가 봅시다. 처음 배열의 상태입니다. { 30, 50, 20, 10, 40 }

먼저, 첫 번째 자리(인덱스 0)부터 시작해서 제일 작은 숫자를 찾습니다. { 30, 50, 20, 10, 40 } (여기서 제일 작은 숫자는 10이네요!)

이 제일 작은 숫자 10을 첫 번째 자리(인덱스 0)에 있던 30과 서로 바꿉니다: { 10, 50, 20, 30, 40 }

이제 맨 앞자리(10)는 제대로 된 주인을 찾았으니 무시해도 좋습니다. 남은 숫자들 중 두 번째 자리(인덱스 1)부터 시작해서 제일 작은 숫자를 찾습니다: { 10, 50, 20, 30, 40 } (남은 애들 중 제일 작은 숫자는 20이네요!)

이 20을 두 번째 자리(인덱스 1)에 있던 50과 자리를 바꿉니다: { 10, 20, 50, 30, 40 }

이제 앞의 두 자리 정렬이 끝났습니다. 세 번째 자리(인덱스 2)부터 시작해서 제일 작은 숫자를 또 찾습니다: { 10, 20, 50, 30, 40 } (이번엔 30이 제일 작네요!)

30을 세 번째 자리(인덱스 2)에 있던 50과 바꿉니다: { 10, 20, 30, 50, 40 }

네 번째 자리(인덱스 3)부터 남은 숫자 중 제일 작은 것을 찾습니다: { 10, 20, 30, 50, 40 } (40이 제일 작습니다!)

40을 네 번째 자리(인덱스 3)에 있던 50과 바꿉니다: { 10, 20, 30, 40, 50 }

마지막으로 다섯 번째 자리(인덱스 4)에서 가장 작은 숫자를 찾습니다: { 10, 20, 30, 40, 50 } (혼자 남은 50이네요)

50을 다섯 번째 자리에 있는 값(자기 자신)과 바꿉니다 (사실상 아무 변화가 일어나지 않습니다): { 10, 20, 30, 40, 50 }

짜잔! 정렬이 모두 끝났습니다! { 10, 20, 30, 40, 50 }

여기서 한 가지 눈치채셨나요? 맨 마지막에 남는 1개는 항상 자기 자신과 자리를 바꾸게 되므로(쓸데없는 행동이죠), 굳이 마지막까지 검사할 필요 없이 배열의 맨 끝부분 바로 앞까지만 반복 작업을 해주면 됩니다.

C++로 구현한 선택 정렬

지금까지 배운 선택 정렬 알고리즘을 C++ 코드로 똑같이 옮겨 적어보겠습니다:

#include <iostream>
#include <iterator>
#include <utility>

int main()
{
    int array[]{ 30, 50, 20, 10, 40 };
    constexpr int length{ static_cast<int>(std::size(array)) };

    // 배열의 요소를 하나씩 차례대로 훑고 지나갑니다
    // (단, 맨 마지막 요소는 그 앞까지 정렬하는 동안 알아서 자기 자리를 찾을 테니, 마지막 요소 바로 앞까지만 반복합니다)
    for (int startIndex{ 0 }; startIndex < length - 1; ++startIndex)
    {
        // smallestIndex는 이번 한 바퀴를 돌면서 찾아낸 '가장 작은 요소'의 위치(인덱스)를 기억할 변수입니다
        // 처음 시작할 때는 현재 살펴보고 있는 첫 번째 요소가 가장 작다고 일단 가정합니다
        int smallestIndex{ startIndex };

        // 그런 다음, 배열의 나머지 뒷부분을 쭉 살펴보면서 더 작은 요소가 숨어있는지 찾아냅니다
        for (int currentIndex{ startIndex + 1 }; currentIndex < length; ++currentIndex)
        {
            // 만약 우리가 지금까지 제일 작다고 생각했던 것보다 더 작은 요소를 발견하게 된다면
            if (array[currentIndex] < array[smallestIndex])
                // 진짜 제일 작은 요소의 위치를 새로운 위치로 업데이트해서 기억해둡니다
                smallestIndex = currentIndex;
        }

        // 위 과정을 다 거치고 나면, smallestIndex는 남은 배열 부분에서 '진짜로 가장 작은 요소'의 위치를 가리키게 됩니다
        // 이제 우리가 처음에 가정했던 시작 위치의 요소와 진짜 가장 작은 요소를 서로 맞바꿔 줍니다 (이로써 제자리를 찾아갑니다)
        std::swap(array[startIndex], array[smallestIndex]);
    }

    // 이제 전체 배열이 예쁘게 정렬되었을 테니, 잘 작동하는지 화면에 쭉 출력해서 확인해 봅니다
    for (int index{ 0 }; index < length; ++index)
        std::cout << array[index] << ' ';

    std::cout << '\n';

    return 0;
}

코드를 처음 보시는 분들이 여기서 가장 헷갈려 하는 부분은 바로 반복문(for 문) 안에 또 다른 반복문이 들어있는 구조일 것입니다. 이를 '중첩 반복문'이라고 부릅니다. 바깥쪽에 있는 반복문(startIndex)은 우리가 정렬해서 꽂아 넣을 자리를 맨 앞에서부터 한 칸씩 뒤로 이동시키는 역할을 합니다. 바깥쪽 반복문이 한 칸 이동할 때마다, 안쪽에 있는 반복문(currentIndex)이 맹활약하면서 아직 정렬되지 않은 나머지 뒷부분을 전부 훑어보고 그중 가장 작은 녀석의 위치를 찾아냅니다. 안쪽 반복문이 가장 작은 녀석의 위치를 smallestIndex에 잘 기억해 두었다가 작업이 끝나면, 그 녀석을 바깥쪽 반복문이 가리키고 있던 현재 자리(startIndex)의 값과 교체합니다. 그리고 바깥쪽 반복문은 다음 칸으로 이동하여 이 전체 과정을 반복하는 원리입니다.

팁: 만약 위에 있는 코드가 머릿속에 잘 안 그려진다면, 이면지를 한 장 꺼내서 샘플 배열을 하나 적어두고 직접 손으로 따라가 보는 것이 최고입니다. 종이 맨 위에 정렬되지 않은 처음 배열의 숫자들을 적으세요. 그리고 startIndex, currentIndex, smallestIndex라는 이름표를 달아둔 화살표를 그려서 각각 어떤 숫자를 가리키고 있는지 표시해 보세요. 코드가 한 줄 한 줄 실행될 때마다 화살표를 직접 옮겨보고, 바깥쪽 반복문이 한 바퀴 끝날 때마다 그다음 줄에 새롭게 변화된 배열의 모습을 그려 나가다 보면 원리가 아주 쉽게 이해될 거예요.

사람들의 이름을 정렬할 때도 작동하는 방식은 완전히 똑같습니다. 단지 배열의 종류를 숫자를 담는 int에서 문자를 담는 std::string으로 슬쩍 바꿔주고, 안에 숫자가 아닌 이름들을 채워 넣어주기만 하면 된답니다.

std::sort 함수 사용하기

배열을 정렬하는 일은 프로그래밍을 하다 보면 밥 먹듯이 아주 자주 일어나는 일입니다. 그래서 C++에서는 우리가 일일이 복잡한 정렬 코드를 짜지 않아도 되도록, C++ 표준 라이브러리 안에 std::sort라는 이름의 강력하고 편리한 정렬 함수를 기본적으로 제공해 줍니다. 이 함수는 <algorithm> 헤더를 추가해서 사용할 수 있고, 아래처럼 아주 간단하게 부려먹을 수 있습니다.

#include <algorithm> // std::sort를 사용하려면 이 헤더가 필요합니다
#include <iostream>
#include <iterator> // std::size를 사용하려면 이 헤더가 필요합니다

int main()
{
    int array[]{ 30, 50, 20, 10, 40 };

    // 마법의 주문! 배열의 처음부터 끝까지 알아서 정렬해 줍니다.
    std::sort(std::begin(array), std::end(array));

    for (int i{ 0 }; i < static_cast<int>(std::size(array)); ++i)
        std::cout << array[i] << ' ';

    std::cout << '\n';

    return 0;
}

이 std::sort 함수를 별다른 조건 없이 그대로 실행시키면, 기본적으로 작은 것부터 큰 것으로 가는 오름차순으로 배열을 척척 정리해 줍니다. 보이지 않는 내부에서는 우리가 앞에서 배웠던 선택 정렬처럼 두 데이터를 작다(<) 기호를 사용해 짝지어 비교하고, 순서가 엇갈려 있으면 서로 자리를 휙휙 바꿔가며 영리하게 정렬을 수행한답니다.

이 편리한 std::sort에 대한 더 깊고 재미있는 이야기는 나중에 다른 장에서 다룰 예정이니 기대해 주세요!

18.2 — 이터레이터(반복자) 소개

배열이나 여러 데이터가 모여 있는 구조에서 데이터를 '처음부터 끝까지 하나씩 살펴보는 일(반복, Iterating)'은 프로그래밍에서 정말 흔하게 하는 작업입니다. 우리는 지금까지 이 작업을 하기 위해 여러 가지 방법을 배웠습니다. 인덱스와 반복문을 사용하는 방법(for 문, while 문), 포인터와 포인터 연산을 사용하는 방법, 그리고 아주 간편한 '범위 기반(range-based) for 문'을 사용하는 방법 말이죠.

#include <array>
#include <cstddef>
#include <iostream>

int main()
{
    // C++17에서는 arr 변수의 타입이 std::array<int, 7>로 자동 추론됩니다.
    // 만약 이 예제를 컴파일할 때 오류가 발생한다면, 아래 주의 사항을 확인하세요.
    std::array arr{ 0, 1, 2, 3, 4, 5, 6 };
    std::size_t length{ std::size(arr) };

    // 명시적인 인덱스를 사용하는 while 문
    std::size_t index{ 0 };
    while (index < length)
    {
        std::cout << arr[index] << ' ';
        ++index;
    }
    std::cout << '\n';

    // 명시적인 인덱스를 사용하는 for 문
    for (index = 0; index < length; ++index)
    {
        std::cout << arr[index] << ' ';
    }
    std::cout << '\n';

    // 포인터를 사용하는 for 문 (참고: ptr을 증가시켜야 하므로 const가 될 수 없습니다)
    for (auto ptr{ &arr[0] }; ptr != (&arr[0] + length); ++ptr)
    {
        std::cout << *ptr << ' ';
    }
    std::cout << '\n';

    // 범위 기반 for 문
    for (int i : arr)
    {
        std::cout << i << ' ';
    }
    std::cout << '\n';

    return 0;
}

주의 사항 이 레슨의 예제들은 '클래스 템플릿 인수 추론'이라는 C++17의 편리한 기능을 사용합니다. 쉽게 말해, 초기화하는 값을 보고 컴파일러가 알아서 타입을 유추해 주는 기능입니다. 위 예제에서 컴파일러가 std::array arr{ 0, 1, 2, 3, 4, 5, 6 };을 보면, 우리가 std::array<int, 7> arr { 0, 1, 2, 3, 4, 5, 6 };을 만들고 싶어 한다는 것을 찰떡같이 알아챕니다. 만약 여러분의 컴파일러가 C++17을 지원하지 않는 설정이라면 "arr 앞에 템플릿 인수가 누락되었습니다" 같은 오류가 뜰 수 있습니다. 이럴 때는 레슨 0.12를 참고해 C++17을 활성화하는 것이 가장 좋습니다. 만약 버전을 올릴 수 없다면, 코드를 명시적인 타입이 적힌 형태로 바꿔주세요. (예: std::array arr{ 0, 1, 2, 3, 4, 5, 6 }; 부분을 std::array<int, 7> arr { 0, 1, 2, 3, 4, 5, 6 };로 수정)

데이터에 접근하기 위해서만 인덱스를 사용하는 경우라면, 인덱스 방식은 불필요하게 코드를 많이 쳐야 합니다. 게다가 이 방식은 배열처럼 요소에 '직접 접근(번호표를 보고 바로 찾아가는 것)'이 가능한 구조에서만 쓸 수 있습니다. 리스트(list) 같은 다른 데이터 구조에서는 인덱스로 바로 찾아가는 것이 불가능하거든요.

포인터와 포인터 연산(포인터에 숫자를 더해서 다음 칸으로 이동하는 것)을 사용해 반복하는 방법은 코드가 복잡해 보이고, 이 규칙을 잘 모르는 사람에게는 매우 헷갈릴 수 있습니다. 또한 이 방법은 배열처럼 메모리상에 데이터가 '다닥다닥 연속으로' 붙어있을 때만 제대로 작동합니다. 리스트, 트리, 맵 같은 구조에서는 데이터가 연속해 있지 않기 때문에 쓸 수 없습니다.

고급 학습자를 위한 내용 메모리에 연속으로 붙어있지 않은 데이터 구조라도, 포인터 연산(덧셈/뺄셈) 없이 그냥 포인터 자체만으로 반복할 수 있는 경우도 있습니다. 예를 들어 연결 리스트(Linked list)에서는 각 데이터가 다음 데이터를 가리키는 포인터를 가지고 있어서, 이 꼬리물기 포인터를 따라가며 하나씩 살펴볼 수 있습니다.

범위 기반 for 문은 아주 흥미롭습니다. 데이터를 하나씩 꺼내오는 복잡한 과정이 우리 눈에는 안 보이게 숨겨져 있거든요. 게다가 배열, 리스트, 트리, 맵 등 종류를 가리지 않고 모든 구조에서 다 잘 작동합니다. 도대체 어떻게 이게 가능한 걸까요? 바로 '이터레이터(Iterator)'를 사용하기 때문입니다.

이터레이터 (반복자)

이터레이터(Iterator)는 컨테이너(배열의 값들이나 문자열의 글자들처럼 데이터를 담아두는 바구니) 안을 처음부터 끝까지 돌아다니며, 지나가는 길에 있는 각 데이터에 접근할 수 있게끔 특별히 만들어진 도구입니다. 비유하자면 데이터 창고를 안내해 주는 '가이드'와 같습니다.

하나의 컨테이너가 여러 종류의 이터레이터를 제공할 수도 있습니다. 예를 들어 어떤 배열은 앞에서부터 뒤로 걸어가는 '정방향 이터레이터'를 제공하기도 하고, 뒤에서부터 앞으로 거꾸로 걸어가는 '역방향 이터레이터'를 제공하기도 합니다.

알맞은 이터레이터를 하나 만들기만 하면, 프로그래머는 데이터가 메모리에 어떻게 저장되어 있는지, 앞으로 어떻게 걸어갈지 고민할 필요가 없습니다. 그냥 이터레이터가 제공하는 간단한 조작법만 쓰면 됩니다. 특히 C++의 이터레이터들은 보통 사용법이 다 똑같습니다. operator++ (플러스플러스 기호)를 쓰면 다음 데이터로 이동하고, operator* (별표 기호)를 쓰면 지금 가리키고 있는 데이터를 꺼내옵니다. 이 통일된 사용법 덕분에 우리는 아주 다양한 종류의 데이터 컨테이너를 똑같은 방법으로 다룰 수 있게 됩니다.

이터레이터 역할을 하는 포인터

가장 단순한 형태의 이터레이터는 바로 '포인터'입니다. 메모리에 데이터가 일렬로 쭉 저장되어 있을 때 포인터를 사용하면 아주 잘 작동하죠. 포인터를 사용해 간단한 배열을 훑어보는 코드를 다시 살펴볼까요?

#include <array>
#include <iostream>

int main()
{
    std::array arr{ 0, 1, 2, 3, 4, 5, 6 };

    auto begin{ &arr[0] };
    // 주의: 이것은 마지막 원소의 바로 '다음' 빈 공간을 가리킵니다.
    auto end{ begin + std::size(arr) };

    // 포인터를 사용하는 for 문
    for (auto ptr{ begin }; ptr != end; ++ptr) // ++를 사용해 다음 요소로 이동
    {
        std::cout << *ptr << ' '; // 역참조(*)를 통해 현재 요소의 실제 값을 가져옴
    }
    std::cout << '\n';

    return 0;
}

출력 결과: 0 1 2 3 4 5 6

위 코드에서 우리는 두 개의 변수를 만들었습니다. 하나는 데이터의 출발점을 가리키는 begin이고, 다른 하나는 끝나는 지점을 표시하는 end입니다. 배열에서 이 끝 지점(end marker)은 보통 '마지막 데이터가 있는 자리'가 아니라, '마지막 데이터 바로 다음 빈칸'을 의미합니다. 만약 데이터가 하나 더 있었다면 들어갈 바로 그 자리 말이죠.

포인터는 이 begin부터 출발해 end에 닿기 전까지 이동하며, 포인터에 역참조 기호(*)를 붙여서 현재 위치의 데이터를 읽어옵니다.

주의 사항 끝 지점을 계산할 때 아래처럼 배열 문법을 사용해 주소를 가져오고 싶으실 수도 있습니다. int* end{ &arr[std::size(arr)] }; 하지만 이렇게 하면 '정의되지 않은 동작(Undefined behavior, 프로그램이 뻗거나 예측 불가능하게 행동함)'이 발생합니다. 왜냐하면 저 코드는 배열의 진짜 범위를 벗어난 곳의 값을 은연중에 읽어오려고 시도하기 때문입니다. 대신 아래처럼 안전한 방식을 사용하세요: int* end{ arr.data() + std::size(arr) }; // data()는 첫 번째 요소를 가리키는 포인터를 줍니다.

표준 라이브러리 이터레이터

데이터를 순서대로 살펴보는 건 프로그래밍에서 숨 쉬는 것만큼 자연스럽고 흔한 일입니다. 그래서 C++의 모든 표준 라이브러리 컨테이너(데이터 저장소들)는 이터레이터 기능을 기본적으로 내장하고 있습니다. 우리가 힘들게 출발점과 끝점을 계산할 필요 없이, 컨테이너에게 직접 begin()과 end()라는 함수를 불러서 "시작점과 끝점을 알려줘!"라고 물어보기만 하면 됩니다.

#include <array>
#include <iostream>

int main()
{
    std::array array{ 1, 2, 3 };

    // 배열에게 시작점과 끝점을 물어봅니다 (begin 및 end 멤버 함수 사용).
    auto begin{ array.begin() };
    auto end{ array.end() };

    for (auto p{ begin }; p != end; ++p) // ++를 사용해 다음 요소로 이동.
    {
        std::cout << *p << ' '; // 역참조를 통해 현재 요소의 값을 가져옴.
    }
    std::cout << '\n';

    return 0;
}

출력 결과: 1 2 3

<iterator>라는 헤더 파일 안에는 범용적으로 쓸 수 있는 std::begin과 std::end라는 함수도 들어 있습니다.

팁 구형 C스타일 배열을 위한 std::begin과 std::end는 <iterator> 헤더에 정의되어 있습니다. 이터레이터를 지원하는 최신 컨테이너들을 위한 std::begin과 std::end는 해당 컨테이너의 헤더 파일(예: <array>, <vector>)에 같이 들어 있습니다.

#include <array>    // <iterator>를 포함합니다
#include <iostream>

int main()
{
    std::array array{ 1, 2, 3 };

    // std::begin과 std::end를 사용해 시작점과 끝점을 가져옵니다.
    auto begin{ std::begin(array) };
    auto end{ std::end(array) };

    for (auto p{ begin }; p != end; ++p) // ++를 사용해 다음 요소로 이동
    {
        std::cout << *p << ' '; // 역참조를 통해 현재 요소의 값을 가져옴
    }
    std::cout << '\n';

    return 0;
}

이것도 똑같이 출력됩니다: 1 2 3

지금 당장 이터레이터의 '타입(자료형)'이 정확히 뭔지 몰라도 괜찮습니다. 나중에 다른 챕터에서 자세히 다룰 거거든요. 여기서 가장 중요한 핵심은 '컨테이너 안을 돌아다니는 복잡한 과정은 이터레이터가 다 알아서 해준다'는 점입니다. 우리가 필요한 건 딱 네 가지뿐입니다. 시작점(begin), 끝점(end), 다음으로 넘어가게 해주는 버튼(operator++), 그리고 값을 꺼내오는 버튼(operator*)입니다.

이터레이터에서의 operator< 와 operator!= 비교

이전 레슨 8.10(For 문)에서, 우리는 숫자를 비교해 반복문을 돌릴 때는 !=보다 < 기호를 쓰는 것이 더 좋다고 배웠습니다. for (index = 0; index < length; ++index)

하지만 이터레이터를 쓸 때는 != (같지 않다) 기호를 사용해 이터레이터가 끝 지점(end)에 도달했는지 확인하는 것이 표준 관행입니다. for (auto p{ begin }; p != end; ++p)

왜 그럴까요? 어떤 이터레이터들은 구조상 크기를 비교하는 것(<, >)이 아예 불가능하기 때문입니다. 하지만 != 기호는 어떤 종류의 이터레이터든 상관없이 항상 무사히 작동합니다.

다시 보는 범위 기반 for 문 (Range-based for loops)

begin()과 end() 함수를 가지고 있거나, std::begin() 및 std::end() 함수와 함께 쓸 수 있는 모든 데이터 타입은 아주 편리한 '범위 기반 for 문'에 쓸 수 있습니다.

#include <array>
#include <iostream>

int main()
{
    std::array array{ 1, 2, 3 };

    // 이 코드는 우리가 앞에서 썼던 반복문과 완전히 똑같이 동작합니다.
    for (int i : array)
    {
        std::cout << i << ' ';
    }
    std::cout << '\n';

    return 0;
}

보이지 않는 곳에서, 범위 기반 for 문은 훑어볼 대상의 begin()과 end()를 몰래 호출해서 사용하고 있습니다. std::array는 자체적으로 이 함수들을 가지고 있기 때문에 범위 기반 반복문에 넣고 돌릴 수 있는 거죠. 구형 C스타일의 고정 크기 배열도 std::begin과 std::end 함수와 호환되기 때문에 역시 사용할 수 있습니다. 하지만 구형 C스타일의 '동적 배열(크기가 변하는 배열)'이나 포인터로 깎여버린(decayed) 배열은 쓸 수 없습니다. 이런 배열들은 길이 정보를 잃어버려서 std::end 함수를 찾을 수 없기 때문입니다.

여러분이 직접 만든 타입에도 이 함수들을 추가해서 범위 기반 for 문을 쓸 수 있게 만드는 방법은 나중에 배우게 될 겁니다.

그리고 이터레이터는 범위 기반 for 문에서만 쓰이는 게 아닙니다. 표준 라이브러리의 std::sort(데이터 정렬하기) 같은 수많은 유용한 알고리즘에서도 널리 쓰입니다. 이제 이터레이터가 뭔지 아셨으니, 앞으로 표준 라이브러리를 쓰면서 이 녀석이 얼마나 자주 등장하는지 보게 되실 겁니다.

이터레이터 무효화 (허공을 맴도는 이터레이터)

포인터나 참조자(Reference)와 마찬가지로, 이터레이터도 가리키고 있던 데이터의 메모리 주소가 바뀌거나 데이터가 파괴되어 버리면 길을 잃고 "허공을 가리키게(dangling)" 될 수 있습니다. 이런 상황을 이터레이터가 무효화(Invalidated)되었다고 부릅니다. 무효화된 이터레이터에 억지로 접근하려고 하면 아까 말했던 끔찍한 '정의되지 않은 동작(Undefined behavior)'이 발생합니다.

데이터 저장소를 수정하는 몇몇 작업들(예를 들어 std::vector라는 바구니에 새로운 데이터를 쑤셔 넣는 일)은, 그 안에 들어있던 기존 데이터들의 메모리 주소를 통째로 이사시켜 버리는 부작용을 낳기도 합니다. 데이터들이 이사를 가버리면, 원래 위치를 가리키고 있던 옛날 이터레이터들은 전부 쓸모가 없어집니다(무효화됩니다). 좋은 C++ 공식 문서들은 어떤 행동을 했을 때 이터레이터가 무효화될 수 있는지 항상 친절하게 경고해 둡니다. (cppreference 사이트의 std::vector 문서 중 "Iterator invalidation(이터레이터 무효화)" 항목을 참고해 보세요.)

우리가 자주 쓰는 범위 기반 for 문 역시 뒤에서는 이터레이터를 쓰고 있습니다. 그러니 반복문이 쌩쌩 돌아가고 있는 중간에 이터레이터를 무효화시키는 짓을 하지 않도록 각별히 조심해야 합니다.

#include <vector>

int main()
{
    std::vector v { 0, 1, 2, 3 };

    for (auto num : v) // 뒤에서 몰래 v의 이터레이터를 돌리며 요소를 봅니다
    {
        if (num % 2 == 0)
            v.push_back(num + 1); // 데이터를 밀어 넣다가 v의 이터레이터가 무효화되면, 프로그램이 어떻게 뻗을지 모릅니다 (정의되지 않은 동작)
    }

    return 0;
}

이터레이터가 무효화되는 또 다른 예시를 볼까요?

#include <iostream>
#include <vector>

int main()
{
    std::vector v{ 1, 2, 3, 4, 5, 6, 7 };

    auto it{ v.begin() };

    ++it; // 두 번째 요소로 이동합니다
    std::cout << *it << '\n'; // 정상 작동: 2가 출력됩니다

    v.erase(it); // 지금 이터레이터가 가리키고 있는 요소를 지워버립니다!

    // erase() 함수는 지워진 요소(및 그 뒤에 있는 요소들)를 가리키던 이터레이터들을 모두 무효화시킵니다.
    // 그러므로 이제 이터레이터 "it"은 쓸모없는 쓰레기가 되었습니다.

    ++it; // 정의되지 않은 동작 (에러 위험!)
    std::cout << *it << '\n'; // 정의되지 않은 동작 (에러 위험!)

    return 0;
}

이렇게 무효화되어 길을 잃은 이터레이터는, 올바른 위치를 가리키는 새 이터레이터를 덮어씌워 주면(예: begin(), end(), 혹은 이터레이터를 반환하는 다른 함수의 결괏값을 다시 넣어줌) 다시 정상적으로 쓸 수 있습니다.

참고로 erase() 함수는 요소를 하나 지우고 나면, 친절하게도 '지워진 녀석의 바로 다음 요소'를 가리키는 새로운 이터레이터를 반환해 줍니다. (만약 마지막 요소를 지웠다면 end()를 줍니다). 따라서 위에서 에러가 나던 코드는 아래처럼 아주 쉽게 고칠 수 있습니다!

#include <iostream>
#include <vector>

int main()
{
    std::vector v{ 1, 2, 3, 4, 5, 6, 7 };

    auto it{ v.begin() };

    ++it; // 두 번째 요소로 이동
    std::cout << *it << '\n';

    it = v.erase(it); // 현재 요소를 지운 다음, `it`이 다음 요소를 가리키도록 새 이터레이터 값을 받아옵니다.

    std::cout << *it << '\n'; // 이제 안전합니다! 3이 출력됩니다.

    return 0;
}

18.3 — 표준 라이브러리 알고리즘 소개

프로그래밍을 갓 배우기 시작한 분들은 정렬하기, 개수 세기, 배열 검색하기 같은 꽤 간단한 작업을 하기 위해 직접 반복문(loop)을 짜는 데 많은 시간을 보냅니다. 그런데 이 반복문이라는 게 은근히 골칫거리입니다. 오타나 실수를 내기도 쉽고, 나중에 코드를 다시 읽을 때 "이게 뭐 하는 코드였지?" 하고 한눈에 파악하기가 어려워서 유지보수하기도 까다롭거든요.

검색, 개수 세기, 정렬은 프로그래밍에서 정말 숨 쉬듯이 자주 하는 작업입니다. 그래서 C++ 표준 라이브러리(Standard Library)는 이런 귀찮은 작업들을 단 몇 줄의 코드만으로 끝낼 수 있도록 미리 만들어진 유용한 함수들의 묶음을 제공합니다. 게다가 이 함수들은 전문가들이 이미 꼼꼼하게 테스트해 두어서 안전하고, 속도도 엄청 빠르며, 여러 종류의 데이터 상자(컨테이너)에서 모두 사용할 수 있습니다. 심지어 일꾼(CPU 스레드) 여러 명을 동시에 투입해서 작업을 더 빨리 끝내는 '병렬 처리'를 지원하는 함수도 많답니다!

이런 '알고리즘 라이브러리'가 제공하는 기능은 크게 세 가지로 나눌 수 있어요.

• 검사기 (Inspectors): 데이터 상자 안을 들여다보기만 할 때 씁니다 (데이터를 수정하진 않아요). 검색이나 개수 세기가 여기 속합니다.
• 변경기 (Mutators): 데이터 상자 안의 데이터를 지지고 볶고 수정할 때 씁니다. 정렬하거나 순서를 마구 섞는 작업이 있죠.
• 도우미 (Facilitators): 데이터 값들을 바탕으로 새로운 결과를 만들어 낼 때 씁니다. 값들을 곱해주는 기능이나, 요소들을 어떤 순서로 정렬할지 심판을 봐주는 기능 등이 있어요.

이런 꿀 기능들은 <algorithm>이라는 라이브러리 안에 살고 있습니다. 이번 레슨에서는 가장 자주 쓰이는 친구들 몇 명을 만나볼 거예요. 하지만 이 외에도 정말 무궁무진한 기능이 있으니, 나중에 공식 문서를 한번 쭉 읽어보시면서 어떤 마법 같은 기능들이 더 있는지 구경해 보시길 추천합니다!

(참고: 이 함수들은 모두 '반복자(iterator)'라는 것을 사용해서 작동합니다. 반복자가 아직 어색하시다면, 이전 레슨인 '18.2 -- 반복자 소개'를 먼저 가볍게 복습하고 오시면 훨씬 이해가 쉬울 거예요!)

std::find를 사용해서 값으로 요소 찾기

std::find는 상자(컨테이너) 안에서 우리가 찾는 값이 처음으로 나타나는 위치를 콕 집어 찾아줍니다. 이 함수를 부르려면 세 가지 준비물이 필요해요.

1) 검색을 시작할 위치, 2) 검색을 끝낼 위치, 그리고 3) 내가 찾고 싶은 값입니다.

만약 값을 찾으면 그 값이 있는 위치를 가리키는 '반복자'를 돌려주고, 끝까지 다 뒤져도 못 찾으면 상자의 맨 끝(end)을 가리키는 반복자를 돌려줍니다.

예를 들어볼까요?

#include <algorithm>
#include <array>
#include <iostream>

int main()
{
    std::array arr{ 13, 90, 99, 5, 40, 80 };

    std::cout << "Enter a value to search for and replace with: ";
    int search{};
    int replace{};
    std::cin >> search >> replace;

    // 입력값 검증은 생략했습니다

    // std::find는 찾은 요소(또는 컨테이너의 끝)를 가리키는 반복자를 반환합니다.
    // (이 반복자의 정확한 타입은 굳이 신경 쓰지 않아도 되므로) 
    // auto를 사용해서 변수에 편하게 저장할게요.
    auto found{ std::find(arr.begin(), arr.end(), search) };

    // 알고리즘이 찾으려는 값을 찾지 못하면 '끝(end) 반복자'를 반환합니다.
    // end() 멤버 함수를 호출해서 이것과 똑같은지 비교해 볼 수 있어요.
    if (found == arr.end())
    {
        std::cout << "Could not find " << search << '\n';
    }
    else
    {
        // 찾은 요소의 값을 새 값으로 덮어씁니다.
        *found = replace;
    }

    for (int i : arr)
    {
        std::cout << i << ' ';
    }

    std::cout << '\n';

    return 0;
}

값을 무사히 찾았을 때의 실행 결과: Enter a value to search for and replace with: 5 234 13 90 99 234 40 80

값을 찾지 못했을 때의 실행 결과: Enter a value to search for and replace with: 0 234 Could not find 0 13 90 99 5 40 80

std::find_if를 사용해서 조건에 맞는 요소 찾기

가끔은 정확히 똑같은 값이 아니라, "이 글자가 포함된 단어가 있나?"처럼 특정 조건을 만족하는 값이 있는지 찾고 싶을 때가 있습니다. 이럴 때는 std::find_if가 아주 딱 맞습니다.

std::find_if는 std::find와 일하는 방식은 비슷한데, 찾고 싶은 '값'을 넘겨주는 대신 '함수'를 넘겨준다는 게 다릅니다. 배열의 요소들을 하나하나 훑어보면서 이 함수에 값을 던져주는데요, 함수가 "어? 이거 조건에 맞네!" 하고 true(참)를 외치면 찾은 것으로 간주하고, 아니면 false(거짓)를 외치고 다음 요소로 넘어가는 식입니다. (나중에 배울 '람다'라는 걸 쓸 수도 있어요.)

아래 예제는 문자열 안에 "nut"이라는 글자가 들어있는 요소가 있는지 std::find_if로 찾아보는 코드입니다.

#include <algorithm>
#include <array>
#include <iostream>
#include <string_view>

// 요소가 조건에 맞으면 true를 반환하는 함수입니다.
bool containsNut(std::string_view str)
{
    // std::string_view::find는 부분 문자열을 찾지 못하면 std::string_view::npos를 반환합니다.
    // 찾았다면 str 안에서 해당 부분 문자열이 시작하는 위치(인덱스)를 반환하죠.
    return str.find("nut") != std::string_view::npos;
}

int main()
{
    std::array<std::string_view, 4> arr{ "apple", "banana", "walnut", "lemon" };

    // 배열을 쭉 훑어보면서 "nut"이라는 부분 문자열이 포함된 요소가 있는지 확인합니다.
    auto found{ std::find_if(arr.begin(), arr.end(), containsNut) };

    if (found == arr.end())
    {
        std::cout << "No nuts\n";
    }
    else
    {
        std::cout << "Found " << *found << '\n';
    }

    return 0;
}

출력 결과: Found walnut

만약 이 작업을 라이브러리 없이 직접 짜야 했다면, 배열을 훑는 반복문 하나에, 문자열을 비교하는 반복문 두 개까지... 최소 3개의 반복문을 겹겹이 써야 했을 겁니다. 표준 라이브러리를 쓰면 이렇게 단 몇 줄로 깔끔하게 해결됩니다!

std::count와 std::count_if를 사용해서 개수 세기

이름만 봐도 딱 아시겠죠? std::count와 std::count_if는 특정 값이나 특정 조건에 맞는 요소가 총 몇 개 있는지를 세어주는 착한 함수들입니다.

다음 예제에서는 "nut"이라는 글자가 포함된 요소가 모두 몇 개인지 세어볼게요.

#include <algorithm>
#include <array>
#include <iostream>
#include <string_view>

bool containsNut(std::string_view str)
{
    return str.find("nut") != std::string_view::npos;
}

int main()
{
    std::array<std::string_view, 5> arr{ "apple", "banana", "walnut", "lemon", "peanut" };

    auto nuts{ std::count_if(arr.begin(), arr.end(), containsNut) };

    std::cout << "Counted " << nuts << " nut(s)\n";

    return 0;
}

출력 결과: Counted 2 nut(s)

std::sort를 사용해서 내 맘대로 정렬하기

예전 레슨에서 배열을 작은 수부터 큰 수로(오름차순) 예쁘게 줄 세울 때 std::sort를 써보셨을 거예요. 그런데 std::sort는 그것보다 훨씬 똑똑합니다. std::sort의 세 번째 준비물로 우리가 직접 만든 '함수'를 끼워 넣어 주면, 우리가 원하는 어떤 방식으로든 맘대로 줄을 세울 수 있거든요.

이 함수는 두 개의 값을 비교해서, 첫 번째 값이 두 번째 값보다 더 앞에 서야 한다면 true를 반환하도록 규칙을 정해주면 됩니다. (기본적으로 std::sort는 아무것도 안 알려주면 알아서 오름차순으로 줄을 세웁니다.)

그럼 이번에는 반대로, 큰 수부터 작은 수로(내림차순) 정렬해 볼까요? greater라는 우리만의 비교 규칙 함수를 만들어서 써보겠습니다.

#include <algorithm>
#include <array>
#include <iostream>

bool greater(int a, int b)
{
    // a가 b보다 크면 a를 b보다 앞에 배치합니다 (내림차순 정렬).
    return (a > b);
}

int main()
{
    std::array arr{ 13, 90, 99, 5, 40, 80 };

    // 우리가 만든 greater 함수를 std::sort에 넘겨줍니다.
    std::sort(arr.begin(), arr.end(), greater);

    for (int i : arr)
    {
        std::cout << i << ' ';
    }

    std::cout << '\n';

    return 0;
}

출력 결과: 99 90 80 40 13 5

이것도 마찬가지로 머리 아프게 정렬 반복문을 직접 만들 필요 없이, 단 몇 줄만으로 내 맘대로 정렬을 끝냈습니다!

그런데 여기서 조금 헷갈리실 수 있는 부분! 우리가 만든 greater 함수는 2개의 재료(인수)가 필요한데, 코드에서는 괄호 ()도 없이 이름만 달랑 적어줬죠? 값은 대체 어디서 가져온 걸까요? 함수 이름 뒤에 괄호를 빼고 적으면, 이건 함수를 당장 실행하라는 게 아니라 "이 함수가 여깄어~" 하고 위치만 가리키는 함수 포인터가 됩니다. 예전에 함수를 괄호 없이 출력하려고 했을 때 화면에 이상하게 "1"이라고 찍혔던 거 기억하시나요? std::sort는 이 포인터를 가지고 있다가, 자기가 알아서 배열 안의 두 요소를 쏙쏙 뽑아 greater 함수에 넣고 실행해 보는 겁니다. std::sort가 속에서 어떤 정렬 방식을 쓰는지 우리는 모르기 때문에, 어떤 두 요소가 비교될지는 그때그때 다릅니다. (이 '함수 포인터'에 대해서는 나중 챕터에서 더 자세히 다룰 거니까 너무 걱정하지 마세요!)

std::for_each를 사용해서 모든 요소에 작업 수행하기

std::for_each는 리스트를 넘겨받아서, 그 안에 있는 모든 요소 하나하나에 똑같은 함수를 실행시켜 줍니다. 리스트에 있는 모든 숫자를 두 배로 뻥튀기하고 싶거나 할 때 아주 유용하죠.

배열의 모든 숫자를 두 배로 만드는 예제를 볼까요?

#include <algorithm>
#include <array>
#include <iostream>

void doubleNumber(int& i)
{
    i *= 2;
}

int main()
{
    std::array arr{ 1, 2, 3, 4 };

    std::for_each(arr.begin(), arr.end(), doubleNumber);

    for (int i : arr)
    {
        std::cout << i << ' ';
    }

    std::cout << '\n';

    return 0;
}

출력 결과: 2 4 6 8

처음 프로그래밍을 배우시는 분들은 여기서 "어? 그냥 범위 기반 for문(range-based for-loop) 쓰면 코드도 더 짧고 편한데 굳이 이 복잡해 보이는 걸 왜 쓰지?" 하고 의아해하실 수 있습니다. 하지만 std::for_each만의 숨겨진 강력한 장점들이 있습니다. 두 방식을 비교해 볼게요.

std::ranges::for_each(arr, doubleNumber); // C++20부터는 begin()과 end()를 쓰지 않아도 됩니다.
// std::for_each(arr.begin(), arr.end(), doubleNumber); // C++20 이전 방식

for (auto& i : arr)
{
    doubleNumber(i);
}

std::for_each를 쓰면, 코드를 읽는 사람에게 "나는 arr의 모든 요소에 doubleNumber 작업을 할 거야!"라는 내 의도를 아주 또렷하게 보여줄 수 있습니다. 반면 for문은 i라는 변수를 하나 더 끼워 넣어야 하죠. 이게 별거 아닌 것 같아 보여도, 사람이 피곤하거나 깜빡 정신을 놓으면 자잘한 실수들을 만들기 딱 좋습니다. 예를 들어 auto를 안 써서 나도 모르게 타입이 변환되어 버리거나, 참조 기호(&)를 깜빡해서 정작 배열 원본 값은 안 변하고 헛수고를 하거나, doubleNumber에 i가 아닌 다른 엉뚱한 변수를 넣는 실수를 할 수 있죠. std::for_each를 쓰면 구조상 이런 억울한 실수가 아예 일어날 수 없습니다!

게다가 std::for_each는 처음이나 끝부분을 마음대로 건너뛰고 실행할 수도 있습니다. 예를 들어 첫 번째 요소는 빼고 두 배로 만들고 싶다면, std::next를 써서 시작 위치를 한 칸 밀어버리면 됩니다.

std::for_each(std::next(arr.begin()), arr.end(), doubleNumber);
// 이제 배열은 [1, 4, 6, 8]이 됩니다. 첫 번째 요소인 1은 두 배가 되지 않았어요.

보통의 범위 기반 for문으로는 이렇게 부분만 쏙 골라서 실행하기가 꽤 번거롭습니다.

가장 중요한 차이점은 속도입니다. std::for_each는 다른 알고리즘들처럼 여러 작업을 동시에 해치우는 병렬 처리가 가능하기 때문에, 다뤄야 할 데이터가 엄청나게 많거나 대규모 프로젝트를 할 때는 단순 for문보다 훨씬 처리 속도가 빠릅니다.

성능과 실행 순서

알고리즘 라이브러리에 있는 기능들은 대체로 "나는 최소한 이 정도 속도는 낼 거야!" 라거나 "나는 꼭 이 순서대로 실행할 거야!" 하는 약속(보장)을 가지고 있습니다. 예를 들어 std::for_each는 각 요소에 딱 한 번씩만 들르고, 무조건 맨 앞에서부터 순서대로 차근차근 실행하겠다고 굳게 약속합니다.

대부분의 알고리즘이 속도 보장은 해주지만, 실행 순서까지 확고하게 보장해 주는 알고리즘은 생각보다 많지 않습니다. 그래서 '당연히 차례대로 실행되겠지?' 하고 우리 마음대로 넘겨짚고 코드를 짜면 위험합니다. 예를 들어 첫 번째 값에는 1을 곱하고, 두 번째에는 2를 곱하고, 세 번째는 3을 곱하는 식으로 순서가 절대적으로 중요한 작업을 해야 한다면, 반드시 '순차적 실행'을 보장하는 알고리즘만 골라서 써야 합니다!

순서대로 얌전히 실행될 것을 보장하는 알고리즘 삼총사는 std::for_each, std::copy, std::copy_backward, std::move, std::move_backward가 있습니다. (물론 '순방향 반복자'라는 걸 쓰는 다른 많은 알고리즘들도 구조상 자연스럽게 순서대로 실행되긴 합니다.)

권장 사항 특정 알고리즘을 사용하기 전에, 내가 지금 하려는 작업이 속도나 실행 순서가 중요한지, 그리고 이 알고리즘이 그걸 만족시켜 주는지 꼭 한번 체크하는 습관을 들이세요!

C++20의 범위 (Ranges)

알고리즘을 쓸 때마다 arr.begin()이랑 arr.end()를 꼬박꼬박 타자 치기, 솔직히 너무 귀찮고 손가락 아프지 않으셨나요? 걱정하지 마세요! C++20부터는 범위(ranges)라는 멋진 기능이 추가되어서, 그냥 arr 하나만 툭 던져줘도 똑같이 작동합니다. 덕분에 코드가 훨씬 짧아지고 읽기도 편해졌답니다.

결론

알고리즘 라이브러리는 우리 코드를 훨씬 단순하고, 실수 없이 튼튼하게 만들어주는 마법 같은 도구 상자입니다. 이번 레슨에서는 그중 아주 일부분만 살짝 맛보았지만, 이 함수들은 일하는 방식이 다들 비슷비슷하기 때문에 원리 몇 가지만 익혀두시면 다른 기능들도 금방 가져다 쓰실 수 있을 거예요.

참고로... 이 비디오에서 라이브러리에 있는 다양한 알고리즘들을 아주 깔끔하게 정리해서 설명해 주니, 시간이 나실 때 꼭 한번 시청해 보세요.

권장 사항 직접 반복문을 짜면서 고생하기보다는, 내가 하려는 작업과 똑같은 기능을 하는 함수가 알고리즘 라이브러리에 있는지 먼저 찾아보고 적극적으로 활용해 보세요!

18.4 — 코드 실행 시간 측정하기

코드를 짜다 보면, "이 방법이랑 저 방법 중에 어느 쪽이 더 빠를까?" 하고 궁금해질 때가 있죠. 그걸 어떻게 알 수 있을까요?

가장 쉬운 방법은 코드가 실행되는 데 걸리는 시간을 직접 재보는 것입니다. C++11 버전부터는 chrono라는 라이브러리 안에 시간을 잴 수 있는 도구들이 들어있어요. 하지만 이 chrono 라이브러리를 있는 그대로 쓰기엔 조금 복잡하고 어렵게 느껴질 수 있습니다.

다행히도 좋은 소식이 하나 있어요! 우리가 필요한 시간 측정 기능들만 쏙쏙 뽑아서, 앞으로 우리 프로그램에서 쉽게 꺼내 쓸 수 있도록 하나의 '클래스(class)'로 깔끔하게 포장해 둘 수 있답니다.

바로 이 클래스입니다.

#include <chrono> // std::chrono 함수들을 사용하기 위해 포함

class Timer
{
private:
    // 복잡한 타입 이름을 쉽게 쓰기 위해 별칭(alias) 만들기
    using Clock = std::chrono::steady_clock;
    using Second = std::chrono::duration<double, std::ratio<1> >;

    std::chrono::time_point<Clock> m_beg { Clock::now() };

public:
    void reset()
    {
        m_beg = Clock::now();
    }

    double elapsed() const
    {
        return std::chrono::duration_cast<Second>(Clock::now() - m_beg).count();
    }
};

이게 전부입니다! 사용 방법도 정말 간단해요. main 함수 맨 위(혹은 시간 측정을 시작하고 싶은 곳)에 Timer 객체를 하나 만들어 주기만 하면 됩니다. 그러고 나서 프로그램이 거기까지 실행되는 데 얼마나 걸렸는지 알고 싶을 때마다 elapsed()라는 함수를 불러주면 된답니다.

#include <iostream>

int main()
{
    Timer t;

    // 시간을 측정할 코드를 여기에 넣으세요

    std::cout << "걸린 시간: " << t.elapsed() << " 초\n";

    return 0;
}

자, 이제 숫자 10,000개가 들어있는 배열을 정렬하는 실제 예제에 이 타이머를 사용해 볼까요? 먼저, 우리가 이전 장에서 직접 만들었던 '선택 정렬(selection sort)' 방식을 써보겠습니다.

#include <array>
#include <chrono> // std::chrono 함수들을 사용하기 위해 포함
#include <cstddef> // std::size_t를 사용하기 위해 포함
#include <iostream>
#include <numeric> // std::iota를 사용하기 위해 포함

const int g_arrayElements { 10000 };

class Timer
{
private:
    // 복잡한 타입 이름을 쉽게 쓰기 위해 별칭(alias) 만들기
    using Clock = std::chrono::steady_clock;
    using Second = std::chrono::duration<double, std::ratio<1> >;

    std::chrono::time_point<Clock> m_beg{ Clock::now() };

public:
    void reset()
    {
        m_beg = Clock::now();
    }

    double elapsed() const
    {
        return std::chrono::duration_cast<Second>(Clock::now() - m_beg).count();
    }
};

void sortArray(std::array<int, g_arrayElements>& array)
{
    // 배열의 각 요소를 하나씩 확인합니다 
    // (마지막 요소는 이미 정렬되어 있을 테니 제외합니다)
    for (std::size_t startIndex{ 0 }; startIndex < (g_arrayElements - 1); ++startIndex)
    {
        // smallestIndex는 이번 반복에서 찾은 가장 작은 값의 위치(인덱스)입니다.
        // 일단 현재 시작 위치의 값이 가장 작다고 가정하고 시작합니다.
        std::size_t smallestIndex{ startIndex };

        // 그런 다음 배열의 나머지 부분에서 더 작은 값이 있는지 찾아봅니다.
        for (std::size_t currentIndex{ startIndex + 1 }; currentIndex < g_arrayElements; ++currentIndex)
        {
            // 만약 지금까지 찾은 가장 작은 값보다 더 작은 값을 발견했다면
            if (array[currentIndex] < array[smallestIndex])
            {
                // 그 위치를 기억해 둡니다.
                smallestIndex = currentIndex;
            }
        }

        // 이제 smallestIndex는 남은 배열 중 가장 작은 값을 가리킵니다.
        // 시작 위치의 값과 가장 작은 값을 서로 바꿉니다 (이렇게 해서 알맞은 자리에 정렬합니다).
        std::swap(array[startIndex], array[smallestIndex]);
    }
}

int main()
{
    std::array<int, g_arrayElements> array;
    std::iota(array.rbegin(), array.rend(), 1); // 배열을 10000부터 1까지의 역순 숫자로 채웁니다

    Timer t;

    sortArray(array);

    std::cout << "걸린 시간: " << t.elapsed() << " 초\n";

    return 0;
}

원작자의 컴퓨터에서 3번 실행해 본 결과, 0.0507초, 0.0506초, 0.0498초가 나왔다고 합니다. 대략 0.05초 정도 걸렸다고 볼 수 있겠네요.

그럼 이번에는 C++ 기본 라이브러리에서 제공하는 강력한 도구인 std::sort를 사용해서 똑같이 테스트해 볼까요?

#include <algorithm> // std::sort를 사용하기 위해 포함
#include <array>
#include <chrono> // std::chrono 함수들을 사용하기 위해 포함
#include <cstddef> // std::size_t를 사용하기 위해 포함
#include <iostream>
#include <numeric> // std::iota를 사용하기 위해 포함

const int g_arrayElements { 10000 };

class Timer
{
private:
    // 복잡한 타입 이름을 쉽게 쓰기 위해 별칭(alias) 만들기
    using Clock = std::chrono::steady_clock;
    using Second = std::chrono::duration<double, std::ratio<1> >;

    std::chrono::time_point<Clock> m_beg{ Clock::now() };

public:
    void reset()
    {
        m_beg = Clock::now();
    }

    double elapsed() const
    {
        return std::chrono::duration_cast<Second>(Clock::now() - m_beg).count();
    }
};

int main()
{
    std::array<int, g_arrayElements> array;
    std::iota(array.rbegin(), array.rend(), 1); // 배열을 10000부터 1까지의 역순 숫자로 채웁니다

    Timer t;

    std::ranges::sort(array); // C++20 버전 이상부터 사용 가능
    // 만약 컴파일러가 C++20을 지원하지 않는다면 아래 코드를 사용하세요:
    // std::sort(array.begin(), array.end());

    std::cout << "걸린 시간: " << t.elapsed() << " 초\n";

    return 0;
}

원작자의 컴퓨터에서는 이 코드가 0.000693초, 0.000692초, 0.000699초를 기록했습니다. 평균적으로 대략 0.0007초가 걸렸네요. 다시 말해 이 경우, 표준 라이브러리의 std::sort가 우리가 직접 만든 선택 정렬보다 무려 100배나 더 빠르다는 뜻입니다!

프로그램 성능(속도)에 영향을 미치는 요소들

프로그램 실행 시간을 재는 것 자체는 아주 쉽지만, 그 결과는 꽤 여러 가지 이유로 휙휙 바뀔 수 있어요. 그래서 제대로 측정하는 법과 무엇이 시간에 영향을 주는지 알아두는 게 무척 중요합니다.

1. 디버그(Debug) 모드가 아닌 릴리즈(Release) 모드로 측정하세요. 디버그 모드는 오류를 찾기 쉽게 하려고 코드를 빠르게 만들어주는 '최적화' 기능을 꺼둡니다. 이 때문에 속도 차이가 엄청나게 나요. 원작자 컴퓨터에서 디버그 모드로 std::sort를 실행했더니 무려 33배나 느린 0.0235초가 걸렸다고 합니다!
2. 컴퓨터가 뒤에서 몰래 하고 있는 다른 작업들을 조심하세요. 측정할 때 컴퓨터가 CPU나 메모리, 하드디스크를 무리하게 쓰고 있으면 안 됩니다 (예: 게임 중이거나, 바이러스 검사 중이거나, 몰래 윈도우 업데이트가 깔리는 중일 때). 심지어 그냥 켜둔 인터넷 브라우저가 새 광고를 띄우느라 잠깐 CPU를 100% 써버리는 일도 생겨요. 측정하기 전에 켜져 있는 프로그램을 최대한 다 끄면, 결과가 매번 들쭉날쭉하는 걸 막을 수 있습니다.
3. 랜덤 숫자(난수)를 쓴다면 결과가 달라질 수 있어요. 매번 랜덤 숫자가 다르게 나오면 코드가 일하는 양도 달라집니다. 여러 번 잴 때 항상 비슷한 결과를 얻고 싶다면, 랜덤 숫자를 만드는 공식에 '고정된 시작 값(시드)'을 넣어주세요. 그러면 매번 똑같은 순서로 난수가 나오니까 측정이 편해져요. (다만, 프로그램의 성능 자체가 이 랜덤 숫자에 너무 의존적이라면 이 방법이 오히려 가짜 결과를 보여줄 수도 있으니 주의해야 합니다.)
4. 사용자 입력을 기다리는 시간은 빼고 재야 합니다. 사용자 이름이나 비밀번호를 입력하라고 기다리는 시간은 프로그램 성능과 아무 상관이 없겠죠? 입력이 필요하다면 측정 중에는 사람이 타이핑하지 않게, 코드가 자동으로 입력값을 가져오도록 살짝 바꿔서 재는 것이 좋습니다.

성능 측정하는 방법

내 프로그램의 진짜 성능을 알아보려면 최소한 3번 이상 측정해 보세요. 3번 다 결과가 비슷하게 나온다면, 그게 현재 컴퓨터에서 내 프로그램이 내는 진짜 속도라고 볼 수 있습니다. 만약 결과가 중구난방이라면, 비슷한 숫자들이 모일 때까지 여러 번 더 재보셔야 해요 (그리고 유독 튀는 숫자가 나왔다면 왜 그런지 이유를 파악해야 합니다). 보통 컴퓨터가 뒤에서 다른 짓을 하느라 한두 번씩 엄청 늦게 끝나는 '튀는 값(outlier)'이 나오는 건 흔한 일입니다.

계속 재봤는데도 결과가 들쭉날쭉하다면, 컴퓨터의 다른 프로그램들이 크게 방해하고 있거나 내 프로그램 안의 무작위적인 요소(랜덤) 때문일 확률이 큽니다.

프로그램 속도는 컴퓨터 사양, 운영체제, 켜져 있는 다른 앱 등 정말 많은 것들에 영향을 받아요. 그래서 "내 프로그램은 10초 만에 끝난다!" 같은 '절대적인 시간'은 남의 컴퓨터에서는 별 의미가 없습니다. 남의 컴퓨터에선 1초가 될 수도, 1분이 될 수도 있거든요. 직접 테스트해 보기 전엔 모르는 일이죠.

하지만 내 컴퓨터 하나에서 하는 '상대적인 비교'는 아주 쓸모가 많습니다. 어떤 코드를 A 방법으로 짰을 때는 10초 걸리고, B 방법으로 짰을 때는 8초 걸렸다면, 다른 컴퓨터에서도 시간 수치 자체는 다르겠지만 결국 B 방법이 더 빠를 거라는 사실은 변함이 없으니까요.

가장 확실하게 비교하는 꿀팁을 하나 드릴게요. B 방법을 다 재보고 난 뒤에, 다시 처음의 A 방법을 한번 더 재보는 겁니다. 만약 다시 잰 A 방법이 맨 처음 잰 10초와 똑같이 나온다면, 컴퓨터 상태가 일정했다는 뜻이니 안심하고 'B가 더 빠르다'라고 결론 내릴 수 있습니다. 하지만 만약 A 방법의 시간이 갑자기 달라졌다면? 방금 내 컴퓨터에 무슨 일이 생겨서 성능에 영향을 줬다는 뜻이에요. 이럴 때는 그동안 측정한 결과를 다 버리고 처음부터 다시 꼼꼼하게 측정하는 것이 좋습니다.

이전 16.1 레슨에서 컨테이너와 배열에 대해 처음 배웠었죠. 핵심만 아주 간단하게 다시 짚어볼게요!

• 컨테이너(Container) 는 이름이 없는 여러 개의 데이터(원소라고 부름)를 한꺼번에 담아두는 '보관함' 같은 역할을 해요.
• 배열(Array) 은 이 데이터들을 메모리 공간에 빈틈없이 일렬로 나란히 저장해요. 그리고 각 자리에 번호(인덱스)가 있어서 원하는 데이터를 아주 빠르게 바로바로 꺼낼 수 있습니다.
• C++에서 가장 자주 쓰이는 배열 종류는 크게 세 가지예요: std::vector, std::array, 그리고 아주 옛날 방식인 C스타일 배열이죠.

그리고 16.10 레슨에서, 배열은 크게 두 가지 종류로 나뉜다고 했어요.

• 고정 크기 배열 (Fixed-size arrays): 말 그대로 크기가 고정된 배열이에요. 배열을 처음 만들 때 크기를 몇 개로 할지 반드시 정해둬야 하고, 나중에 크기를 늘리거나 줄일 수 없어요. C스타일 배열과 오늘 배울 std::array 가 여기에 속해요.
• 동적 배열 (Dynamic arrays): 프로그램이 실행되는 도중에 고무줄처럼 크기를 자유롭게 늘리거나 줄일 수 있는 배열이에요. std::vector 가 바로 이 동적 배열이랍니다.

이전 장에서는 주로 std::vector 에 대해 배웠어요. 빠르고, 쓰기 편하고, 기능도 다양해서 우리가 배열이 필요할 때 가장 먼저 찾는 아주 훌륭한 도구죠.

"그럼 무조건 융통성 있는 동적 배열만 쓰면 안 되나요?"

동적 배열은 확실히 강력하고 편리하지만, 세상 모든 일이 그렇듯 장점이 있으면 살짝 양보해야 하는 부분(Tradeoff)도 있기 마련이에요.

1. std::vector 는 크기가 딱 고정된 배열보다 속도가 아주 살짝 느립니다. (물론 코드를 비효율적으로 짜서 배열 크기를 계속 늘렸다 줄였다 하는 게 아니라면, 아마 체감하기 힘들 정도로 미미한 차이이긴 해요.)
2. std::vector 는 constexpr (컴파일할 때 값이 영원히 고정되는 완벽한 상수) 기능을 아주 제한적인 상황에서만 쓸 수 있어요.

최신 C++(모던 C++)에서는 바로 이 두 번째 이유가 핵심이에요! constexpr 배열을 사용하면 코드가 훨씬 더 단단해지고 오류가 줄어들며, 컴파일러가 코드를 알아서 엄청나게 최적화해 줄 수 있거든요. 따라서 constexpr 배열을 쓸 수 있는 상황이라면 무조건 써야 하고, 그럴 때 바로 우리가 써야 할 컨테이너가 std::array 인 것입니다!

권장 사항 값이 변하지 않는 constexpr 배열을 만들 때는 std::array 를 사용하고, 그 외의 일반적인 경우에는 std::vector 를 사용하세요.

std::array 만들기

std::array 를 쓰려면 <array> 헤더 파일을 불러와야 해요. 애초에 std::vector 와 비슷하게 작동하도록 만들어졌기 때문에, 써보시면 둘이 서로 다른 점보다는 비슷한 점이 훨씬 많다는 걸 알게 되실 거예요.

하지만 처음 만들 때의 모습은 살짝 다릅니다:

#include <array>  // std::array를 쓰기 위해 필요해요
#include <vector> // std::vector를 쓰기 위해 필요해요

int main()
{
    std::array<int, 5> a {};  // 5개의 int 데이터를 담는 std::array

    std::vector<int> b(5);    // 5개의 int 데이터를 담는 std::vector (비교용이에요)

    return 0;
}

우리가 만든 std::array 의 선언을 보면 꺾쇠 < > 안에 두 가지 정보(템플릿 인자)가 들어갑니다. 첫 번째인 int 는 이 배열 안에 어떤 종류의 데이터 를 넣을지 정해주는 것이고, 두 번째인 5 는 배열의 길이(크기) 를 딱 정해주는 숫자입니다.

std::array 의 길이는 반드시 상수 표현식 이어야 해요

프로그램 실행 중에 마음대로 크기를 바꿀 수 있는 std::vector 와는 다르게, std::array 의 길이는 프로그램이 실행되기 전(컴파일 단계)에 이미 확실히 정해져 있는 상수 표현식 이어야 해요. 주로 그냥 숫자(정수 리터럴)를 바로 쓰거나, constexpr 변수, 또는 열거형(enum) 값을 사용해서 길이를 정해줍니다.

#include <array>

int main()
{
    std::array<int, 7> a {}; // 평범한 숫자(리터럴)를 사용했어요

    constexpr int len { 8 };
    std::array<int, len> b {}; // constexpr 변수를 사용했어요

    enum Colors
    {
         red,
         green,
         blue,
         max_colors
    };

    std::array<int, max_colors> c {}; // 열거형(enum) 값을 사용했어요

#define DAYS_PER_WEEK 7
    std::array<int, DAYS_PER_WEEK> d {}; // 매크로를 사용했어요 (이렇게 쓰지 말고 constexpr 변수를 쓰세요!)

    return 0;
}

주의할 점은, 실행 중에 값이 바뀔 수 있는 일반 변수나 매개변수 등은 길이로 쓸 수 없다는 거예요!

#include <array>
#include <iostream>

void foo(const int length) // length는 프로그램 실행 중에 값이 결정되는 상수예요
{
    std::array<int, length> e {}; // 에러: length는 컴파일러가 미리 알 수 있는 상수 표현식이 아니에요!
}

int main()
{
    // const가 아닌 일반 변수를 사용하는 경우
    int numStudents{};
    std::cin >> numStudents; // 사용자에게 값을 입력받으므로 값이 바뀔 수 있죠

    std::array<int, numStudents> {}; // 에러: numStudents는 상수 표현식이 아니에요!

    foo(7);

    return 0;
}

주의하세요! 의아하게 들릴 수 있지만, 길이가 0인 std::array 도 만들 수 있어요.

#include <array>
#include <iostream>

int main()
{
    std::array<int, 0> arr {}; // 길이가 0인 std::array를 만들어요
    std::cout << arr.empty();  // arr의 길이가 0이면 true가 나옵니다

    return 0;
}

길이가 0인 std::array 는 데이터가 아예 없는 아주 특별한 케이스예요. 만약 빈 배열인데 실수로 안의 데이터에 접근하려고 시도하면(예: arr[0]) 프로그램이 꼬여버리는 치명적인 오류(미정의 동작)가 발생합니다. 배열이 텅 비었는지 확인하고 싶을 때는 empty() 라는 함수를 쓰면 안전하게 확인할 수 있어요.

std::array 값 채워넣기 (초기화)

조금 특이하게도 std::array 에는 '생성자'라는 복잡한 기능이 없어요. 대신 데이터를 담는 순수한 바구니(집합체, Aggregate) 취급을 받기 때문에 집합체 초기화 라는 단순한 방식을 씁니다. 어렵게 생각할 것 없이, 중괄호 {} 안에 쉼표로 값을 쭉 나열해서 한 번에 초기화하는 방식이에요.

#include <array>

int main()
{
    std::array<int, 6> fibonnaci = { 0, 1, 1, 2, 3, 5 }; // 중괄호를 사용한 복사 리스트 초기화 방식
    std::array<int, 5> prime { 2, 3, 5, 7, 11 };         // 중괄호를 사용한 직접 리스트 초기화 방식 (이 방식을 추천해요!)

    return 0;
}

이렇게 하면 배열의 0번째 칸부터 순서대로 우리가 적은 값들이 쏙쏙 들어갑니다.

만약 아무 값도 안 넣어주면 어떻게 될까요? 기본값으로 알아서 비워지는데, 문제는 컴퓨터 메모리 특성상 이전에 쓰던 '쓰레기값'이 남아있을 수 있다는 거예요. 그래서 안전하게 처음부터 모든 칸을 깔끔하게 '0'으로 비우고 싶다면, 텅 빈 중괄호 {} 를 써서 '값 초기화'를 해주는 것이 가장 좋습니다.

#include <array>
#include <vector>

int main()
{
    std::array<int, 5> a;   // 기본 초기화 (int 자리들에 쓰레기값이 남아있을 수 있어요)
    std::array<int, 5> b{}; // 값 초기화 (모든 int 자리가 깔끔하게 0으로 채워져요) (이 방식을 추천해요!)

    std::vector<int> v(5);  // 값 초기화 (모든 int 자리가 깔끔하게 0으로 채워져요) (비교용이에요)

    return 0;
}

배열 크기보다 숫자를 너무 많이 적어 넣으면 컴파일러가 에러를 냅니다. 반대로 크기보다 숫자를 적게 넣으면, 우리가 적어준 것만 채우고 남은 빈자리는 알아서 모두 0으로 깔끔하게 채워준답니다!

#include <array>

int main()
{
    std::array<int, 4> a { 1, 2, 3, 4, 5 }; // 컴파일 에러: 값을 너무 많이 넣었어요!
    std::array<int, 4> b { 1, 2 };          // 남은 자리인 b[2]와 b[3]은 알아서 0으로 채워져요

    return 0;
}

Const 와 Constexpr std::array

std::array 는 내용을 바꿀 수 없는 const 로 만들 수 있어요:

#include <array>

int main()
{
    const std::array<int, 5> prime { 2, 3, 5, 7, 11 };

    return 0;
}

안에 들어있는 데이터 하나하나에 일일이 const 를 붙여주지 않아도, 배열 자체가 통째로 const 이기 때문에 안의 내용물도 자동으로 절대 바꿀 수 없는 상태가 됩니다.

그리고 std::array 는 완벽한 상수인 constexpr 기능도 100% 완벽하게 지원합니다.

#include <array>

int main()
{
    constexpr std::array<int, 5> prime { 2, 3, 5, 7, 11 };

    return 0;
}

이 완벽한 constexpr 지원이 바로 우리가 std::array 를 사용해야 하는 가장 핵심적인 이유입니다.

권장 사항 가능하다면 여러분의 std::array 는 항상 constexpr 로 만드세요. 만약 constexpr 로 만들 수 없는 상황이라면, 차라리 std::vector 를 쓰는 게 나을지 고민해 보는 것이 좋습니다.

똑똑한 컴파일러의 타입 추론 기능 (CTAD) - C++17 이상

C++17 버전부터는 '클래스 템플릿 인자 추론(CTAD)' 이라는 똑똑한 기능이 생겼어요. 우리가 괄호 안에 적어준 값들을 보고, 컴파일러가 눈치껏 "아~ 데이터 타입은 이거고, 길이는 이만큼이구나!" 하고 알아서 맞춰주는 기능이에요.

#include <array>
#include <iostream>

int main()
{
    constexpr std::array a1 { 9, 7, 5, 3, 1 }; // 값들을 보고 컴파일러가 알아서 std::array<int, 5> 라고 추론해요
    constexpr std::array a2 { 9.7, 7.31 };     // 값들을 보고 컴파일러가 알아서 std::array<double, 2> 라고 추론해요

    return 0;
}

이 방식이 코드를 훨씬 깔끔하게 만들어주기 때문에 사용할 수 있다면 아주 적극적으로 추천합니다. (단, 오래된 컴파일러를 쓴다면 데이터 타입과 길이를 예전처럼 직접 다 적어주셔야 해요.)

권장 사항 컴파일러가 알아서 타입과 길이를 눈치채도록 CTAD 기능을 적극 활용하세요.

하지만 주의할 점! C++23 기준으로, 타입과 길이 중 하나만 쏙 빼고 하나만 적어주는 건 불가능해요. 둘 다 생략해서 컴파일러에게 전적으로 맡기거나, 아니면 둘 다 꼼꼼히 적어줘야 합니다.

#include <iostream>

int main()
{
    constexpr std::array<int> a2 { 9, 7, 5, 3, 1 };     // 에러: 정보가 부족해요 (길이를 안 적음)
    constexpr std::array<5> a2 { 9, 7, 5, 3, 1 };       // 에러: 정보가 부족해요 (타입을 안 적음)

    return 0;
}

std::to_array 를 써서 길이만 생략하기 - C++20 이상

"타입은 내가 정하고 싶은데, 길이는 일일이 세기 귀찮아!" 할 때가 있죠? C++20부터는 std::to_array 라는 도우미 함수를 쓰면 길이만 생략하는 꼼수를 쓸 수 있어요.

#include <array>
#include <iostream>

int main()
{
    constexpr auto myArray1 { std::to_array<int, 5>({ 9, 7, 5, 3, 1 }) }; // 타입과 크기를 모두 지정해요
    constexpr auto myArray2 { std::to_array<int>({ 9, 7, 5, 3, 1 }) };    // 타입만 지정하고, 크기는 알아서 추론하게 해요
    constexpr auto myArray3 { std::to_array({ 9, 7, 5, 3, 1 }) };         // 타입과 크기를 모두 알아서 추론하게 해요

    return 0;
}

하지만 이 기능은 너무 남발하면 안 돼요. std::to_array 는 임시 배열을 하나 더 만들었다가 옮겨 담는 과정을 거치기 때문에, 그냥 std::array 를 만드는 것보다 컴퓨터가 일을 조금 더 무겁게 해야 하거든요. 반복문 안에서 계속 만들어내야 하거나 속도가 중요한 곳에서는 피하는 게 좋습니다. 꼭 필요한 상황에서만 가끔 쓰는 걸 추천해요.

예를 들면, C++에서는 숫자 뒤에 꼬리표를 붙여서 short 타입이라고 명시하는 방법이 없어요. 이럴 때 일일이 길이를 세서 적지 않고 short 배열을 만들고 싶다면 아주 유용하겠죠.

#include <array>
#include <iostream>

int main()
{
    constexpr auto shortArray { std::to_array<short>({ 9, 7, 5, 3, 1 }) };
    std::cout << sizeof(shortArray[0]) << '\n';

    return 0;
}

operator[] 로 배열 안의 내용 꺼내 보기

std::vector 와 마찬가지로, std::array 에서도 대괄호 [] 기호를 사용하는 게 안의 데이터를 꺼내보는 가장 흔하고 친숙한 방법이에요:

#include <array> // std::array를 쓰기 위해 필요해요
#include <iostream>

int main()
{
    constexpr std::array<int, 5> prime{ 2, 3, 5, 7, 11 };

    std::cout << prime[3]; // 인덱스 번호 3번 자리에 있는 값(7)을 화면에 출력해요
    std::cout << prime[9]; // 잘못된 인덱스 번호예요! (미정의 동작 발생)

    return 0;
}

여기서 꼭 기억해야 할 아주 중요한 점이 있어요! [] 기호는 우리가 배열 범위를 벗어났는지 절대 확인해주지 않는다는 거예요. 위 코드처럼 5칸짜리 배열인데 9번 자리를 달라고 요구하면, 프로그램이 죽거나 이상한 쓰레기값을 가져오는 끔찍한 일(미정의 동작)이 벌어집니다. 항상 내가 가진 배열 크기 안에서만 번호를 부르도록 조심해야 합니다!

17.2 — std::array 길이와 인덱싱

우리는 앞서 std::vector를 배우며 표준 라이브러리 컨테이너들이 길이나 위치를 나타낼 때 '부호 없는 정수(unsigned)'를 사용한다는 사실을 알게 되었습니다. 안타깝게도 std::array 역시 같은 표준 컨테이너 가족이기 때문에, 부호 있는 정수(int)와 함께 사용할 때 발생하는 데이터 타입 불일치 문제를 그대로 안고 있습니다.

이번 레슨에서는 std::array의 길이를 확인하고 특정 위치의 값을 찾는(인덱싱) 방법들을 정리해 보려 합니다. 전체적인 사용법은 std::vector와 매우 비슷해서 익숙한 느낌이 드실 텐데, 여기서 주목해야 할 std::array만의 독보적인 장점은 바로 constexpr을 완벽하게 지원한다는 점입니다.

std::array는 프로그램이 실행되기 전인 컴파일 단계에서 이미 모든 크기와 값이 고정되는 '컴파일 타임 상수'로 다룰 수 있습니다. 여기서 우리가 기억해야 할 중요한 규칙이 하나 등장합니다. 원래 부호가 있는 값을 부호 없는 값으로 변환할 때는 데이터가 잘려 나갈 위험 때문에 컴파일러가 엄격하게 굴지만, 그 값이 constexpr일 때는 예외적으로 너그러워집니다.

즉, 컴파일러가 미리 계산해 보고 "이 값은 데이터 손실 위험이 없는 안전한 양수다"라고 확신할 수 있다면, 우리가 복잡한 형변환을 거치지 않아도 훨씬 유연하게 코드를 작성할 수 있게 해줍니다. 이 특성을 잘 활용하면 std::array를 다룰 때 발생하는 번거로운 인덱스 문제들을 훨씬 스마트하게 해결할 수 있습니다.

std::array의 길이는 std::size_t 타입이에요

std::array 는 템플릿 구조체라는 형태로 만들어져 있고, 대략 이렇게 생겼습니다:

template<typename T, std::size_t N> // N은 타입이 아닌(non-type) 템플릿 매개변수입니다
struct array;

보시다시피, 배열의 길이(N)를 나타내는 매개변수는 std::size_t 타입을 사용해요. 이제는 잘 아시겠지만, std::size_t 는 아주 커다란 '부호 없는 정수(unsigned)' 타입이랍니다.

따라서 우리가 std::array 를 만들 때, 길이를 나타내는 값은 반드시 std::size_t 타입이거나 std::size_t 로 변신할 수 있는 값이어야 해요. 다행히 이 길이는 무조건 constexpr (컴파일 시점에 미리 확정되는 상수)이어야만 합니다. 그래서 우리가 평범한 정수(음수/양수 모두 되는 signed)를 적어 넣더라도, 컴파일러가 알아서 아무런 에러 없이 컴파일 시점에 std::size_t 로 안전하게 둔갑시켜 줍니다. 데이터 손실 경고 같은 건 걱정 안 하셔도 돼요!

참고로 알아두면 좋은 팁... C++23 이전에는 C++에 std::size_t 를 콕 집어 표현하는 숫자 꼬리표(리터럴 접미사)가 아예 없었어요. 보통은 일반 정수(int)를 써도 컴파일러가 알아서 std::size_t 로 잘 바꿔주기 때문에 굳이 필요가 없었거든요. 이 꼬리표는 주로 타입을 자동으로 추론할 때 쓰라고 추가된 거예요. 예를 들어 constexpr auto x { 0 } 이라고 쓰면 컴퓨터는 이걸 std::size_t 가 아니라 평범한 int 로 생각해 버려요. 이럴 때 굳이 길고 복잡하게 static_cast 를 쓰지 않고도, 그냥 0 (int) 과 0UZ (std::size_t) 를 예쁘게 구분해서 쓸 수 있게 해주는 아주 유용한 기능이랍니다.

std::array의 길이와 인덱스는 size_type 인데, 이건 언제나 std::size_t 예요

std::vector 와 마찬가지로, std::array 안에는 size_type 이라는 별명이 숨어 있어요. 이 별명은 배열의 길이나 위치(인덱스)를 나타낼 때 쓰이는 타입을 부르는 말이에요. std::array 의 경우, 이 size_type 은 언제나 std::size_t 를 가리키는 별명입니다.

눈여겨볼 점은, std::array 의 길이를 정의하는 템플릿 부분에는 size_type 이 아니라 std::size_t 라고 대놓고 적혀 있다는 거예요. 왜냐하면 size_type 은 std::array 가 만들어지고 나서야 그 안에 생기는 별명인데, 템플릿을 정의하는 저 시점에서는 아직 그 별명이 존재하지 않거든요. 딱 저곳에서만 std::size_t 를 직접 쓰고, 나머지 모든 곳에서는 size_type 을 사용한답니다.

std::array의 길이 구하기

std::array 의 길이를 알아내는 데는 보통 3가지 흔한 방법이 쓰여요.

첫 번째, std::array 객체에게 직접 size() 함수를 써서 길이를 물어보는 방법이에요. (부호 없는 size_type 으로 길이를 알려줍니다.)

#include <array>
#include <iostream>

int main()
{
    constexpr std::array arr { 9.0, 7.2, 5.4, 3.6, 1.8 };
    std::cout << "length: " << arr.size() << '\n'; // 길이를 size_type 타입 (std::size_t의 별명) 으로 반환합니다

    return 0;
}

출력 결과는 다음과 같아요: length: 5

참고로, 글자 길이를 잴 때 length() 와 size() 라는 똑같은 기능의 함수를 두 개나 가지고 있는 문자열(std::string) 친구들과는 달리, std::array (그리고 대부분의 다른 C++ 컨테이너들)는 오직 size() 하나만 가지고 있답니다.

두 번째, C++17부터는 컨테이너 밖에서 쓰는 std::size() 라는 일반 함수를 쓸 수 있어요. (이것도 결국 내부적으로는 첫 번째 방법을 호출해서 부호 없는 size_type 으로 돌려줍니다.)

#include <array>
#include <iostream>

int main()
{
    constexpr std::array arr{ 9, 7, 5, 3, 1 };
    std::cout << "length: " << std::size(arr); // C++17 지원, 길이를 size_type 타입 (std::size_t의 별명) 으로 반환합니다

    return 0;
}

마지막으로 세 번째! C++20부터는 std::ssize() 라는 일반 함수를 쓸 수 있게 되었어요. 이 녀석은 길이를 '부호가 있는(signed) 아주 큰 정수 타입'(보통 std::ptrdiff_t)으로 알려주는 기특한 함수입니다.

#include <array>
#include <iostream>

int main()
{
    constexpr std::array arr { 9, 7, 5, 3, 1 };
    std::cout << "length: " << std::ssize(arr); // C++20 지원, 길이를 부호가 있는(signed) 큰 정수 타입으로 반환합니다

    return 0;
}

세 가지 방법 중에서 길이를 '부호가 있는 정수(음수 표현 가능)'로 돌려주는 함수는 이 녀석이 유일해요!

constexpr 값으로 std::array 길이 구하기

std::array 의 길이는 프로그램이 실행되기 전에 이미 고정되는 constexpr 이기 때문에, 방금 배운 세 가지 함수를 쓰면 언제나 길이를 constexpr 값으로 얻어낼 수 있어요! (심지어 배열 자체를 constexpr 로 만들지 않았어도 가능하답니다!) 이 말은 즉, 이 함수들을 고정된 값이 필요한 곳(상수 표현식)에 마음껏 써도 된다는 뜻이고, 여기서 얻은 길이를 평범한 int 에 집어넣어도 데이터 손실 경고가 뜨지 않는다는 놀라운 장점이 있어요.

#include <array>
#include <iostream>

int main()
{
    std::array arr { 9, 7, 5, 3, 1 }; // 참고: 이 예제에서는 constexpr이 아닙니다
    constexpr int length{ std::size(arr) }; // 성공: 반환값이 constexpr std::size_t 이며, int로 변환되어도 데이터 손실(narrowing conversion)이 아닙니다

    std::cout << "length: " << length << '\n';

    return 0;
}

Visual Studio 사용자 분들을 위한 안내 Visual Studio에서는 위 코드를 작성하면 C4365라는 경고를 잘못 띄우는 버그가 있어요. 이 문제는 이미 마이크로소프트에 보고되어 있으니 무시하셔도 괜찮습니다.

주의하세요! (경고) C++ 언어 자체의 작은 결함 때문에, std::array 를 함수의 매개변수로 넘길 때 참조(const reference) 방식을 사용하면 안타깝게도 위 함수들이 constexpr 값을 돌려주지 못하고 에러를 냅니다.

void printLength(const std::array<int, 5> &arr)
{
constexpr int length{ std::size(arr) }; // 컴파일 에러!
std::cout << "length: " << length << '\n';
}

int main()
{
std::array arr { 9, 7, 5, 3, 1 };
constexpr int length{ std::size(arr) }; // 아주 잘 작동합니다
std::cout << "length: " << length << '\n';

printLength(arr);

return 0;
}

이 성가신 결함은 C++23에서 고쳐졌지만, 아직 이 최신 기능을 완벽하게 지원하는 컴파일러가 많지 않아요.

지금 당장 쓸 수 있는 해결책은 함수 자체를 '템플릿'으로 만들어서, 배열의 길이를 매개변수로 직접 넘겨받는 거랍니다. (이 방법은 다음 17.3 레슨에서 자세히 다룰 테니 가벼운 마음으로 넘어가세요!)

template `<auto lenth>`
void printLength(const std::array<int, Length> &arr)
{
    std::cout << "length: " << Length << '\n';
}

operator[] 나 at() 으로 std::array 안의 값 꺼내기

이전 17.1 레슨에서, std::array 안의 값을 꺼낼 때 가장 많이 쓰는 방법은 대괄호 [] (첨자 연산자)를 쓰는 거라고 배웠죠. 이 방법은 엄청나게 빠르지만, 우리가 배열 크기를 벗어난 엉뚱한 번호를 넣었을 때 컴퓨터가 막아주지 않아요(범위 검사를 안 함). 만약 없는 번호를 부르면 프로그램이 미쳐 날뛰게 될 겁니다(Undefined behavior).

그래서 std::vector 처럼 std::array 에도 at() 이라는 안전장치 멤버 함수가 있어요. 이 함수는 프로그램이 실행되는 도중에 우리가 제대로 된 번호를 불렀는지 안전하게 검사해 줍니다. 하지만 전문가들은 이 함수 사용을 별로 추천하지 않아요. 보통은 값을 꺼내기 '전에' 미리 번호가 맞는지 우리가 직접 확인하거나, 아예 프로그램이 실행되기도 전인 컴파일 시점에 검사하는 것을 훨씬 선호하거든요.

참고로 [] 나 at() 모두 우리가 부르는 번호(인덱스)가 부호 없는 size_type (std::size_t) 타입일 거라고 기대하고 있어요. 만약 우리가 넣는 번호가 constexpr 값이라면, 컴파일러가 알아서 에러 없이 예쁘게 std::size_t 로 변환해 줍니다. 데이터 손실 같은 건 없으니 부호 문제로 머리 아플 일은 없어요.

하지만, 만약 우리가 넣는 번호가 constexpr 이 아닌 일반적인 정수라면 이야기가 달라집니다. 이때는 std::size_t 로 변환될 때 데이터 손실 위험이 있다고 판단해서 컴파일러가 짜증 섞인 경고를 뱉어낼 수도 있어요. (이 상황에 대해서는 16.3 레슨에서 std::vector 를 예로 들어 아주 자세히 다뤘었죠!)

std::get() 은 constexpr 번호를 부를 때 컴파일 시점에 안전 검사를 해줘요!

std::array 의 길이는 프로그램 실행 전(컴파일 시점)에 이미 정해진 constexpr 이라고 거듭 강조했죠? 그렇다면, 우리가 꺼내려는 번호(인덱스)도 마침 constexpr 이라면, 컴파일러가 코드를 번역할 때 "어라? 이 번호가 배열 크기 안에 잘 들어맞나?" 하고 미리 검사해 줄 수 있을 거예요! (만약 범위를 벗어난 번호를 불렀다면, 아예 컴파일을 멈춰서 에러를 내주면 가장 완벽하겠죠.)

하지만 앞서 말했듯 [] 는 애초에 그런 검사를 안 하고, at() 은 프로그램이 실행될 때 야 비로소 검사를 합니다. 함수의 매개변수들은 애초에 constexpr 로 넘길 수도 없고요. 그럼 도대체 컴파일 시점에 미리 번호 검사를 받으려면 어떻게 해야 할까요?

정답은 바로 std::get() 이라는 특별한 함수 템플릿을 쓰는 겁니다! 이 녀석은 꺼내려는 번호를 꺾쇠괄호(< >) 안에 템플릿 인자로 넣어서 사용해요:

#include <array>
#include <iostream>

int main()
{
    constexpr std::array prime{ 2, 3, 5, 7, 11 };

    std::cout << std::get<3>(prime); // 인덱스 3에 있는 요소의 값을 출력합니다
    std::cout << std::get<9>(prime); // 유효하지 않은 인덱스 (컴파일 에러)

    return 0;
}

std::get() 의 코드를 살짝 들여다보면, 내부적으로 static_assert 라는 아주 엄격한 검사관이 들어있어요. 이 검사관은 우리가 꺾쇠괄호 안에 적은 번호가 배열의 전체 길이보다 작은지 확인하고, 만약 벗어났다면 가차 없이 컴파일을 중단시키고 에러를 뿜어냅니다.

꺾쇠괄호 안에 들어가는 템플릿 인자는 무조건 constexpr 이어야만 하기 때문에, 이 std::get() 은 우리가 부르려는 번호가 상수(constexpr)일 때만 사용할 수 있다는 점을 꼭 기억해 두세요!

17.3 — std::array 전달하고 반환하기

std::array 타입의 객체도 일반적인 다른 데이터들처럼 함수에 쏙 집어넣을 수 있습니다. 만약 데이터를 통째로 복사해서 넘겨주는 '값에 의한 전달(pass by value)' 방식을 쓰면, 컴퓨터가 배열 전체를 복사하느라 힘을 빼게 됩니다(성능이 떨어집니다). 그래서 복사하는 과정을 피하기 위해 보통 상수 참조(const reference) 방식을 사용해서 원본을 가리키기만 하는 형태로 함수에 전달합니다.

std::array 를 사용할 때는 배열의 길이 와 안에 들어가는 데이터의 타입 이 모두 배열의 '신분증' 같은 역할을 합니다. 따라서 함수에서 이 배열을 넘겨받을 때는, 데이터 타입과 길이를 꼭 명확하게 적어주어야 합니다.

#include <array>
#include <iostream>

void passByRef(const std::array<int, 5>& arr) // 여기에 <int, 5>를 명확하게 적어주어야 합니다
{
    std::cout << arr[0] << '\n';
}

int main()
{
    std::array arr{ 9, 7, 5, 3, 1 }; // CTAD(클래스 템플릿 인수 추론)가 알아서 std::array<int, 5> 타입을 알아냅니다
    passByRef(arr);

    return 0;
}

안타깝게도 CTAD(컴파일러가 코드를 보고 알아서 타입을 눈치껏 맞춰주는 편리한 기능)는 함수의 매개변수에서는 아직 작동하지 않습니다. 그래서 함수 괄호 안에 그냥 std::array 라고만 적어두고 컴파일러에게 알아서 맞춰달라고 할 수는 없습니다.

함수 템플릿을 써서 다양한 타입과 길이의 std::array 전달하기

만약 들어가는 데이터가 int 든 double 이든 상관없이, 그리고 길이가 5든 100이든 상관없이 모두 받아줄 수 있는 '만능 함수'를 만들고 싶다면 어떻게 해야 할까요? 바로 함수 템플릿 을 만들면 됩니다. 데이터 타입과 길이를 들어갈 수 있게 빈칸(매개변수)으로 뚫어놓으면, C++ 컴파일러가 알아서 실제 쓰일 때 그 빈칸을 채워 진짜 함수들을 만들어냅니다.

관련 내용 함수 템플릿에 대한 자세한 내용은 '11.6 -- 함수 템플릿' 강의에서 다룹니다.

std::array 는 원래 이렇게 생겼습니다:

template<typename T, std::size_t N> // N은 타입이 아닌 템플릿 매개변수(숫자 값 등)입니다
struct array;

우리는 이 모양을 그대로 흉내 내서 함수 템플릿을 만들 수 있습니다:

#include <array>
#include <iostream>

template <typename T, std::size_t N> // 참고: 이 템플릿 매개변수 선언은 std::array의 선언과 모양이 똑같습니다
void passByRef(const std::array<T, N>& arr)
{
    static_assert(N != 0); // 길이가 0인 std::array가 들어오면 실패(오류) 처리합니다

    std::cout << arr[0] << '\n';
}

int main()
{
    std::array arr{ 9, 7, 5, 3, 1 }; // CTAD를 이용해 std::array<int, 5>로 유추합니다
    passByRef(arr);  // 성공: 컴파일러가 passByRef(const std::array<int, 5>& arr) 함수를 만들어냅니다

    std::array arr2{ 1, 2, 3, 4, 5, 6 }; // CTAD를 이용해 std::array<int, 6>으로 유추합니다
    passByRef(arr2); // 성공: 컴파일러가 passByRef(const std::array<int, 6>& arr) 함수를 만들어냅니다

    std::array arr3{ 1.2, 3.4, 5.6, 7.8, 9.9 }; // CTAD를 이용해 std::array<double, 5>로 유추합니다
    passByRef(arr3); // 성공: 컴파일러가 passByRef(const std::array<double, 5>& arr) 함수를 만들어냅니다

    return 0;
}

위 예제에서 우리는 passByRef() 라는 함수 템플릿을 딱 하나만 만들었습니다. 여기서 T 와 N 은 첫째 줄의 template <typename T, std::size_t N> 에서 정의되었습니다. T 는 데이터의 타입을 결정할 수 있게 해주고, N 은 배열의 길이를 결정할 수 있게 해주는 특별한 매개변수입니다.

주의! std::array 의 길이를 나타내는 템플릿 매개변수(N)의 타입은 int 가 아니라 반드시 std::size_t 여야 합니다! 템플릿은 자동으로 타입을 변환해주지 않기 때문에 int 를 쓰면 짝이 맞지 않아 컴파일러가 에러를 뿜어냅니다.

그래서 우리가 main() 에서 passByRef(arr) 를 부르면, 컴파일러가 알아서 void passByRef(const std::array<int, 5>& arr) 라는 맞춤형 함수를 찍어내서 실행합니다. arr2 와 arr3 에 대해서도 똑같이 알아서 만들어줍니다. 결론적으로, 단 하나의 만능 함수 템플릿으로 어떤 타입, 어떤 길이의 std::array 도 모두 처리할 수 있게 된 것입니다!

원한다면 둘 중 하나만 빈칸(템플릿)으로 뚫어놓을 수도 있습니다. 아래 예제에서는 배열의 길이는 아무거나 들어올 수 있게 템플릿으로 만들었지만, 데이터 타입은 무조건 int 만 받도록 고정했습니다.

#include <array>
#include <iostream>

template <std::size_t N> // 참고: 여기서는 길이만 템플릿으로 만들었습니다
void passByRef(const std::array<int, N>& arr) // 데이터 타입을 int로 고정해두었습니다
{
    static_assert(N != 0); // 길이가 0인 std::array가 들어오면 실패(오류) 처리합니다

    std::cout << arr[0] << '\n';
}

int main()
{
    std::array arr{ 9, 7, 5, 3, 1 }; // CTAD를 이용해 std::array<int, 5>로 유추합니다
    passByRef(arr);  // 성공: 컴파일러가 passByRef(const std::array<int, 5>& arr) 함수를 만들어냅니다

    std::array arr2{ 1, 2, 3, 4, 5, 6 }; // CTAD를 이용해 std::array<int, 6>으로 유추합니다
    passByRef(arr2); // 성공: 컴파일러가 passByRef(const std::array<int, 6>& arr) 함수를 만들어냅니다

    std::array arr3{ 1.2, 3.4, 5.6, 7.8, 9.9 }; // CTAD를 이용해 std::array<double, 5>로 유추합니다
    passByRef(arr3); // 오류: 컴파일러가 일치하는 함수를 찾을 수 없습니다 (double 타입이라서 튕겨냅니다)

    return 0;
}

C++20 기능: auto 를 이용한 비타입 템플릿 매개변수

템플릿을 만들 때마다 std::size_t 처럼 길이를 나타내는 정확한 타입을 외워서 적는 건 꽤나 귀찮은 일입니다. C++20부터는 auto 키워드를 쓰면, 컴파일러가 알아서 눈치껏 타입을 맞춰주기 때문에 훨씬 편해졌습니다.

#include <array>
#include <iostream>

template <typename T, auto N> // 이제 auto를 사용해 N의 타입을 알아서 유추합니다
void passByRef(const std::array<T, N>& arr)
{
    static_assert(N != 0); // 길이가 0인 std::array가 들어오면 실패(오류) 처리합니다

    std::cout << arr[0] << '\n';
}

int main()
{
    std::array arr{ 9, 7, 5, 3, 1 }; // CTAD를 이용해 std::array<int, 5>로 유추합니다
    passByRef(arr);  // 성공: 컴파일러가 passByRef(const std::array<int, 5>& arr) 함수를 만들어냅니다

    std::array arr2{ 1, 2, 3, 4, 5, 6 }; // CTAD를 이용해 std::array<int, 6>으로 유추합니다
    passByRef(arr2); // 성공: 컴파일러가 passByRef(const std::array<int, 6>& arr) 함수를 만들어냅니다

    std::array arr3{ 1.2, 3.4, 5.6, 7.8, 9.9 }; // CTAD를 이용해 std::array<double, 5>로 유추합니다
    passByRef(arr3); // 성공: 컴파일러가 passByRef(const std::array<double, 5>& arr) 함수를 만들어냅니다

    return 0;
}

여러분의 컴파일러가 C++20을 지원한다면, 아주 유용하게 쓸 수 있는 방법입니다.

배열 길이에 대한 컴파일 타임 검사 (Static assert)

위에서 본 것과 비슷한 아래의 함수를 한번 살펴볼까요?

#include <array>
#include <iostream>

template <typename T, std::size_t N>
void printElement3(const std::array<T, N>& arr)
{
    std::cout << arr[3] << '\n';
}

int main()
{
    std::array arr{ 9, 7, 5, 3, 1 };
    printElement3(arr);

    return 0;
}

이 코드는 지금 당장은 아무 문제 없이 잘 돌아가지만, 초보 프로그래머가 실수하기 딱 좋은 엄청난 버그 폭탄을 숨기고 있습니다. 찾으셨나요?

위 프로그램은 배열의 3번 인덱스(네 번째 값)를 화면에 보여주는 역할을 합니다. 배열 안에 값이 4개 이상 들어있다면 문제가 없겠죠. 하지만 배열 길이가 2밖에 안 되는데 3번 인덱스를 찾으려고 하면, 컴파일러는 아무 경고 없이 그냥 넘어가 버립니다.

#include <array>
#include <iostream>

template <typename T, std::size_t N>
void printElement3(const std::array<T, N>& arr)
{
    std::cout << arr[3] << '\n'; // 유효하지 않은 인덱스입니다 (에러 발생 위치)
}

int main()
{
    std::array arr{ 9, 7 }; // 2개의 요소만 있는 배열입니다 (유효한 인덱스는 0과 1뿐입니다)
    printElement3(arr);

    return 0;
}

이러면 프로그램이 알 수 없는 이상한 행동(정의되지 않은 동작)을 하게 됩니다. 이런 실수를 했을 때 컴파일러가 "너 잘못 짰어!" 하고 미리 알려주면 얼마나 좋을까요?

일반 함수의 매개변수와 달리, 템플릿 매개변수는 컴파일 타임 상수 (프로그램을 실행하기도 전에 이미 그 값이 확정됨)라는 엄청난 장점이 있습니다. 이 장점을 활용하면 문제를 미리 예방할 수 있습니다.

첫 번째 해결책은 operator[] (대괄호) 대신 std::get() 을 쓰는 것입니다. 대괄호는 길이를 넘었는지 검사하지 않지만, std::get() 은 프로그램을 실행하기도 전(컴파일할 때)에 길이를 검사해 줍니다.

#include <array>
#include <iostream>

template <typename T, std::size_t N>
void printElement3(const std::array<T, N>& arr)
{
    std::cout << std::get<3>(arr) << '\n'; // 컴파일 시점에 인덱스 3이 유효한지 안전하게 검사합니다
}

int main()
{
    std::array arr{ 9, 7, 5, 3, 1 };
    printElement3(arr); // 성공

    std::array arr2{ 9, 7 };
    printElement3(arr2); // 컴파일 오류가 발생하여 실수를 미리 막아줍니다

    return 0;
}

컴파일러가 printElement3(arr2) 코드를 확인하면 길이가 2인 배열 전용 함수를 만드는데, 그 안에서 std::get<3>(arr) 을 발견하고는 "어? 길이 2짜리 배열에서 3번 인덱스를 달라고? 안 돼!"라며 에러를 띄워줍니다.

두 번째 해결책은 우리가 직접 static_assert 라는 기능을 이용해 "배열 길이는 무조건 3보다 커야 해!"라고 단단히 못을 박아두는 것입니다.

#include <array>
#include <iostream>

template <typename T, std::size_t N>
void printElement3(const std::array<T, N>& arr)
{
    // 전제 조건: 3번 요소가 존재하려면 배열 길이가 3보다 커야 합니다
    static_assert (N > 3);

    // 이 지점부터는 배열 길이가 무조건 3보다 크다고 확신하고 안심할 수 있습니다

    std::cout << arr[3] << '\n';
}

int main()
{
    std::array arr{ 9, 7, 5, 3, 1 };
    printElement3(arr); // 성공

    std::array arr2{ 9, 7 };
    printElement3(arr2); // 컴파일 오류가 발생합니다

    return 0;
}

마찬가지로 배열 길이가 2인 arr2 가 들어오면, 컴퓨터가 static_assert (2 > 3) 라는 수학적으로 말이 안 되는 수식을 보고 에러를 뿜어내어 우리의 실수를 막아줍니다.

std::array 반환하기 (함수에서 밖으로 내보내기)

std::array 를 함수에 집어넣는 건 참조 방식을 쓰면 되니까 아주 쉬웠습니다. 그런데 함수에서 결과물로 std::array 를 밖으로 뱉어낼(반환할) 때는 조금 복잡해집니다. std::vector 와 달리 std::array 는 가볍게 '이동(move)'시키는 게 불가능해서, 배열 전체를 하나하나 복사해서 반환해야 하거든요.

상황에 따라 주로 두 가지 방법을 씁니다.

1. 값으로 반환하기 (Return by value) 다음 조건이 모두 맞다면 통째로 복사해서 반환해도 괜찮습니다.

• 배열 크기가 작다.
• 안에 든 데이터가 가벼워서 복사해도 부담이 없다.
• 0.001초가 중요한 엄청난 고성능 프로그램이 아니다.

복사를 하느라 컴퓨터가 살짝 힘을 쓰긴 하겠지만, 코드가 가장 자연스럽고 깔끔해집니다.

#include <array>
#include <iostream>
#include <limits>

// 값으로 반환하는 함수 템플릿
template <typename T, std::size_t N>
std::array<T, N> inputArray() // 값으로 반환하기
{
    std::array<T, N> arr{};
    std::size_t index { 0 };
    while (index < N)
    {
        std::cout << "Enter value #" << index << ": ";
        std::cin >> arr[index];

        if (!std::cin) // 잘못된 입력 처리하기
        {
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            continue;
        }
        ++index;
    }

    return arr;
}

int main()
{
    std::array<int, 5> arr { inputArray<int, 5>() };

    std::cout << "The value of element 2 is " << arr[2] << '\n';

    return 0;
}

• 장점: 초보자가 보기에도 코드가 가장 자연스럽습니다. 함수가 어떤 값을 뱉어낸다는 게 눈에 확 띄고, 함수를 실행함과 동시에 빈 배열에 결과값을 쏙 넣을 수 있습니다.
• 단점: 배열 전체를 복사해야 해서 무겁습니다. 그리고 템플릿이 자동으로 유추해줄 단서가 없기 때문에 <int, 5> 라고 직접 다 적어줘야 합니다.

2. 출력 매개변수(Out parameter)로 반환하기 복사하는 게 너무 무겁고 아깝다면 이 방법을 씁니다. 함수를 부르는 쪽에서 빈 배열을 미리 준비해서 함수에 던져주면(참조 방식), 함수가 그 빈 배열의 속을 꽉꽉 채워주는 방식입니다.

#include <array>
#include <limits>
#include <iostream>

template <typename T, std::size_t N>
void inputArray(std::array<T, N>& arr) // 상수가 아닌 참조로 전달하기 (원본을 수정할 수 있도록 넘김)
{
    std::size_t index { 0 };
    while (index < N)
    {
        std::cout << "Enter value #" << index << ": ";
        std::cin >> arr[index];

        if (!std::cin) // 잘못된 입력 처리하기
        {
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            continue;
        }
        ++index;
    }
}

int main()
{
    std::array<int, 5> arr {};
    inputArray(arr); // 함수가 arr의 속을 채워줍니다

    std::cout << "The value of element 2 is " << arr[2] << '\n';

    return 0;
}

• 장점: 복사가 전혀 일어나지 않아서 아주 빠르고 효율적입니다.
• 단점: 함수가 값을 반환하는 대신 매개변수를 슬쩍 수정하는 거라, 코드를 처음 보는 사람은 이해하기 어려울 수 있습니다. 또, 배열을 만들면서 바로 채울 수 없고 무조건 빈 배열을 먼저 선언해 둬야 합니다.

그냥 std::vector 쓰면 안 되나요?

사실 가장 좋은 꿀팁입니다. std::vector 는 '이동(move)'이라는 기술이 가능해서 통째로 반환해도 복사본을 만들지 않고 쌩하고 날아갑니다. 만약 std::array 를 통째로 반환해야 하는 상황이 생긴다면, 굳이 무거운 복사를 참아가며 std::array 를 고집하기보다는 유연하고 빠른 std::vector 를 대신 사용하는 것을 강력히 추천합니다!

17.4 — 클래스 타입의 std::array와 중괄호 생략 쉽게 이해하기

std::array 에는 숫자(int)나 문자(char) 같은 단순하고 기본적인 타입만 넣을 수 있는 게 아닙니다. 구조체(struct)나 클래스(class)처럼 우리가 직접 만든 복잡한 덩어리들도 얼마든지 담을 수 있어요! 즉, 포인터들을 모아둔 std::array 나, 구조체들을 모아둔 std::array 를 만들 수 있다는 뜻입니다.

하지만 초보자분들이 구조체나 클래스를 담은 std::array 를 처음 만들 때(초기화할 때) 에러가 나면서 많이들 당황하시곤 합니다. 그래서 이번 레슨에서는 이 부분을 아주 속 시원하고 알기 쉽게 풀어보겠습니다.

작성자의 참고 노트 이번 레슨에서는 이해를 돕기 위해 '구조체(struct)'를 예시로 사용할 거예요. 하지만 여기서 배우는 모든 원리는 '클래스(class)'에도 똑같이 적용되니 걱정하지 마세요!

구조체를 담은 std::array 만들고 값 넣기

먼저 아주 간단한 House (집) 구조체를 만들어 볼까요?

struct House{
    int number{};
    int stories{};
    int roomsPerStory{};
};

이 House 구조체들을 담는 std::array 를 만들고, 나중에 값을 하나씩 집어넣는 건 우리가 흔히 아는 방식 그대로 잘 작동합니다.

#include <array>
#include <iostream>

struct House{
    int number{};
    int stories{};
    int roomsPerStory{};
};

int main(){
    std::array<House, 3> houses{};

    houses[0] = { 13, 1, 7 };
    houses[1] = { 14, 2, 5 };
    houses[2] = { 15, 2, 4 };

    for (const auto& house : houses)
    {
        std::cout << "House number " << house.number
                  << " has " << (house.stories * house.roomsPerStory)
                  << " rooms.\n";
    }

    return 0;
}

위 코드를 실행하면 예상대로 다음처럼 잘 출력됩니다.

House number 13 has 7 rooms. House number 14 has 10 rooms. House number 15 has 8 rooms.

구조체를 담은 std::array 초기화하기 (만들면서 동시에 값 넣기)

배열을 만들 때 값을 한 번에 쏙쏙 집어넣는 것도 잘 작동합니다. 단, 어떤 타입 인지 명확하게 적어준다면요!

#include <array>
#include <iostream>

struct House{
    int number{};
    int stories{};
    int roomsPerStory{};
};

int main(){
    constexpr std::array houses { // CTAD(템플릿 인자 추론)를 사용해 <House, 3> 이라는 걸 컴파일러가 눈치채게 합니다
            House{ 13, 1, 7 },
            House{ 14, 2, 5 },
            House{ 15, 2, 4 }
        };

    for (const auto& house : houses)
    {
        std::cout << "House number " << house.number
            << " has " << (house.stories * house.roomsPerStory)
            << " rooms.\n";
    }

    return 0;
}

위 코드에서는 CTAD(컴파일러가 타입을 스스로 유추하는 똑똑한 기능)를 써서 이 배열이 std::array<House, 3> 이라는 걸 알아내게 했습니다. 그리고 House{ ... } 처럼 각 줄마다 House 라고 친절하게 적어줬기 때문에 아무 문제 없이 작동합니다.

매번 'House'라고 적기 귀찮다면? (여기서부터 문제가 생깁니다!)

위 코드에서 값을 넣을 때마다 House 라고 일일이 적어주는 게 조금 번거롭게 느껴지지 않나요?

    constexpr std::array houses {
        House{ 13, 1, 7 }, // 여기에 House라고 썼고
        House{ 14, 2, 5 }, // 여기도 썼고
        House{ 15, 2, 4 }  // 여기도 썼네요
    };

생각해 보면 아까 배열을 만들고 나중에 값을 대입할 때는 굳이 House 라고 적지 않아도 알아서 잘 들어갔거든요.

// 컴파일러는 houses 배열의 각 칸이 House라는 걸 이미 알고 있습니다.
// 그래서 오른쪽의 숫자를 알아서 House 형태로 바꿔서 넣어줍니다.
houses[0] = { 13, 1, 7 };
houses[1] = { 14, 2, 5 };
houses[2] = { 15, 2, 4 };

그래서 아마 여러분은 "처음 배열을 만들 때도 House 라는 글자를 빼고 숫자만 적어도 알아서 들어가지 않을까?" 하고 이렇게 시도해 볼 수 있습니다.

// 작동하지 않습니다!
constexpr std::array<House, 3> houses { // 컴파일러에게 각 칸이 House라고 말해줬지만...
        { 13, 1, 7 }, // 정작 값 앞에는 House를 빼버렸습니다.
        { 14, 2, 5 },
        { 15, 2, 4 }
    };

놀랍게도 이 코드는 에러가 납니다. 왜 안 되는지 그 속사정을 아주 쉽게 파헤쳐 볼까요?

왜 에러가 날까요? (std::array의 비밀)

사실 std::array 는 진짜 순수한 배열이 아닙니다. 진짜 C스타일 배열 하나를 몰래 품고 있는 '포장지(구조체)' 에 불과합니다. 속살은 이렇게 생겼어요.

template<typename T, std::size_t N>
struct array{
    T implementation_defined_name[N]; // 타입 T를 N개 담을 수 있는 '숨겨진 C스타일 배열'입니다
};

그래서 우리가 아까처럼 코드를 쓰면, 바보 같은 컴파일러는 우리의 의도와 다르게 완전히 오해를 해버립니다.

// 작동하지 않습니다!
constexpr std::array<House, 3> houses { // 1. 자, houses 포장지(구조체) 초기화 시작!
    { 13, 1, 7 }, // 2. 어? 안에 있는 '숨겨진 C스타일 배열'의 첫 번째 칸(0번 칸)에 이걸 넣으라는 거구나!
    { 14, 2, 5 }, // 3. 엥? 자리가 없는데? 이건 뭐야? (?)
    { 15, 2, 4 }  // 4. 이것도 뭐야? 에러!! (?)
};

즉, 컴파일러는 첫 번째 줄 { 13, 1, 7 } 전체를 "숨겨진 내부 배열 3칸 중 첫 번째 칸에 몽땅 넣어라" 는 뜻으로 착각해 버립니다. 그리고 나머지 두 줄을 보고는 "더 이상 넣을 데가 없는데 값이 너무 많아!" 라며 에러를 뱉어내는 거죠.

정답은 '이중 중괄호' 치기!

이 오해를 풀고 코드를 정상적으로 작동하게 만드는 올바른 방법은, 중괄호를 한 겹 더 씌워주는 것 입니다.

// 예상대로 아주 잘 작동합니다!
constexpr std::array<House, 3> houses { // 1. houses 포장지(구조체) 초기화 시작!
    { // 2. 여기서부터가 '숨겨진 C스타일 배열'에 들어갈 진짜 값들이야! 라고 알려주는 추가 중괄호
        { 13, 4, 30 }, // 배열의 0번 칸에 들어갈 값
        { 14, 3, 10 }, // 배열의 1번 칸에 들어갈 값
        { 15, 3, 40 }, // 배열의 2번 칸에 들어갈 값
     }
};

바깥쪽 중괄호 {} 는 std::array 라는 포장지를 위한 것이고, 안쪽 중괄호 {} 가 바로 그 안에 숨어있는 진짜 배열을 위한 것입니다. 이렇게 해주면 각각의 방에 값들이 예쁘게 쏙쏙 들어갑니다.

핵심 포인트 구조체, 클래스, 배열 등을 담은 std::array 를 만들 때, 값 앞에 일일이 House{...} 처럼 이름을 적어주기 귀찮다면 반드시 바깥에 중괄호를 한 번 더 {{ }} 씌워주세요! 그래야 컴파일러가 헷갈리지 않습니다.

완성된 코드는 이렇습니다:

#include <array>
#include <iostream>

struct House{
    int number{};
    int stories{};
    int roomsPerStory{};
};

int main(){
    constexpr std::array<House, 3> houses {{ // 이중 중괄호 {{ }} 에 주목하세요!
        { 13, 1, 7 },
        { 14, 2, 5 },
        { 15, 2, 4 }
    }};

    for (const auto& house : houses)
    {
        std::cout << "House number " << house.number
                  << " has " << (house.stories * house.roomsPerStory)
                  << " rooms.\n";
    }

    return 0;
}

중괄호 생략 이란?

"어라? 숫자만 넣을 때는 중괄호 한 번만 써도 잘 됐는데요?" 라고 생각하셨다면 아주 예리하십니다.

#include <array>
#include <iostream>

int main(){
    constexpr std::array<int, 5> arr { 1, 2, 3, 4, 5 }; // 단일 중괄호 (어? 왜 이건 되죠?)

    for (const auto n : arr)
        std::cout << n << '\n';

    return 0;
}

물론 여기도 원래는 이중 중괄호 {{ 1, 2, 3, 4, 5 }} 를 쓰는 게 원칙상 맞습니다.

하지만 C++은 우리를 편하게 해주려고 중괄호 생략 (Brace elision) 이라는 마법을 부립니다. 배열 안에 들어가는 게 단순한 숫자 하나씩일 때, 또는 아까처럼 House{13,1,7} 처럼 이름을 명확히 적어줬을 때는 컴파일러가 눈치껏 "아, 굳이 중괄호 두 번 안 쳐도 내가 찰떡같이 알아먹지!" 하고 한 겹을 생략할 수 있게 허락해 주는 것입니다.

초보자를 위한 꿀팁: 언제 생략해도 되는지 헷갈린다면? 고민하지 말고 무조건 이중 중괄호 {{ }} 를 쓰시면 마음이 편안해집니다. 아니면 일단 중괄호를 한 번만 써보고, 컴파일러가 빨간 줄(에러)을 띄우면 그때 쓱 한 겹 더 씌워주면 됩니다!

학생 예제로 복습하기

마지막으로 Student 라는 구조체를 담은 배열을 어떻게 만들었는지 살펴볼까요? 여기서는 각 값 앞에 Student 라고 친절하게 이름을 적어주었기 때문에 중괄호를 한 번만(생략해서) 썼습니다.

#include <array>
#include <iostream>
#include <string_view>

// 각 학생은 id(번호)와 name(이름)을 가집니다
struct Student{
    int id{};
    std::string_view name{};
};

// 3명의 학생을 담은 배열입니다. (각 값 앞에 Student라고 명시했기 때문에 중괄호를 한 번만 썼습니다)
constexpr std::array students{ Student{0, "Alex"}, Student{ 1, "Joe" }, Student{ 2, "Bob" } };

const Student* findStudentById(int id){
    // 모든 학생을 하나씩 확인합니다
    for (auto& s : students)
    {
        // 입력한 번호(id)와 일치하는 학생을 찾으면 그 학생의 주소를 반환합니다
        if (s.id == id) return &s;
    }

    // 일치하는 번호를 못 찾았다면 빈 값(nullptr)을 반환합니다
    return nullptr;
}

int main(){
    constexpr std::string_view nobody { "nobody" };

    const Student* s1 { findStudentById(1) };
    std::cout << "You found: " << (s1 ? s1->name : nobody) << '\n';

    const Student* s2 { findStudentById(3) };
    std::cout << "You found: " << (s2 ? s2->name : nobody) << '\n';

    return 0;
}

출력 결과:

You found: Joe You found: nobody

참고로, 위 코드에서 std::array students 가 수정 불가능한 상수(constexpr)로 만들어졌기 때문에, 이 학생 정보를 찾아주는 함수 findStudentById() 도 반드시 수정 불가능한 const 포인터를 반환해야 합니다. 따라서 main() 함수에서 결과값을 받을 때도 const Student* 로 받아야 한다는 점 잊지 마세요!

17.6 — std::array와 열거형

이전 레슨(16.9)에서는 배열과 열거형(enum)에 대해 이야기해 보았죠. 이제 우리가 코드 작성 시 아주 유용한 도구인 constexpr std::array 를 가지게 되었으니, 이 이야기를 조금 더 발전시켜서 몇 가지 재미있는 꿀팁을 알려드릴게요.

배열의 초기화 개수가 맞는지 확인하기 (static_assert 사용)

C++에서 constexpr std::array 를 만들 때 안의 값들(초기값)만 쏙쏙 넣어주면, 똑똑한 컴파일러가 "아, 이 배열은 이만큼의 길이가 필요하겠구나!" 하고 스스로 크기를 알아맞히는 기능이 있어요.

하지만 만약 우리가 실수로 값을 원래 있어야 할 개수보다 적게 넣으면 어떻게 될까요? 배열의 길이가 생각했던 것보다 짧아지게 되고, 나중에 빈 공간에 접근하려고 하면 프로그램이 엉뚱하게 작동하는 문제(정의되지 않은 동작)가 발생할 수 있습니다.

예를 들어볼게요:

#include <array>
#include <iostream>

enum StudentNames
{
    kenny, // 0
    kyle, // 1
    stan, // 2
    butters, // 3
    cartman, // 4
    max_students // 5
};

int main()
{
    constexpr std::array testScores { 78, 94, 66, 77 }; // 앗, 값이 4개밖에 없네요

    std::cout << "Cartman got a score of " << testScores[StudentNames::cartman] << '\n'; // 잘못된 인덱스 접근으로 인해 정의되지 않은 동작 발생

    return 0;
}

이렇게 배열 안에 들어가는 값의 개수가 정확한지 확인해야 할 때는 static_assert 라는 기능을 사용해서 아주 안전하게 검사할 수 있어요. static_assert 는 프로그램이 만들어질 때(컴파일될 때) "이 조건이 맞는지 꼭 확인해!" 라고 명령을 내리는 든든한 문지기 역할을 합니다.

#include <array>
#include <iostream>

enum StudentNames
{
    kenny, // 0
    kyle, // 1
    stan, // 2
    butters, // 3
    cartman, // 4
    max_students // 5
};

int main()
{
    constexpr std::array testScores { 78, 94, 66, 77 };

    // 시험 점수의 개수가 학생 수와 똑같은지 확인합니다
    static_assert(std::size(testScores) == max_students); // 컴파일 에러: static_assert 조건 실패

    std::cout << "Cartman got a score of " << testScores[StudentNames::cartman] << '\n';

    return 0;
}

이렇게 코드를 짜두면 참 편리해요. 나중에 새로운 학생(열거형 값)을 추가해 놓고 시험 점수를 깜빡 잊고 안 적었더라도, 프로그램이 아예 실행조차 되지 않고 에러를 내뿜기 때문에 실수를 바로잡을 수 있거든요. 이 방법은 두 개의 서로 다른 constexpr std::array 가 똑같은 길이를 가졌는지 확인할 때도 사용할 수 있습니다.

열거형(enum)의 입력과 출력 을 더 쉽게 만드는 constexpr 배열

이전 레슨(13.5)에서 열거형(enum)의 이름을 화면에 출력하거나 입력받는 방법을 배웠어요. 그때는 열거형을 문자열로 바꾸거나, 문자열을 다시 열거형으로 바꿔주는 '도우미 함수'를 직접 길게 만들었죠. 그런데 이 함수들은 똑같은 단어들을 중복해서 가지고 있어야 했고, 일일이 조건문을 확인해야 해서 무척 번거로웠어요.

constexpr std::string_view getPetName(Pet pet)
{
    switch (pet)
    {
    case cat:   return "cat";
    case dog:   return "dog";
    case pig:   return "pig";
    case whale: return "whale";
    default:    return "???";
    }
}

constexpr std::optional<Pet> getPetFromString(std::string_view sv)
{
    if (sv == "cat")   return cat;
    if (sv == "dog")   return dog;
    if (sv == "pig")   return pig;
    if (sv == "whale") return whale;

    return {};
}

이 방식의 귀찮은 점은, 나중에 새로운 동물을 추가할 때마다 이 함수들도 잊지 않고 일일이 수정해 줘야 한다는 거예요.

이제 이 함수들을 훨씬 더 똑똑하게 고쳐볼까요? 대부분의 열거형은 값이 0부터 시작해서 차례대로 1씩 커집니다. 이 특징을 이용하면, 배열 하나에 열거형의 이름들을 순서대로 담아두고 사용할 수 있어요!

이렇게 하면 두 가지 마법 같은 일이 가능해집니다:

1. 열거형의 값을 인덱스(순서 번호)로 사용해서, 배열에서 곧바로 해당하는 이름을 꺼내올 수 있어요.
2. 반복문을 사용해 모든 이름을 하나씩 훑어볼 수 있고, 몇 번째 인덱스인지를 확인해서 이름과 열거형 값을 다시 짝지어줄 수도 있습니다.

#include <array>
#include <iostream>
#include <string>
#include <string_view>

namespace Color
{
    enum Type
    {
        black,
        red,
        blue,
        max_colors
    };

    // sv 접미사를 사용하여 std::array가 타입을 std::string_view로 추론하게 합니다
    using namespace std::string_view_literals; // sv 접미사를 사용하기 위함
    constexpr std::array colorName { "black"sv, "red"sv, "blue"sv };

    // 모든 색상에 대해 문자열이 잘 정의되었는지 확인합니다
    static_assert(std::size(colorName) == max_colors);
};

constexpr std::string_view getColorName(Color::Type color)
{
    // 열거형 값을 인덱스로 사용해서 열거형의 이름을 바로 가져올 수 있습니다
    return Color::colorName[static_cast<std::size_t>(color)];
}

// operator<< 에게 Color를 어떻게 출력하는지 알려줍니다
// std::ostream은 std::cout의 타입입니다
// 반환 타입과 매개변수 타입은 참조(reference)입니다 (불필요한 복사를 막기 위해서요)!
std::ostream& operator<<(std::ostream& out, Color::Type color)
{
    return out << getColorName(color);
}

// operator>> 에게 이름을 통해 Color를 어떻게 입력받는지 알려줍니다
// 함수가 값을 수정할 수 있도록 const가 아닌 참조로 color를 전달합니다
std::istream& operator>> (std::istream& in, Color::Type& color)
{
    std::string input {};
    std::getline(in >> std::ws, input);

    // 이름 목록을 쭉 확인하면서 일치하는 이름이 있는지 찾습니다
    for (std::size_t index=0; index < Color::colorName.size(); ++index)
    {
        if (input == Color::colorName[index])
        {
            // 일치하는 이름을 찾았다면, 그 인덱스를 사용해 열거형 값을 얻을 수 있습니다
            color = static_cast<Color::Type>(index);
            return in;
        }
    }

    // 일치하는 것을 못 찾았다면 잘못된 입력이라는 뜻입니다
    // 따라서 입력 스트림을 실패(fail) 상태로 설정합니다
    in.setstate(std::ios_base::failbit);

    // 추출에 실패하면, operator>> 는 기본 타입들을 0으로 초기화합니다
    // 이 연산자도 똑같이 동작하게 만들려면 아래 줄의 주석을 해제하세요
    // color = {};
    return in;
}

int main()
{
    auto shirt{ Color::blue };
    std::cout << "Your shirt is " << shirt << '\n';

    std::cout << "Enter a new color: ";
    std::cin >> shirt;
    if (!std::cin)
        std::cout << "Invalid\n";
    else
        std::cout << "Your shirt is now " << shirt << '\n';

    return 0;
}

이 코드의 실행 결과는 다음과 같습니다:

Your shirt is blue
Enter a new color: red
Your shirt is now red

범위 기반 for문 과 열거형

가끔 열거형 안에 있는 값들을 처음부터 끝까지 한 바퀴 쫙 돌면서(반복하면서) 작업하고 싶을 때가 있어요. 숫자 인덱스를 쓰는 일반적인 for 문을 사용해서 할 수도 있지만, 이렇게 하면 숫자를 열거형 타입으로 억지로 변환해 주는 귀찮은 작업(static casting)을 코드에 많이 적어야 합니다.

#include <array>
#include <iostream>
#include <string_view>

namespace Color
{
    enum Type
    {
        black,
        red,
        blue,
        max_colors
    };

    // sv 접미사를 사용하여 std::array가 타입을 std::string_view로 추론하게 합니다
    using namespace std::string_view_literals; // sv 접미사를 사용하기 위함
    constexpr std::array colorName { "black"sv, "red"sv, "blue"sv };

    // 모든 색상에 대해 문자열이 잘 정의되었는지 확인합니다
    static_assert(std::size(colorName) == max_colors);
};

constexpr std::string_view getColorName(Color::Type color)
{
    return Color::colorName[color];
}

// operator<< 에게 Color를 어떻게 출력하는지 알려줍니다
// std::ostream은 std::cout의 타입입니다
// 반환 타입과 매개변수 타입은 참조(reference)입니다 (불필요한 복사를 막기 위해서요)!
std::ostream& operator<<(std::ostream& out, Color::Type color)
{
    return out << getColorName(color);
}

int main()
{
    // 일반 for문을 사용해 모든 색상을 순회합니다
    for (int i=0; i < Color::max_colors; ++i )
        std::cout << static_cast<Color::Type>(i) << '\n';

    return 0;
}

그렇다면 코드가 훨씬 깔끔해지는 범위 기반 for문 을 쓰면 어떨까요? 안타깝게도 C++에서는 이 편리한 방법을 열거형에 직접 사용할 수는 없게 되어 있어요.

#include <array>
#include <iostream>
#include <string_view>

namespace Color
{
    enum Type
    {
        black,
        red,
        blue,
        max_colors
    };

    // sv 접미사를 사용하여 std::array가 타입을 std::string_view로 추론하게 합니다
    using namespace std::string_view_literals; // sv 접미사를 사용하기 위함
    constexpr std::array colorName { "black"sv, "red"sv, "blue"sv };

    // 모든 색상에 대해 문자열이 잘 정의되었는지 확인합니다
    static_assert(std::size(colorName) == max_colors);
};

constexpr std::string_view getColorName(Color::Type color)
{
    return Color::colorName[color];
}

// operator<< 에게 Color를 어떻게 출력하는지 알려줍니다
// std::ostream은 std::cout의 타입입니다
// 반환 타입과 매개변수 타입은 참조(reference)입니다 (불필요한 복사를 막기 위해서요)!
std::ostream& operator<<(std::ostream& out, Color::Type color)
{
    return out << getColorName(color);
}

int main()
{
    for (auto c: Color::Type) // 컴파일 에러: 열거형은 순회(traverse)할 수 없습니다
        std::cout << c < '\n';

    return 0;
}

이 문제를 해결하기 위해 많은 프로그래머들이 창의적인 방법들을 만들어냈지만, 가장 직관적이고 쉬운 해결책은 바로 우리가 방금 배운 constexpr std::array 를 활용하는 겁니다!

배열에는 범위 기반 for문 을 마음껏 쓸 수 있거든요. 열거형의 값들을 차례대로 담은 배열을 하나 만들어두고, 그 배열을 반복하도록 만들면 끝입니다. (단, 이 방법은 열거형 값들이 서로 중복되지 않고 고유할 때만 제대로 작동해요!)

#include <array>
#include <iostream>
#include <string_view>

namespace Color
{
    enum Type
    {
        black,     // 0
        red,       // 1
        blue,      // 2
        max_colors // 3
    };

    using namespace std::string_view_literals; // sv 접미사를 사용하기 위함
    constexpr std::array colorName { "black"sv, "red"sv, "blue"sv };
    static_assert(std::size(colorName) == max_colors);

    constexpr std::array types { black, red, blue }; // 모든 열거형 값들을 담고 있는 std::array 입니다
    static_assert(std::size(types) == max_colors);
};

constexpr std::string_view getColorName(Color::Type color)
{
    return Color::colorName[color];
}

// operator<< 에게 Color를 어떻게 출력하는지 알려줍니다
// std::ostream은 std::cout의 타입입니다
// 반환 타입과 매개변수 타입은 참조(reference)입니다 (불필요한 복사를 막기 위해서요)!
std::ostream& operator<<(std::ostream& out, Color::Type color)
{
    return out << getColorName(color);
}

int main()
{
    for (auto c: Color::types) // 성공: std::array에는 범위 기반 for문을 사용할 수 있습니다
        std::cout << c << '\n';

    return 0;
}

위의 예제 코드를 보면 Color::types 배열에 들어있는 요소들의 타입이 바로 Color::Type 입니다. 따라서 반복문을 돌 때 변수 c 의 타입도 자연스럽게 우리가 원하는 Color::Type 으로 알아서 맞춰집니다. 아주 깔끔하죠!

출력 결과는 다음과 같습니다:

black
red
blue

17.7 — C 스타일 배열 소개

이제 std::vector 와 std::array 를 배웠으니, 배열의 마지막 종류인 C 스타일 배열도 마저 알아보겠습니다.

16.1 수업 컨테이너와 배열 소개 에서 말했듯이, C 스타일 배열은 C 언어에서 물려받은 기능입니다. 그리고 다른 배열 종류와 달리, 이것은 C++ 표준 라이브러리 클래스가 아니라 C++ 언어 자체에 기본으로 들어 있는 기능 입니다. 그래서 C 스타일 배열을 쓰기 위해서는 #include 로 헤더 파일을 추가할 필요가 없습니다.

참고로 C++ 언어가 원래 직접 지원하는 배열은 C 스타일 배열뿐입니다. 그래서 표준 라이브러리의 배열 컨테이너인 std::array 나 std::vector 도 내부적으로는 보통 C 스타일 배열을 바탕으로 만들어집니다.

C 스타일 배열 선언하기

C 스타일 배열은 언어 자체 기능이기 때문에, 전용 선언 문법이 따로 있습니다. C 스타일 배열을 선언할 때는 대괄호 [] 를 써서, 이 변수가 C 스타일 배열이라고 컴파일러에게 알려줍니다.

대괄호 안에는 배열의 길이(length)를 넣을 수 있습니다. 이 길이는 std::size_t 형의 정수값이며, 배열 안에 원소가 몇 개 들어 있는지를 컴파일러에게 알려줍니다.

다음 정의는 testScore 라는 이름의 C 스타일 배열 변수를 만들고, 그 안에 int 형 원소 30개를 넣습니다.

int main()
{
    int testScore[30] {};      // testScore라는 이름의 C 스타일 배열을 정의한다. int 원소 30개가 값 초기화된다(헤더 포함 불필요)

//  std::array<int, 30> arr{}; // 비교용: 값 초기화된 int 원소 30개를 가진 std::array 예시(<array>를 #include 해야 함)

    return 0;
}

C 스타일 배열의 길이는 최소 1 이상이어야 합니다. 배열 길이가 0이거나, 음수이거나, 정수가 아니면 컴파일러가 오류를 냅니다.

심화 내용 힙(heap)에 동적으로 할당한 C 스타일 배열은 길이가 0인 것도 허용됩니다.

C 스타일 배열의 길이는 상수 표현식이어야 한다

std::array 와 마찬가지로, C 스타일 배열을 선언할 때 배열 길이는 상수 표현식 이어야 합니다. 즉, 컴파일하기 전에 값이 이미 확정되어 있어야 합니다. 형식은 std::size_t 여야 하지만, 대부분의 경우 이 점은 크게 신경 쓰지 않아도 됩니다.

팁 일부 컴파일러는 C99의 가변 길이 배열(VLA, variable-length array) 기능과 호환되도록, constexpr 가 아닌 길이도 허용할 수 있습니다.

하지만 가변 길이 배열은 정식 C++ 문법이 아닙니다 . 그러므로 C++ 프로그램에서는 사용하지 않는 것이 좋습니다.

만약 여러분의 컴파일러가 이런 배열을 허용한다면, 아마도 컴파일러 확장 기능을 끄지 않은 것일 가능성이 큽니다. (0.10 수업 컴파일러 설정: 컴파일러 확장 기능 참고)

C 스타일 배열에 인덱스로 접근하기

std::array 처럼, C 스타일 배열도 첨자 연산자 operator[] 로 원소에 접근할 수 있습니다.

#include <iostream>

int main()
{
    int arr[5]; // int 값 5개를 담는 배열 정의

    arr[1] = 7; // 첨자 연산자를 사용해 배열의 1번 원소에 접근
    std::cout << arr[1]; // 7 출력

    return 0;
}

표준 라이브러리 컨테이너 클래스들은 보통 인덱스로 std::size_t 같은 부호 없는 정수형 만 사용합니다. 하지만 C 스타일 배열의 인덱스는 부호 있는 정수든, 부호 없는 정수든, 어떤 정수형이든 사용할 수 있고, 범위 없는 열거형(unscoped enum)도 사용할 수 있습니다.

즉, 표준 라이브러리 컨테이너에서 자주 생기는 부호 변환 관련 인덱스 문제를 C 스타일 배열은 덜 겪습니다.

#include <iostream>

int main()
{
    const int arr[] { 9, 8, 7, 6, 5 };

    int s { 2 };
    std::cout << arr[s] << '\n'; // 부호 있는 인덱스를 사용해도 괜찮음

    unsigned int u { 2 };
    std::cout << arr[u] << '\n'; // 부호 없는 인덱스를 사용해도 괜찮음

    return 0;
}

팁 C 스타일 배열은 부호 있는 인덱스, 부호 없는 인덱스, 범위 없는 열거형 인덱스를 모두 받을 수 있습니다.

하지만 operator[] 는 범위 검사를 하지 않습니다. 그래서 배열 범위를 벗어난 인덱스를 넣으면 정의되지 않은 동작이 발생합니다.

참고로 배열을 선언할 때 int arr[5] 처럼 쓰는 [] 는 첨자 연산자 operator[] 를 호출하는 것이 아닙니다. 그것은 그냥 배열 선언 문법의 일부 입니다.

C 스타일 배열의 집합체 초기화

std::array 와 마찬가지로, C 스타일 배열도 집합체입니다. 그래서 집합체 초기화를 사용할 수 있습니다.

간단히 다시 말하면, 집합체 초기화는 집합체의 멤버를 중괄호 목록으로 한 번에 직접 초기화하는 방법 입니다. 즉, 중괄호 {} 안에 쉼표로 구분된 값들을 넣어서 초기화합니다.

int main()
{
    int fibonnaci[6] = { 0, 1, 1, 2, 3, 5 }; // 중괄호 목록을 사용한 복사 리스트 초기화
    int prime[5] { 2, 3, 5, 7, 11 };         // 중괄호 목록을 사용한 리스트 초기화(권장)

    return 0;
}

이 두 방식 모두 배열 원소를 0번부터 차례대로 초기화합니다.

만약 C 스타일 배열에 초기값을 주지 않으면, 원소들은 기본 초기화 됩니다. 대부분의 경우 이것은 원소들이 초기화되지 않은 상태로 남는다 는 뜻입니다.

보통은 원소가 제대로 초기화되길 원하므로, 초기값 없이 정의할 때는 빈 중괄호 {} 를 사용해서 값 초기화 하는 것이 좋습니다.

int main()
{
    int arr1[5];    // 멤버가 기본 초기화됨(int 원소들은 초기화되지 않은 채로 남음)
    int arr2[5] {}; // 멤버가 값 초기화됨(int 원소들은 0으로 초기화됨)(권장)

    return 0;
}

초기화 목록에 들어 있는 값의 개수가 배열 길이보다 많으면 컴파일러가 오류를 냅니다. 반대로 값의 개수가 배열 길이보다 적으면, 남은 원소들은 값 초기화됩니다.

int main()
{
    int a[4] { 1, 2, 3, 4, 5 }; // 컴파일 오류: 초기값이 너무 많음
    int b[4] { 1, 2 };          // arr[2]와 arr[3]는 값 초기화됨

    return 0;
}

C 스타일 배열의 단점 중 하나는, 원소 타입을 반드시 직접 써야 한다는 점입니다. C 스타일 배열은 클래스 템플릿이 아니기 때문에 CTAD(클래스 템플릿 인수 추론)가 동작하지 않습니다.

또한 auto 를 사용해서 초기화 목록으로부터 배열 원소 타입을 추론하게 하는 것도 불가능합니다.

int main()
{
    auto squares[5] { 1, 4, 9, 16, 25 }; // 컴파일 오류: C 스타일 배열에는 타입 추론을 사용할 수 없음

    return 0;
}

길이 생략하기

다음 배열 정의에는 살짝 중복되는 정보가 있습니다. 보이시나요?

int main()
{
    const int prime[5] { 2, 3, 5, 7, 11 }; // prime의 길이는 5

    return 0;
}

우리는 컴파일러에게 배열 길이가 5라고 직접 말했고, 동시에 초기값도 5개 넣었습니다. 즉, 같은 정보를 두 번 말한 셈입니다.

C 스타일 배열을 초기화 목록으로 초기화할 때는, 배열 정의에서 길이를 생략할 수 있습니다. 그러면 컴파일러가 초기값 개수를 보고 배열 길이를 알아서 계산해 줍니다.

다음 두 배열 정의는 똑같이 동작합니다.

int main()
{
    const int prime1[5] { 2, 3, 5, 7, 11 }; // prime1은 길이 5라고 직접 지정
    const int prime2[] { 2, 3, 5, 7, 11 };  // prime2는 컴파일러가 길이 5라고 추론

    return 0;
}

이 방법은 모든 배열 원소에 대해 초기값을 명시했을 때만 동작합니다.

int main()
{
    int bad[] {}; // 오류: 컴파일러는 이것을 길이 0 배열로 추론하는데, 길이 0 배열은 허용되지 않음

    return 0;
}

초기화 목록으로 C 스타일 배열의 모든 원소를 초기화할 때는, 배열 길이를 생략하고 컴파일러가 계산하게 하는 편이 더 좋습니다 .

그렇게 하면 나중에 초기값을 추가하거나 제거해도 배열 길이가 자동으로 맞춰집니다. 또한, 직접 적어 둔 배열 길이와 실제 초기값 개수가 서로 안 맞는 실수도 피할 수 있습니다.

권장 사항 모든 배열 원소를 명시적으로 초기화할 때는, C 스타일 배열의 길이를 생략하는 것을 권장합니다.

const 와 constexpr C 스타일 배열

std::array 와 마찬가지로, C 스타일 배열도 const 또는 constexpr 로 만들 수 있습니다. 다른 const 변수와 마찬가지로, const 배열은 반드시 초기화해야 하고, 한 번 정한 뒤에는 원소 값을 바꿀 수 없습니다.

#include <iostream>

namespace ProgramData
{
    constexpr int squares[5] { 1, 4, 9, 16, 25 }; // constexpr int로 이루어진 배열
}

int main()
{
    const int prime[5] { 2, 3, 5, 7, 11 }; // const int로 이루어진 배열
    prime[0] = 17; // 컴파일 오류: const int는 바꿀 수 없음

    return 0;
}

C 스타일 배열에 대한 sizeof

이전 수업에서 sizeof() 연산자는 객체나 타입의 크기를 바이트 단위 로 구한다고 배웠습니다. C 스타일 배열에 sizeof() 를 적용하면, 배열 전체가 차지하는 바이트 수 를 반환합니다.

#include <iostream>

int main()
{
    const int prime[] { 2, 3, 5, 7, 11 }; // 컴파일러가 prime의 길이를 5로 추론함

    std::cout << sizeof(prime); // 20 출력(단, int가 4바이트라고 가정)

    return 0;
}

int 가 4바이트라고 가정하면, 위 프로그램은 20을 출력합니다. prime 배열은 int 원소 5개를 가지고 있고, 각 원소가 4바이트이므로 5 * 4 = 20 바이트입니다.

여기에는 별도의 추가 정보(overhead)가 없습니다. C 스타일 배열 객체는 원소들만 가지고 있고, 그 외의 추가 데이터는 없습니다 .

C 스타일 배열의 길이 구하기

C++17에서는 <iterator> 헤더에 있는 std::size() 를 사용할 수 있습니다. 이 함수는 배열 길이를 부호 없는 정수값(std::size_t) 으로 돌려줍니다.

C++20에서는 std::ssize() 도 사용할 수 있는데, 이것은 배열 길이를 부호 있는 정수값 으로 돌려줍니다. (보통 std::ptrdiff_t 같은 큰 부호 있는 정수형입니다.)

#include <iostream>
#include <iterator> // std::size와 std::ssize용

int main()
{
    const int prime[] { 2, 3, 5, 7, 11 };   // 컴파일러가 prime의 길이를 5로 추론함

    std::cout << std::size(prime) << '\n';  // C++17, 부호 없는 정수값 5를 반환
    std::cout << std::ssize(prime) << '\n'; // C++20, 부호 있는 정수값 5를 반환

    return 0;
}

팁 std::size() 와 std::ssize() 의 정식 헤더는 <iterator> 입니다. 하지만 이 함수들이 워낙 자주 쓰이다 보니, <array> 나 <vector> 같은 다른 헤더에서도 함께 사용할 수 있는 경우가 많습니다.

다만 C 스타일 배열에 std::size() 또는 std::ssize() 를 쓸 때는, 다른 헤더를 이미 포함하지 않았을 수도 있습니다. 그럴 때는 보통 <iterator> 를 포함하는 것이 관례입니다.

이 함수들을 제공하는 전체 헤더 목록은 cppreference의 size 함수 문서에서 볼 수 있습니다.

C 스타일 배열의 길이 구하기(C++14 이하)

C++17 이전에는 C 스타일 배열의 길이를 구하는 표준 라이브러리 함수가 없었습니다.

만약 C++11 또는 C++14를 쓰고 있다면, 대신 다음 함수를 사용할 수 있습니다.

#include <cstddef> // std::size_t용
#include <iostream>

template <typename T, std::size_t N>
constexpr std::size_t length(const T(&)[N]) noexcept
{
    return N;
}

int main() {

    int array[]{ 1, 1, 2, 3, 5, 8, 13, 21 };
    std::cout << "The array has: " << length(array) << " elements\n";

    return 0;
}

이 코드는 함수 템플릿을 사용합니다. 이 함수는 C 스타일 배열을 참조(reference) 로 받고, 그 배열 길이를 나타내는 비타입 템플릿 매개변수 N 을 그대로 반환합니다.

아주 오래된 코드에서는, 배열 전체 크기를 원소 하나의 크기로 나누어서 길이를 구하는 방법도 자주 보입니다.

#include <iostream>

int main()
{
    int array[8] {};
    std::cout << "The array has: " << sizeof(array) / sizeof(array[0]) << " elements\n";

    return 0;
}

이 코드는 다음을 출력합니다.

The array has: 8 elements

이게 왜 될까요? 먼저, 배열 전체 크기는 다음과 같습니다.

배열 전체 크기 = 배열 길이 × 원소 하나의 크기

짧게 쓰면:

배열 크기 = 길이 × 원소 크기

이 식을 길이에 대해 정리하면:

길이 = 배열 크기 / 원소 크기

보통 원소 크기는 sizeof(array[0]) 로 구합니다. 그래서 다음 식이 나옵니다.

length = sizeof(array) / sizeof(array[0])

가끔은 이것을 다음처럼 쓰는 경우도 있습니다.

sizeof(array) / sizeof(*array)

이것도 같은 뜻입니다.

하지만 다음 수업에서 보겠지만, 이 공식은 배열이 decay된 경우 쉽게 깨질 수 있습니다. 그러면 프로그램이 예상치 못하게 망가질 수 있습니다.

반면 C++17의 std::size() 와 위에서 보여 준 length() 함수 템플릿은 이런 경우 컴파일 오류를 내기 때문에 더 안전합니다 .

관련 내용 배열 decay는 다음 수업 17.8 C 스타일 배열 decay 에서 다룹니다.

C 스타일 배열은 대입을 지원하지 않는다

조금 의외일 수 있지만, C++ 배열은 배열 전체에 대한 대입을 지원하지 않습니다.

int main()
{
    int arr[] { 1, 2, 3 }; // 괜찮음: 초기화는 가능
    arr[0] = 4;            // 개별 원소에 대한 대입은 가능
    arr = { 5, 6, 7 };     // 컴파일 오류: 배열 전체 대입은 불가능

    return 0;
}

기술적으로 말하면, 대입 연산의 왼쪽 피연산자는 수정 가능한 lvalue 여야 합니다. 그런데 C 스타일 배열은 그런 대상으로 취급되지 않기 때문에 이런 대입이 불가능합니다.

만약 C 스타일 배열에 새로운 값 목록을 통째로 넣고 싶다면, 가장 좋은 방법은 std::vector 를 쓰는 것입니다. 또는 C 스타일 배열의 각 원소를 하나씩 바꾸거나, std::copy 를 사용해서 다른 C 스타일 배열의 내용을 복사할 수도 있습니다.

#include <algorithm> // std::copy용

int main()
{
    int arr[] { 1, 2, 3 };
    int src[] { 5, 6, 7 };

    // src를 arr로 복사
    std::copy(std::begin(src), std::end(src), std::begin(arr));

    return 0;
}

정말 쉽게 이해하는 한 줄 요약

C 스타일 배열은 “같은 타입의 값을 여러 개 붙여서 저장하는, C++ 기본 내장 배열” 입니다. 다만 편리한 기능이 적고 실수하기 쉬워서, 현대 C++ 에서는 보통 std::array 나 std::vector 를 더 많이 씁니다.

17.8 — C 스타일 배열 decay

C 스타일 배열을 함수에 넘길 때 생기는 문제

C 언어를 만든 사람들은 한 가지 문제를 해결해야 했습니다. 먼저 아래처럼 아주 단순한 프로그램을 봅시다.

#include <iostream>

void print(int val)
{
    std::cout << val;
}

int main()
{
    int x { 5 };
    print(x);

    return 0;
}

print(x)를 호출하면, 인수 x의 값 5가 매개변수 val로 복사됩니다. 함수 안에서는 val의 값 5를 화면에 출력합니다. int 하나 복사하는 건 부담이 거의 없으니, 여기서는 아무 문제가 없습니다.

이제 비슷한 예제를 보겠습니다. 이번에는 int 하나가 아니라, 원소가 1000개인 C 스타일 int 배열을 사용합니다.

#include <iostream>

void printElementZero(int arr[1000])
{
    std::cout << arr[0]; // 첫 번째 원소의 값을 출력
}

int main()
{
    int x[1000] { 5 };   // 원소가 1000개인 배열 정의, x[0]은 5로 초기화
    printElementZero(x);

    return 0;
}

이 프로그램도 잘 컴파일되고, 예상대로 5를 출력합니다.

겉으로 보기에는 앞의 예제와 비슷하지만, 실제로는 예상과 조금 다르게 동작합니다. 왜냐하면 C 언어 설계자들이 두 가지 큰 문제를 동시에 해결하려고 특별한 방법을 만들었기 때문입니다.

첫 번째 문제는 이것입니다. 함수를 호출할 때마다 원소 1000개짜리 배열을 통째로 복사하면 비용이 큽니다. 원소 타입 자체도 복사 비용이 큰 타입이라면 더 부담스럽습니다. 그래서 복사를 피하고 싶었습니다. 그런데 C에는 참조(reference)가 없어서, 참조 전달로 복사를 피할 수 없었습니다.

두 번째 문제도 있습니다. 길이가 다른 배열들도 하나의 함수로 받고 싶었습니다. 예를 들어 위의 printElementZero()는 배열 길이가 몇이든, arr[0]만 있으면 되니 아무 길이의 배열이든 받는 게 이상적입니다. 배열 길이마다 함수를 하나씩 만드는 건 너무 불편합니다.

그런데 C에는 “길이가 아무거나인 배열”을 직접 표현하는 문법도 없고, 템플릿도 없고, 길이가 다른 배열끼리 자동 변환도 안 됩니다.

그래서 C 언어 설계자들은 아주 영리한 해결책을 만들었습니다. 이 방식은 호환성 때문에 C++에도 그대로 들어왔습니다.

#include <iostream>

void printElementZero(int arr[1000]) // 복사본을 만들지 않음
{
    std::cout << arr[0]; // 첫 번째 원소의 값을 출력
}

int main()
{
    int x[7] { 5 };      // 원소가 7개인 배열 정의
    printElementZero(x); // somehow works!

    return 0;
}

이상하게도 위 코드는 원소 7개짜리 배열을, 원소 1000개짜리 배열을 받는 것처럼 보이는 함수에 넘기고도 잘 동작합니다. 게다가 배열 복사도 일어나지 않습니다.

이번 단원에서는 이것이 어떻게 가능한지 살펴보겠습니다.

또한 C 설계자들이 고른 이 해결책이 왜 위험할 수 있는지, 그리고 왜 현대 C++에서는 그다지 좋은 방식이 아닌지도 함께 보겠습니다.

하지만 그 전에, 먼저 두 가지 하위 주제를 알아야 합니다.

배열이 포인터로 변환되는 것 (array decay)

대부분의 경우, C 스타일 배열이 식(expression) 안에서 사용되면, 배열은 자동으로 원소 타입을 가리키는 포인터로 바뀝니다. 이 포인터는 배열의 첫 번째 원소(인덱스 0)의 주소로 초기화됩니다.

이 현상을 보통 array decay(줄여서 decay)라고 부릅니다.

다음 프로그램을 보면 확인할 수 있습니다.

#include <iomanip> // std::boolalpha용
#include <iostream>

int main()
{
    int arr[5]{ 9, 7, 5, 3, 1 }; // 우리 배열의 원소 타입은 int

    // 먼저, arr가 int* 포인터로 decay된다는 것을 확인해 보자

    auto ptr{ arr }; // 값을 평가하면 arr가 decay됨, 타입 추론은 int*를 추론해야 함
    std::cout << std::boolalpha << (typeid(ptr) == typeid(int*)) << '\n'; // ptr의 타입이 int*이면 true 출력

    // 이제 이 포인터가 배열의 첫 번째 원소 주소를 가지고 있다는 것도 확인해 보자

    std::cout << std::boolalpha << (&arr[0] == ptr) << '\n';

    return 0;
}

작성자의 컴퓨터에서는 다음이 출력되었습니다.

true
true

배열이 decay되어 만들어진 포인터는 특별한 포인터가 아닙니다. 그냥 첫 번째 원소의 주소를 담고 있는 일반 포인터입니다.

마찬가지로, const 배열(예: const int arr[5])은 pointer-to-const, 즉 const int*로 decay됩니다.

팁

C++에서 C 스타일 배열이 decay되지 않는 흔한 경우는 몇 가지 있습니다.

• sizeof()나 typeid()의 인수로 사용될 때
• operator&로 배열 자체의 주소를 구할 때
• 클래스 타입의 멤버로 전달될 때
• 참조로 전달될 때

C 스타일 배열은 대부분의 경우 포인터로 decay되기 때문에, “배열은 곧 포인터다”라고 착각하기 쉽습니다. 하지만 이건 사실이 아닙니다.

배열 객체는 원소들이 순서대로 들어 있는 덩어리이고, 포인터 객체는 주소 하나를 저장하는 변수일 뿐입니다.

배열 타입과 decay된 배열의 타입 정보도 다릅니다. 위 예제에서 arr의 타입은 int[5]이고, decay된 후의 타입은 int*입니다.

중요한 차이는 이것입니다.

• int[5]에는 길이 정보가 들어 있음
• int*에는 길이 정보가 없음

핵심 통찰

decay된 배열 포인터는, 자신이 가리키는 배열의 길이를 알지 못합니다. “decay”라는 말은 바로 이 길이 정보가 사라진다는 뜻도 함께 담고 있습니다.

C 스타일 배열에 첨자([])를 쓰면, 사실 decay된 포인터에 operator[]를 적용하는 것이다

C 스타일 배열은 값으로 평가될 때 포인터로 decay되므로, 배열에 첨자 []를 붙이는 것도 사실은 decay된 포인터에 대해 첨자를 쓰는 것입니다.

#include <iostream>

int main()
{
    const int arr[] { 9, 7, 5, 3, 1 };
    std::cout << arr[2]; // decay된 배열에 첨자를 써서 2번 원소를 얻음, 5 출력

    return 0;
}

포인터에도 직접 operator[]를 사용할 수 있습니다. 그 포인터가 첫 번째 원소의 주소를 가지고 있다면, 결과는 똑같습니다.

#include <iostream>

int main()
{
    const int arr[] { 9, 7, 5, 3, 1 };

    const int* ptr{ arr };  // arr가 포인터로 decay됨
    std::cout << ptr[2];    // ptr에 첨자를 써서 2번 원소를 얻음, 5 출력

    return 0;
}

이게 왜 편리한지는 조금 뒤에 보게 됩니다. 그리고 이것이 정확히 어떻게 동작하는지, 또 포인터가 첫 번째 원소가 아닌 다른 곳을 가리키면 어떻게 되는지는 다음 단원 17.9 -- Pointer arithmetic and subscripting에서 더 자세히 다룹니다.

array decay는 C 스타일 배열 전달 문제를 해결해 준다

array decay는 이 단원 처음에 나온 두 가지 문제를 한 번에 해결합니다.

C 스타일 배열을 함수 인수로 넘기면, 배열은 포인터로 decay되고, 그 배열의 첫 번째 원소 주소를 담은 포인터가 함수로 전달됩니다.

즉, 겉으로는 배열을 값으로 전달하는 것처럼 보여도, 실제로는 주소를 전달하는 것입니다. 그래서 배열 전체 복사본을 만들지 않아도 됩니다.

핵심 통찰

C 스타일 배열은, 겉보기와 달리 값 전달이 아니라 주소 전달됩니다.

이제 같은 원소 타입이지만 길이가 다른 두 배열을 생각해 봅시다. 예를 들어 int[5]와 int[7]은 서로 다른 타입이라서 원래는 호환되지 않습니다.

하지만 둘 다 decay되면 똑같이 int*가 됩니다. 즉, 길이 정보가 사라지기 때문에 길이가 다른 배열도 같은 방식으로 전달할 수 있게 됩니다.

핵심 통찰

원소 타입이 같고 길이만 다른 두 C 스타일 배열은, decay되면 같은 포인터 타입으로 바뀝니다.

다음 예제에서는 두 가지를 보여 줍니다.

1. 길이가 다른 배열들을 하나의 함수에 넘길 수 있다는 것
2. 배열을 받는 함수 매개변수는 배열 원소 타입의 (const) 포인터로 선언할 수 있다는 것

#include <iostream>

void printElementZero(const int* arr) // const 주소 전달
{
    std::cout << arr[0];
}

int main()
{
    const int prime[] { 2, 3, 5, 7, 11 };
    const int squares[] { 1, 4, 9, 25, 36, 49, 64, 81 };

    printElementZero(prime);   // prime은 const int* 포인터로 decay됨
    printElementZero(squares); // squares는 const int* 포인터로 decay됨

    return 0;
}

이 예제는 잘 동작하고, 다음을 출력합니다.

2
1

main() 안에서 printElementZero(prime)를 호출하면, prime은 const int[5] 배열에서 const int* 포인터로 decay됩니다. 이 포인터는 prime의 첫 번째 원소 주소를 담고 있습니다.

마찬가지로 printElementZero(squares)를 호출하면, squares는 const int[8]에서 const int*로 decay됩니다. 그리고 역시 첫 번째 원소의 주소를 담습니다.

함수에 실제로 전달되는 것은 바로 이런 const int* 포인터들입니다.

그래서 printElementZero() 함수의 매개변수도 같은 포인터 타입인 const int*여야 합니다.

이 함수 안에서는 그 포인터에 첨자 []를 써서 원하는 배열 원소에 접근합니다.

C 스타일 배열은 주소로 전달되기 때문에, 함수는 복사본이 아니라 원본 배열에 직접 접근합니다. 따라서 함수가 배열 원소를 바꿀 수도 있습니다.

그래서 함수가 배열을 수정할 생각이 없다면, 매개변수에 const를 붙이는 것이 좋습니다.

C 스타일 배열을 받는 함수 매개변수 문법

매개변수를 int* arr처럼 선언하면, arr가 “정수 하나를 가리키는 포인터”인지, “배열의 첫 번째 원소를 가리키는 포인터”인지 한눈에 잘 드러나지 않습니다.

그래서 C 스타일 배열을 받을 때는, 보통 대체 문법인 int arr[]를 사용하는 편이 더 읽기 쉽습니다.

#include <iostream>

void printElementZero(const int arr[]) // const int*와 똑같이 처리됨
{
    std::cout << arr[0];
}

int main()
{
    const int prime[] { 2, 3, 5, 7, 11 };
    const int squares[] { 1, 4, 9, 25, 36, 49, 64, 81 };

    printElementZero(prime);   // prime은 포인터로 decay됨
    printElementZero(squares); // squares는 포인터로 decay됨

    return 0;
}

이 프로그램은 바로 앞 예제와 완전히 똑같이 동작합니다. 컴파일러는 함수 매개변수 const int arr[]를 const int*와 같은 의미로 해석하기 때문입니다.

하지만 arr[] 문법에는 장점이 있습니다. 이 매개변수가 “값 하나를 가리키는 포인터”가 아니라, decay된 C 스타일 배열을 받기 위한 것이라는 뜻을 더 잘 전달해 줍니다.

대괄호 안에는 길이 정보를 쓸 필요가 없습니다. 어차피 사용되지 않기 때문입니다. 길이를 써도 무시됩니다.

권장 사항

C 스타일 배열을 기대하는 함수 매개변수는 포인터 문법(int* arr)보다 배열 문법(int arr[])을 사용하는 것이 좋습니다.

다만 이 문법의 단점도 있습니다. 겉으로는 배열처럼 보여서, 사실은 이미 decay되어 포인터가 되었다는 점이 덜 눈에 띕니다. 그래서 decay된 배열에서는 기대대로 동작하지 않는 일을 실수로 하기가 더 쉽습니다. 이제 그런 문제들을 보겠습니다.

array decay의 문제점

array decay는 길이가 다른 C 스타일 배열을 복사 없이 함수에 넘길 수 있게 해 준 영리한 해결책이었습니다. 하지만 배열 길이 정보가 사라지기 때문에, 여러 종류의 실수가 생기기 쉽습니다.

첫 번째 문제는 sizeof()입니다. 배열과 decay된 배열(즉 포인터)에 대해 sizeof()는 서로 다른 값을 돌려줍니다.

#include <iostream>

void printArraySize(int arr[])
{
    std::cout << sizeof(arr) << '\n'; // 4 출력 (주소가 32비트라고 가정)
}

int main()
{
    int arr[]{ 3, 2, 1 };

    std::cout << sizeof(arr) << '\n'; // 12 출력 (int가 4바이트라고 가정)

    printArraySize(arr);

    return 0;
}

즉, C 스타일 배열에 sizeof()를 쓰는 것은 꽤 위험할 수 있습니다. 지금 내가 다루는 것이 진짜 배열 객체인지, 아니면 이미 decay된 포인터인지를 확실히 알아야 하기 때문입니다.

이전 단원 17.7 -- Introduction to C-style arrays에서는, 예전부터 sizeof(arr) / sizeof(*arr)를 C 스타일 배열 길이를 구하는 꼼수처럼 써 왔다고 말했습니다.

하지만 이 방식은 위험합니다. arr가 이미 decay되었다면, sizeof(arr)는 배열 크기가 아니라 포인터 크기를 반환합니다. 그러면 배열 길이를 잘못 계산하게 되고, 프로그램이 오작동할 가능성이 큽니다.

다행히 C++17의 std::size()(그리고 C++20의 std::ssize())는 포인터를 넘기면 컴파일 자체를 막아 줍니다.

#include <iostream>

int printArrayLength(int arr[])
{
    std::cout << std::size(arr) << '\n'; // 컴파일 오류: std::size()는 포인터에서 동작하지 않음
}

int main()
{
    int arr[]{ 3, 2, 1 };

    std::cout << std::size(arr) << '\n'; // 3 출력

    printArrayLength(arr);

    return 0;
}

두 번째 문제는, 어쩌면 더 중요할 수 있는데, 리팩터링을 어렵게 만든다는 점입니다. 즉, 긴 함수를 더 짧고 깔끔한 함수들로 나누는 과정에서 문제가 생기기 쉽습니다.

원래는 일반 배열로 잘 동작하던 코드가, 함수로 분리되면서 decay된 배열을 다루게 되면:

• 컴파일이 안 되거나
• 더 나쁘게는, 조용히 잘못 동작할 수도 있습니다

세 번째 문제는 길이 정보가 없어서 생기는 여러 실전 문제들입니다. 배열 길이를 모르면, 그 배열이 충분히 긴지 확인하기가 어렵습니다.

사용자는 함수가 기대하는 길이보다 짧은 배열을 넘길 수도 있고, 심지어 배열이 아니라 값 하나의 주소를 넘길 수도 있습니다. 그런데 함수가 아무 검증 없이 arr[2] 같은 접근을 해 버리면, 정의되지 않은 동작(undefined behavior)이 발생할 수 있습니다.

#include <iostream>

void printElement2(int arr[])
{
    // arr에 원소가 최소 3개 있는지 어떻게 보장할까?
    std::cout << arr[2] << '\n';
}

int main()
{
    int a[]{ 3, 2, 1 };
    printElement2(a);  // ok

    int b[]{ 7, 6 };
    printElement2(b);  // 컴파일은 되지만 정의되지 않은 동작 발생

    int c{ 9 };
    printElement2(&c); // 컴파일은 되지만 정의되지 않은 동작 발생

    return 0;
}

배열 길이를 모르면, 배열을 처음부터 끝까지 순회하는 것도 어렵습니다. 어디까지 가야 끝인지 알 수 없기 때문입니다.

물론 이런 문제를 피하는 방법은 있습니다. 하지만 그런 방법들은 프로그램을 더 복잡하게 만들고, 더 약하게(깨지기 쉽게) 만들기도 합니다.

배열 길이 문제를 우회하는 방법

전통적으로 프로그래머들은 배열 길이 정보가 없다는 문제를 두 가지 방식 중 하나로 해결해 왔습니다.

첫 번째 방법은 배열과 배열 길이를 따로따로 넘기는 것입니다.

#include <cassert>
#include <iostream>

void printElement2(const int arr[], int length)
{
    assert(length > 2 && "printElement2: Array too short"); // length에는 static_assert를 쓸 수 없음

    std::cout << arr[2] << '\n';
}

int main()
{
    constexpr int a[]{ 3, 2, 1 };
    printElement2(a, static_cast<int>(std::size(a)));  // ok

    constexpr int b[]{ 7, 6 };
    printElement2(b, static_cast<int>(std::size(b)));  // assert 발생

    return 0;
}

하지만 이 방법도 여전히 여러 문제가 있습니다.

• 호출하는 쪽에서 배열과 길이를 맞는 쌍으로 넘겨야 합니다. 길이를 잘못 넘기면 함수는 여전히 오작동할 수 있습니다.
• std::size()나 std::size_t를 반환하는 길이 함수와 함께 쓰면, 부호(sign) 변환 문제가 생길 수 있습니다.
• 런타임 assert는 실제 실행 중 그 코드가 지나갈 때만 잡힙니다. 테스트에서 놓친 호출 경로가 있으면, 사용자가 실제로 실행했을 때 터질 수도 있습니다.
• 현대 C++이라면 constexpr 배열 길이를 컴파일 타임에 검사하려고 static_assert를 쓰고 싶지만, 함수 매개변수는 constexpr가 될 수 없어서(심지어 constexpr 또는 consteval 함수 안에서도) 쉽지 않습니다.
• 이 방법은 명시적인 함수 호출일 때만 쓸 수 있습니다. 만약 함수 호출이 암묵적이라면(예: 배열을 피연산자로 쓰는 연산자 호출), 길이를 따로 넘길 기회가 없습니다.

두 번째 방법은, 의미상 유효하지 않은 특별한 값을 배열 끝 표시로 쓰는 것입니다. 예를 들어 시험 점수에 -1은 말이 안 된다고 하면, -1을 “여기가 끝”이라고 표시하는 식입니다.

이렇게 하면 배열 길이는 시작부터 그 끝 표시 원소까지 세어서 구할 수 있습니다. 배열 순회도 끝 표시가 나올 때까지 하면 됩니다.

이 방법의 좋은 점은, 암묵적인 함수 호출에서도 동작한다는 것입니다.

핵심 통찰

C 스타일 문자열도 C 스타일 배열이며, 문자열 끝을 표시하기 위해 널 종료 문자를 사용합니다. 그래서 문자열이 decay되더라도 끝을 찾으면서 순회할 수 있습니다.

하지만 이 방법도 문제점이 많습니다.

• 끝 표시 원소가 없으면, 순회가 배열 끝을 넘어가 버려서 정의되지 않은 동작이 발생합니다.
• 배열을 순회하는 함수는 끝 표시 원소를 특별 취급해야 합니다. 예를 들어 C 스타일 문자열 출력 함수는 종료 문자를 출력하면 안 됩니다.
• 실제 배열 길이와, 의미 있는 원소 개수가 서로 다릅니다. 길이를 잘못 다루면, 의미 없는 끝 표시 원소를 일반 데이터처럼 처리할 수도 있습니다.
• 이 방식은 “의미상 절대 쓸 수 없는 값”이 있을 때만 가능합니다. 그런데 실제로는 그런 값이 없는 경우도 많습니다.

대부분의 경우 C 스타일 배열은 피하는 것이 좋다

C 스타일 배열은 전달 방식도 일반적이지 않습니다. 겉보기에는 값 전달 같지만 실제로는 주소 전달입니다. 그리고 decay가 일어나면 길이 정보도 사라집니다.

이런 이유들 때문에 C 스타일 배열은 점점 덜 쓰이게 되었습니다. 가능하면 피하는 것을 권장합니다.

권장 사항

가능하다면 C 스타일 배열은 피하세요.

• 읽기 전용 문자열(문자열 리터럴 심볼 상수, 문자열 매개변수)에는 std::string_view를 우선 사용하세요.
• 수정 가능한 문자열에는 std::string을 우선 사용하세요.
• 전역이 아닌 constexpr 배열에는 std::array를 우선 사용하세요.
• constexpr가 아닌 배열에는 std::vector를 우선 사용하세요.

전역 constexpr 배열에는 C 스타일 배열을 사용해도 괜찮습니다. 이것은 바로 아래에서 설명합니다.

참고로...

C++에서는 배열을 참조로 전달할 수 있습니다. 이 경우 함수에 넘길 때 배열이 decay되지 않습니다. (다만 배열에 대한 참조도, 값을 평가하면 결국 decay될 수 있습니다.)

하지만 이 방식을 항상 빠짐없이 적용해야 하는데, 한 번이라도 참조를 빼먹으면 decay가 발생합니다. 게다가 배열 참조 매개변수는 길이가 고정되어 있어야 하므로, 함수가 특정 길이의 배열 하나만 처리할 수 있습니다.

길이가 다른 배열도 처리하려면 함수 템플릿까지 써야 합니다. 그런데 그렇게까지 해서 C 스타일 배열을 “고칠” 바에는, 그냥 std::array를 쓰는 편이 낫습니다.

그렇다면 현대 C++에서는 언제 C 스타일 배열을 사용할까?

현대 C++에서 C 스타일 배열은 보통 두 경우에 사용됩니다.

첫 번째는 constexpr 전역 데이터(또는 constexpr static local 데이터)를 저장할 때입니다. 이런 배열은 프로그램 어디서든 직접 접근할 수 있어서, 함수로 전달할 일이 적고, 따라서 decay 문제도 피하기 쉽습니다.

또한 C 스타일 배열 문법이 std::array보다 약간 덜 번거롭게 느껴질 수도 있습니다. 더 중요한 점은, 이런 배열에 인덱싱할 때 표준 라이브러리 컨테이너들처럼 부호 변환 문제를 덜 겪는다는 것입니다.

두 번째는, 함수나 클래스가 constexpr이 아닌 C 스타일 문자열 인수를 직접 처리하고 싶을 때입니다. 즉, 굳이 std::string_view로 바꾸라고 요구하지 않는 경우입니다.

이유는 두 가지가 있을 수 있습니다.

첫째, constexpr이 아닌 C 스타일 문자열을 std::string_view로 바꾸려면, 문자열 길이를 알아내기 위해 문자열을 한 번 끝까지 훑어야 합니다. 만약 함수가 성능이 매우 중요한 코드 구간에 있고, 길이 정보가 딱히 필요 없다면(예: 어차피 함수가 직접 문자열을 끝까지 순회할 예정이라면), 이 변환을 생략하는 것이 도움이 될 수 있습니다.

둘째, 그 함수나 클래스가 내부적으로 또 다른 C 스타일 문자열을 기대하는 함수들을 호출한다면, 굳이 std::string_view로 바꿨다가 다시 C 스타일 문자열 방식으로 맞추는 과정이 비효율적일 수 있습니다. (물론 std::string_view를 꼭 써야 할 다른 이유가 있다면 이야기는 달라집니다.)

17.9 — 포인터 연산과 배열 인덱싱(첨자)

이전 레슨 '16.1 -- 컨테이너와 배열 소개'에서 배열은 메모리 상에 순서대로 나란히 저장된다고 배웠습니다. 이번 레슨에서는 배열의 인덱스(몇 번째 요소인지 나타내는 번호)가 수학적으로 어떻게 작동하는지 조금 더 깊이 파헤쳐 보겠습니다.

앞으로의 레슨에서 이 인덱싱 수학을 직접 쓸 일은 많지 않겠지만, 이번 내용을 알아두면 범위 기반 for 문(range-based for loops)이 실제로 어떻게 작동하는지 이해하는 데 큰 도움이 됩니다. 또한 나중에 '반복자(iterators)'라는 개념을 배울 때 아주 유용하게 쓰일 거예요!

포인터 연산이란 무엇인가요?

포인터 연산이란 포인터(메모리 주소를 담는 변수)에 덧셈, 뺄셈, 1 증가(++), 1 감소(--) 같은 간단한 수학 계산을 해서 새로운 메모리 주소를 만들어내는 기능입니다.

어떤 포인터 ptr이 있다고 해볼게요. ptr + 1을 하면 단순히 주소 숫자에 1이 더해지는 게 아니라, 메모리 상에 있는 바로 다음 데이터의 주소를 알려줍니다. (포인터가 가리키는 데이터의 종류에 따라 몇 바이트를 건너뛸지 결정됩니다)

예를 들어, ptr이 정수형 포인터(int*)이고 정수(int)가 4바이트 크기라면, ptr + 1은 ptr의 주소에서 딱 4바이트 뒤에 있는 메모리 주소를 반환합니다. 마찬가지로 ptr + 2는 8바이트 뒤의 메모리 주소를 알려주겠죠.

#include <iostream>

int main()
{
    int x {};
    const int* ptr{ &x }; // int가 4바이트라고 가정해 봅시다

    std::cout << ptr << ' ' << (ptr + 1) << ' ' << (ptr + 2) << '\n';

    return 0;
}

원문 작성자의 컴퓨터에서는 이 코드가 다음과 같이 출력되었습니다.

00AFFD80 00AFFD84 00AFFD88

출력된 주소들을 잘 보면, 이전 주소보다 정확히 4바이트씩 커졌다는 것을 알 수 있습니다.

자주 쓰이진 않지만, 포인터 연산은 뺄셈도 가능합니다. 포인터 ptr이 있을 때, ptr - 1은 메모리 상에 있는 바로 앞 데이터의 주소를 알려줍니다.

#include <iostream>

int main()
{
    int x {};
    const int* ptr{ &x }; // int가 4바이트라고 가정해 봅시다

    std::cout << ptr << ' ' << (ptr - 1) << ' ' << (ptr - 2) << '\n';

    return 0;
}

원문 작성자의 컴퓨터에서는 다음과 같이 출력되었습니다.

00AFFD80 00AFFD7C 00AFFD78

이 경우에는 주소가 4바이트씩 작아진 것을 볼 수 있습니다. (참고로 C는 16진수에서 12를, 8은 8을 의미하므로 차이가 4입니다!)

핵심 통찰 포인터 연산은 단순히 주소 숫자에서 1을 더하거나 빼는 것이 아닙니다. 포인터가 가리키는 자료형의 크기를 기준으로, 다음/이전 데이터 객체의 주소를 반환하는 것입니다.

포인터에 증가 연산자(++)나 감소 연산자(--)를 붙이면 앞서 본 덧셈/뺄셈과 똑같이 작동합니다. 다만, 차이점은 포인터 변수 자체가 가지고 있는 주소 값을 실제로 변경한다는 것입니다.

정수 x가 있을 때 ++x는 x = x + 1을 짧게 쓴 것이죠? 마찬가지로 포인터 ptr이 있을 때 ++ptr은 ptr = ptr + 1을 짧게 쓴 것입니다. 포인터 연산을 한 다음 그 결과를 다시 ptr에 집어넣는 거죠.

#include <iostream>

int main()
{
    int x {};
    const int* ptr{ &x }; // int가 4바이트라고 가정해 봅시다

    std::cout << ptr << '\n';

    ++ptr; // ptr = ptr + 1
    std::cout << ptr << '\n';

    --ptr; // ptr = ptr - 1
    std::cout << ptr << '\n';

    return 0;
}

원문 작성자의 컴퓨터에서는 이렇게 출력되었습니다.

00AFFD80 00AFFD84 00AFFD80

주의 사항 엄밀히 말해서, 위 코드는 '정의되지 않은 동작'입니다. C++ 표준에 따르면 포인터 연산은 포인터와 그 결과값이 같은 배열 안에 속해 있을 때(혹은 배열의 마지막 요소 바로 다음을 가리킬 때)만 안전하게 작동한다고 정의되어 있습니다. 하지만 요즘 나오는 대부분의 C++ 컴파일러들은 이 규칙을 강제로 막지 않아서, 배열 바깥에서 포인터 연산을 해도 에러를 띄우지는 않는 경우가 많습니다. (그래도 조심하는 게 좋습니다!)

배열의 인덱스([])는 사실 포인터 연산입니다

이전 레슨 (17.8 -- C 스타일 배열 붕괴)에서 우리는 배열의 인덱스 기호(operator[])를 포인터에도 사용할 수 있다고 배웠습니다.

#include <iostream>

int main()
{
    const int arr[] { 9, 7, 5, 3, 1 };

    const int* ptr{ arr }; // 0번째 요소의 주소를 담고 있는 일반적인 포인터
    std::cout << ptr[2];   // ptr의 인덱스 2에 접근하여 요소를 가져옵니다. 5가 출력됩니다.

    return 0;
}

여기서 무슨 일이 일어나고 있는지 조금 더 자세히 들여다볼게요.

알고 보면 ptr[n] 이라는 인덱스 방식은, *((ptr) + (n)) 이라는 복잡한 코드를 아주 짧고 예쁘게 줄여 쓴 것에 불과합니다. 모양만 다를 뿐 사실 포인터 연산이라는 뜻이죠!

괄호는 연산이 올바른 순서로 되도록 막아준 것이고, 앞에 붙은 별표(*)는 그 주소에 있는 실제 값을 꺼내오는(역참조) 역할을 합니다.

과정을 쉽게 설명해 드릴게요:

1. 먼저 ptr에 arr을 넣어 초기화합니다. 배열 arr이 초기화에 사용되면, 배열은 '0번째 요소의 주소를 담은 포인터'로 슬쩍 변신(붕괴)합니다. 그래서 이제 ptr은 0번째 요소의 주소를 가지게 됩니다.
2. 그다음 ptr[2]를 출력합니다. ptr[2]는 *((ptr) + (2))와 같고, 이는 *(ptr + 2)와 같습니다. ptr + 2는 ptr에서 2칸 떨어진 데이터의 주소, 즉 '인덱스 2번' 요소의 주소를 찾아줍니다. 그리고 앞에 붙은 * 덕분에 그 주소 안에 있는 진짜 값(여기서는 5)이 뿅 하고 나타나는 것입니다.

다른 예시를 한 번 볼까요?

#include <iostream>

int main()
{
    const int arr[] { 3, 2, 1 };

    // 먼저, 인덱스([])를 사용해 배열 요소의 주소와 값을 가져와 봅시다
    std::cout << &arr[0] << ' ' << &arr[1] << ' ' << &arr[2] << '\n';
    std::cout << arr[0] << ' ' << arr[1] << ' ' << arr[2] << '\n';

    // 이제 포인터 연산을 사용해서 똑같은 작업을 해봅시다
    std::cout << arr<< ' ' << (arr+ 1) << ' ' << (arr+ 2) << '\n';
    std::cout << *arr<< ' ' << *(arr+ 1) << ' ' << *(arr+ 2) << '\n';

    return 0;
}

작성자의 컴퓨터에서는 이렇게 출력되었습니다.

00AFFD80 00AFFD84 00AFFD88 3 2 1 00AFFD80 00AFFD84 00AFFD88 3 2 1

arr이 주소 00AFFD80을 가지고 있다면, (arr + 1)은 4바이트 뒤의 주소를, (arr + 2)는 8바이트 뒤의 주소를 반환한다는 것을 알 수 있습니다. 이 주소들 앞에 *를 붙이면(역참조) 그 위치에 있는 값(3, 2, 1)을 얻을 수 있습니다.

배열 요소들은 메모리상에 항상 나란히 붙어있기 때문에, arr이 배열의 0번째 요소를 가리키는 포인터라면 *(arr + n)은 자연스럽게 배열의 n번째 요소가 됩니다.

이것이 바로 배열의 순서가 1이 아니라 0부터 시작하는 진짜 이유입니다! 0부터 시작해야 컴퓨터가 인덱스를 계산할 때 매번 1을 빼지 않아도 되어서 수학적으로 훨씬 효율적이거든요.

참고로... 재미있는 사실 하나 알려드릴게요! 컴파일러가 ptr[n]을 *((ptr) + (n))으로 바꿔서 계산한다고 했죠? 그렇기 때문에 덧셈의 순서를 바꿔서 n[ptr] 이라고 적어도 똑같이 작동합니다! 컴파일러가 이를 *((n) + (ptr))로 바꾸기 때문이죠. 하지만 코드를 읽는 사람을 엄청나게 헷갈리게 만드니까 절대 이렇게 쓰지는 마세요!

음수 인덱스도 가능하다고요?

지난 레슨에서 C 스타일 배열의 인덱스에는 양수(부호 없는 정수)뿐만 아니라 음수(부호 있는 정수)도 쓸 수 있다고 말씀드렸습니다. 단순한 편의를 위해서가 아닙니다. C 스타일 배열에서는 실제로 음수 인덱스를 쓰는 것이 가능하기 때문입니다. 이상하게 들리겠지만, 원리를 알면 말이 됩니다.

방금 *(ptr+1)이 메모리에서 다음 데이터를 가져오고, ptr[1]이 그것과 똑같은 기능이라고 배웠죠?

그렇다면 레슨 맨 처음에 배운 *(ptr-1)은 메모리에서 이전 데이터를 가져온다는 사실도 기억하시나요? 이걸 인덱스로 짧게 쓰면 어떻게 될까요? 맞습니다. 바로 ptr[-1]이 됩니다!

#include <array>
#include <iostream>

int main()
{
    const int arr[] { 9, 8, 7, 6, 5 };

    // ptr이 3번째 요소를 가리키도록 설정합니다
    const int* ptr { &arr[3] };

    // ptr이 3번째 요소를 가리키고 있다는 것을 증명해 봅시다
    std::cout << *ptr << ptr[0] << '\n'; // 66 출력
    // 놀랍게도 ptr[-1]은 2번째 요소입니다!
    std::cout << *(ptr-1) << ptr[-1] << '\n'; // 77 출력

    return 0;
}

포인터 연산으로 배열 훑어보기 (순회하기)

포인터 연산이 가장 많이 쓰이는 곳 중 하나는, 인덱스 번호를 쓰지 않고 C 스타일 배열의 처음부터 끝까지 쭉 훑어보는(순회하는) 작업입니다. 다음 코드가 어떻게 작동하는지 보세요.

#include <iostream>

int main()
{
    constexpr int arr[]{ 9, 7, 5, 3, 1 };

    const int* begin{ arr };                // begin은 시작 요소를 가리킵니다
    const int* end{ arr + std::size(arr) }; // end는 배열의 '마지막 요소 바로 다음 칸'을 가리킵니다

    for (; begin != end; ++begin)           // begin부터 end에 도달하기 전까지 반복합니다
    {
        std::cout << *begin << ' ';     // 현재 요소를 가져오기 위해 포인터를 역참조합니다
    }

    return 0;
}

위의 예제에서, 우리는 begin 포인터가 가리키는 요소(배열의 0번째 요소)부터 탐색을 시작합니다. begin과 end의 주소가 아직 다르므로(begin != end), 루프 안의 코드가 실행됩니다. 루프 안에서는 *begin을 통해 현재 위치의 값을 꺼내옵니다. 한 바퀴가 끝나면 ++begin을 실행해서 포인터가 다음 요소를 가리키도록 한 칸 전진시킵니다. 이 작업은 begin과 end가 완전히 같아질 때까지 계속 반복됩니다.

따라서 위 코드는 다음과 같이 출력됩니다. 9 7 5 3 1

여기서 end 포인터가 배열의 '마지막 요소 바로 다음 칸(one-past-the-end)'을 가리키도록 설정된 것에 주목하세요. 그 위치에 실제 데이터가 없더라도, 그 주소를 가지고만 있는 것은 문제가 되지 않습니다 (단, 그 주소에서 값을 꺼내오려고(*end) 하면 안 됩니다!). 이렇게 설정하면 계산이나 조건 비교가 아주 깔끔해져서 어디서 +1이나 -1을 억지로 해줄 필요가 없습니다.

팁 C 스타일 배열을 가리키는 포인터에서 포인터 연산을 할 때, 계산된 주소값이 유효한 배열 요소의 주소이거나 마지막 요소 바로 다음 칸이라면 안전합니다. 하지만 이 범위를 벗어난 주소를 계산하게 되면, (그 주소의 값을 읽으려 시도하지 않더라도) 정의되지 않은 동작(undefined behavior)이 발생하므로 주의해야 합니다.

이전 레슨 '17.8 -- C 스타일 배열 붕괴'에서, 배열이 포인터로 변해버리면(붕괴하면) 배열의 전체 크기를 구하는 std::size 같은 기능이 작동하지 않아서 코드를 수정하기 어렵다고 했습니다. 하지만 이렇게 시작(begin)과 끝(end) 포인터로 배열을 순회하는 방식을 쓰면, 반복문 부분을 깔끔하게 별도의 함수로 분리할 수 있습니다!

#include <iostream>

void printArray(const int* begin, const int* end)
{
    for (; begin != end; ++begin)   // begin부터 end에 도달하기 전까지 반복합니다
    {
        std::cout << *begin << ' '; // 현재 요소를 가져오기 위해 포인터를 역참조합니다
    }

    std::cout << '\n';
}

int main()
{
    constexpr int arr[]{ 9, 7, 5, 3, 1 };

    const int* begin{ arr };                // begin은 시작 요소를 가리킵니다
    const int* end{ arr + std::size(arr) }; // end는 배열의 '마지막 요소 바로 다음 칸'을 가리킵니다

    printArray(begin, end);

    return 0;
}

이 프로그램은 arr 배열 자체를 함수에 넘겨주지 않았는데도 아주 잘 작동합니다! 배열을 직접 전달하지 않았으니 배열이 붕괴되어 크기를 잃어버릴 걱정도 없죠. 대신 begin과 end라는 두 개의 포인터만으로 배열을 순회하는 데 필요한 모든 정보를 함수에 전달한 것입니다.

나중에 반복자(iterators)와 알고리즘(algorithms)을 배울 때 다시 보겠지만, C++ 표준 라이브러리에는 이렇게 begin과 end 쌍을 이용해서 데이터를 다루는 함수들이 정말 많답니다.

범위 기반 for 문도 사실 포인터 연산으로 만들어졌습니다

다음과 같은 아주 편리한 '범위 기반 for 문'을 생각해 봅시다.

#include <iostream>

int main()
{
    constexpr int arr[]{ 9, 7, 5, 3, 1 };

    for (auto e : arr)         // `begin`부터 `end`에 도달하기 전까지 반복합니다
    {
        std::cout << e << ' '; // 반복 변수를 통해 현재 요소를 가져옵니다
    }

    return 0;
}

만약 범위 기반 for 문의 공식 문서를 찾아본다면, 컴퓨터 내부에서는 이 반복문을 대략 이런 구조로 바꿔서 실행한다는 것을 알 수 있습니다.

{
    auto __begin = begin-expr; // 시작점
    auto __end = end-expr;     // 끝점

    for ( ; __begin != __end; ++__begin)
    {
        range-declaration = *__begin; // 현재 값을 변수에 담기
        loop-statement;               // 루프 안의 실제 코드 실행
    }
}

이 원리를 바탕으로, 앞서 보았던 범위 기반 for 문을 내부 구현 방식대로 직접 풀어서 써보겠습니다.

#include <iostream>

int main()
{
    constexpr int arr[]{ 9, 7, 5, 3, 1 };

    auto __begin = arr;                // arr이 시작점(begin-expr)이 됩니다
    auto __end = arr + std::size(arr); // arr + std::size(arr)이 끝점(end-expr)이 됩니다

    for ( ; __begin != __end; ++__begin)
    {
        auto e = *__begin;         // e라는 변수에 현재 포인터가 가리키는 값을 복사해 넣습니다
        std::cout << e << ' ';     // 여기가 루프 안에서 우리가 작성했던 코드입니다
    }

    return 0;
}

방금 전 '포인터 연산으로 배열 훑어보기' 섹션에서 우리가 직접 짰던 코드랑 완전히 똑같이 생겼죠?! 유일한 차이점이라면, 포인터에서 값을 꺼내올 때 *__begin을 그대로 쓰지 않고, 한 번 더 편하게 쓰기 위해 e라는 변수에 담아서 썼다는 것뿐입니다!

17.10 — C 스타일 문자열

이전 17.7 레슨(C 스타일 배열 소개)에서 우리는 여러 개의 데이터를 순서대로 모아두는 'C 스타일 배열'에 대해 배웠습니다. int testScore[30] {}; // 30개의 정수를 담을 수 있는 배열 (인덱스 번호는 0부터 29까지)

그리고 5.2 레슨(리터럴)에서는 "Hello, world!"처럼 문자들이 순서대로 모여 있는 것을 '문자열'이라고 불렀고, 'C 스타일 문자열 리터럴'이라는 개념도 소개했었죠.

여기서 "Hello, world!"라는 문자열은 const char[14]라는 타입을 가집니다. 눈에 보이는 13개의 글자에, 문자열의 끝을 알리는 숨겨진 '널 종료 문자(null-terminator)' 1개가 더해진 거예요.

혹시 눈치채셨나요? C 스타일 문자열은 사실 요소의 타입이 char나 const char로 이루어진 C 스타일 배열일 뿐입니다!

우리가 코드 안에 "안녕"처럼 따옴표로 묶인 C 스타일 문자열 리터럴을 쓰는 건 괜찮습니다. 하지만 C 스타일 문자열 '객체(변수)'를 직접 다루는 것은 요즘 현대 C++에서는 잘 쓰이지 않습니다. 다루기 까다롭고 위험하기 때문이죠. (그래서 요즘은 더 안전하고 편한 std::string이나 std::string_view를 주로 사용합니다). 그럼에도 불구하고 예전에 쓰인 코드들에서는 여전히 이 C 스타일 문자열을 자주 마주치게 될 테니, 꼭 알고 넘어가야 합니다.

그래서 이번 레슨에서는 현대 C++에서 C 스타일 문자열 객체를 다룰 때 꼭 알아야 할 가장 중요한 핵심들을 살펴보겠습니다.

C 스타일 문자열 정의하기

C 스타일 문자열 변수를 만드는 방법은 간단합니다. 그냥 char (또는 const char, constexpr char) 타입의 C 스타일 배열을 선언하면 됩니다.

char str1[8]{};                    // 8개의 문자를 담는 배열, 인덱스는 0부터 7까지
const char str2[]{ "string" };     // 7개의 문자를 담는 배열, 인덱스는 0부터 6까지
constexpr char str3[] { "hello" }; // 6개의 문자를 담는 배열, 인덱스는 0부터 5까지

항상 기억하세요! 눈에 보이지 않는 끝맺음 문자인 '널 종료 문자'를 담기 위해 늘 빈칸 1개가 더 필요합니다.

초기값을 넣어서 C 스타일 문자열을 만들 때는, 배열의 크기(길이)를 숫자로 직접 쓰지 말고 컴파일러가 알아서 계산하게 두는 것을 강력히 추천합니다. 이렇게 하면 나중에 문자열의 내용이 길어지거나 짧아져도 숫자를 일일이 수정할 필요가 없고, 널 종료 문자를 위한 공간을 깜빡 잊어버릴 위험도 없으니까요.

C 스타일 문자열은 붕괴(Decay)합니다

17.8 레슨에서 우리는 C 스타일 배열이 대부분의 상황에서 '포인터'로 변해버리는 현상(이를 붕괴라고 부릅니다)을 배웠습니다. C 스타일 문자열도 결국 배열이기 때문에 똑같이 포인터로 퇴화해 버립니다.

C 스타일 문자열 리터럴은 const char*로 퇴화하고, C 스타일 문자열 배열은 배열이 값을 바꿀 수 있는지(const 여부)에 따라 const char*나 char*로 퇴화합니다. 이렇게 문자열이 포인터로 모습이 바뀌어버리면, 문자열이 원래 얼마나 길었는지에 대한 길이 정보가 싹 사라지게 됩니다.

이처럼 길이 정보를 잃어버리기 때문에, C 스타일 문자열의 끝에는 항상 '널 종료 문자'가 달려있는 것입니다. 비록 길이가 몇인지 잊어버렸더라도, 처음부터 시작해서 이 널 종료 문자가 나올 때까지 글자 수를 하나하나 세면 (비효율적이긴 하지만) 길이를 다시 알아낼 수 있으니까요.

C 스타일 문자열 출력하기

C 스타일 문자열을 화면에 띄울 때, std::cout은 이 '널 종료 문자'를 만날 때까지 글자들을 계속 출력합니다. 널 종료 문자가 "여기가 문자열의 끝이야!"라고 표시해주기 때문에, 길이를 잃어버리고 퇴화한 문자열이라도 문제없이 끝까지 출력할 수 있는 겁니다.

#include <iostream>

void print(char ptr[]){
    std::cout << ptr << '\n'; // 문자열을 출력합니다
}

int main(){
    char str[]{ "string" };
    std::cout << str << '\n'; // 문자열을 출력합니다

    print(str);

    return 0;
}

만약 널 종료 문자가 없는 문자열을 출력하려고 하면 어떻게 될까요? (예를 들어 실수로 널 종료 문자를 다른 글자로 덮어써 버렸다면요) 결과는 '정의되지 않은 동작(예측할 수 없는 치명적인 오류)'으로 이어집니다. 가장 흔하게 일어나는 현상은, 원래 문자열을 다 출력하고 나서도 멈추지 않고 메모리 옆 칸을 계속 뒤지며 아무 글자나 마구잡이로 화면에 찍어내는 것입니다. 그러다 우연히 '0(널 종료 문자)'이 들어있는 메모리를 마주쳐야 겨우 멈추게 되죠!

C 스타일 문자열 입력받기

사용자에게 주사위를 원하는 만큼 굴린 다음, 나온 숫자들을 띄어쓰기 없이 쭉 적어보라고 한다고 상상해 봅시다 (예: 524412616). 사용자가 숫자를 몇 개나 적을까요? 우리는 전혀 알 수가 없습니다.

C 스타일 문자열은 한 번 크기를 정하면 늘어나거나 줄어들지 않는 '고정 크기 배열'이기 때문에, 이럴 땐 우리가 필요할 것 같은 최대 크기보다 훨씬 더 큰 배열을 넉넉하게 만들어 두는 것이 유일한 해결책입니다.

#include <iostream>

int main(){
    char rolls[255] {}; // 254개의 글자 + 널 종료 문자까지 담을 수 있을 만큼 충분히 큰 배열을 선언합니다
    std::cout << "Enter your rolls: ";
    std::cin >> rolls;
    std::cout << "You entered: " << rolls << '\n';

    return 0;
}

C++20 버전 이전에는 std::cin >> rolls가 띄어쓰기를 만나기 전까지 최대한 많은 글자를 rolls 배열에 쑤셔 넣으려고 했습니다. 문제는 사용자가 실수로든 고의로든 우리가 준비한 254글자보다 훨씬 많은 글자를 입력하는 걸 막을 방법이 없었다는 점입니다. 만약 그런 일이 발생하면, 사용자의 입력값이 rolls 배열의 크기를 넘쳐흘러 버리고 치명적인 오류(정의되지 않은 동작)가 발생합니다.

핵심 통찰 배열 오버플로우(Array overflow) 또는 버퍼 오버플로우(Buffer overflow)는 담을 수 있는 공간보다 더 많은 데이터가 복사될 때 발생하는 무서운 컴퓨터 보안 문제입니다. 이런 일이 생기면 허락된 공간 너머의 메모리 영역까지 덮어써 버려서 프로그램이 엉뚱하게 작동합니다. 악의적인 해커들은 이런 약점을 이용해 메모리 내용을 조작하고 자기들 입맛대로 프로그램을 오작동하게 만들기도 합니다.

이러한 문제 때문에 C++20부터는 >> 연산자가 '퇴화하지 않은(길이 정보를 그대로 가진)' C 스타일 문자열을 입력받을 때만 작동하도록 규칙이 바뀌었습니다. 덕분에 딱 배열의 길이만큼만 글자를 가져올 수 있어서 넘쳐흐르는 것을 막을 수 있죠. 하지만 동시에, 이미 포인터로 퇴화해버린 C 스타일 문자열에는 더 이상 >> 연산자로 값을 입력받을 수 없다는 뜻이기도 합니다.

그래서 std::cin을 사용해 C 스타일 문자열을 읽어 들일 때 가장 추천하는 안전한 방법은 다음과 같습니다.

#include <iostream>
#include <iterator> // std::size를 사용하기 위해 포함합니다

int main(){
    char rolls[255] {}; // 254개의 글자 + 널 종료 문자까지 담을 수 있을 만큼 충분히 큰 배열을 선언합니다
    std::cout << "Enter your rolls: ";
    std::cin.getline(rolls, std::size(rolls));
    std::cout << "You entered: " << rolls << '\n';

    return 0;
}

이렇게 cin.getline()을 사용하면 빈칸(띄어쓰기)을 포함해서 최대 254글자까지만 rolls 배열에 안전하게 읽어 들입니다. 공간을 넘어서는 나머지 글자들은 그냥 버려지죠. getline()은 글자를 얼마나 읽을지 길이를 정해줄 수 있기 때문에 최대 한도액을 알려줄 수 있습니다. 배열이 퇴화하지 않은 상태라면 std::size()를 써서 전체 크기를 쉽게 구해 넣을 수 있습니다. 하지만 퇴화된 배열이라면 다른 꼼수로 길이를 알아내야 하고, 실수로 엉뚱한 길이를 입력해버리면 프로그램이 망가지거나 보안에 구멍이 뚫릴 수 있습니다.

요즘의 현대 C++에서는 사용자에게 글자를 입력받아 저장할 때 std::string을 사용하는 것이 훨씬 더 안전합니다. std::string은 글자가 들어오는 양에 맞춰 알아서 척척 자기 크기를 늘려주기 때문입니다.

C 스타일 문자열 수정하기

여기서 한 가지 꼭 알아두어야 할 점은, C 스타일 문자열도 C 스타일 배열과 똑같은 규칙을 따른다는 것입니다. 즉, 처음 만들 때 값을 넣어서 초기화하는 것은 가능하지만, 일단 한 번 만들어진 다음에는 = 연산자로 새로운 통짜 문자열을 집어넣을 수 없다는 뜻입니다!

char str[]{ "string" }; // 정상: 처음 만들 때 초기화하는 것은 괜찮습니다
str = "rope";           // 오류: 만들어진 이후에 = 으로 새로운 값을 대입하는 것은 안 됩니다!

이런 제약 때문에 C 스타일 문자열을 다루는 게 조금 성가시게 느껴집니다.

하지만 C 스타일 문자열도 본질은 결국 '배열'이기 때문에, [] 기호(인덱스)를 사용해서 문자열 안에 있는 특정 글자 딱 하나만 콕 집어서 바꾸는 건 얼마든지 가능합니다.

#include <iostream>

int main(){
    char str[]{ "string" };
    std::cout << str << '\n';
    str[1] = 'p';
    std::cout << str << '\n';

    return 0;
}

이 프로그램을 실행하면 다음과 같이 출력됩니다. string spring

C 스타일 문자열의 길이 알아내기

거듭 강조하지만 C 스타일 문자열은 C 스타일 배열입니다. 그래서 std::size() (C++20부터는 std::ssize())를 사용해서 배열의 전체 길이를 알아낼 수 있습니다. 하지만 여기서 주의해야 할 두 가지 함정이 있습니다.

1. 퇴화된(포인터로 쪼그라든) 문자열에서는 이 방법이 먹히지 않습니다.
2. 이 방법은 진짜 글자 수가 아니라, 숨겨진 널 종료 문자를 포함해서 '이 C 스타일 배열이 메모리에서 차지하는 전체 칸 수'를 알려줍니다.

#include <iostream>

int main(){
    char str[255]{ "string" }; // 6개의 실제 글자 + 널 종료 문자
    std::cout << "length = " << std::size(str) << '\n'; // 출력 결과: length = 255

    char *ptr { str };
    std::cout << "length = " << std::size(ptr) << '\n'; // 컴파일 오류가 발생합니다!

    return 0;
}

이를 해결하는 다른 방법은 <cstring> 헤더 파일 안에 있는 strlen() 함수를 사용하는 것입니다. strlen()은 퇴화된 배열에서도 아주 잘 작동하며, 숨겨진 널 종료 문자를 뺀 '순수한 글자 수'만 깔끔하게 세어서 반환해 줍니다.

#include <cstring> // std::strlen을 사용하기 위해 포함합니다
#include <iostream>

int main(){
    char str[255]{ "string" }; // 6개의 실제 글자 + 널 종료 문자
    std::cout << "length = " << std::strlen(str) << '\n'; // 출력 결과: length = 6

    char *ptr { str };
    std::cout << "length = " << std::strlen(ptr) << '\n';   // 출력 결과: length = 6

    return 0;
}

하지만 안타깝게도 std::strlen() 함수는 좀 느린 편입니다. 길이를 한 번에 바로 아는 게 아니라, 배열의 맨 처음부터 시작해서 널 종료 문자를 만날 때까지 글자를 일일이 하나씩 세어가며 발품을 팔아야 하기 때문입니다.

기타 C 스타일 문자열 조작 함수들

C 스타일 문자열은 이름 그대로 과거 C 언어 시절의 주력 문자열 형태였습니다. 그래서 C 언어에는 이를 쪼개고 붙이고 다루기 위한 다양한 도구(함수)들이 많이 준비되어 있죠. C++은 이 함수들을 고스란히 물려받아서 <cstring> 헤더에 잘 모아두었습니다.

오래된 코드들을 보다 보면 마주치게 될 유용한 옛날 함수 몇 가지를 소개합니다.

• strlen() -- C 스타일 문자열의 길이(글자 수)를 알려줍니다.
• strcpy(), strncpy(), strcpy_s() -- 한 문자열을 다른 문자열에 덮어씁니다(복사).
• strcat(), strncat() -- 한 문자열의 맨 끝부분에 다른 문자열을 꼬리표처럼 이어 붙입니다.
• strcmp(), strncmp() -- 두 문자열이 서로 똑같은지 비교합니다. (완전히 똑같으면 0을 반환합니다).

하지만 strlen()을 제외하고는, 특별한 이유가 없다면 이 함수들을 사용하지 않는 것을 강력히 권장합니다.

const가 아닌 C 스타일 문자열 객체는 피하세요

const가 붙지 않아서 내용을 언제든 바꿀 수 있는(non-const) C 스타일 문자열은 꼭 써야 할 명확하고 어쩔 수 없는 이유가 없다면 피하는 것이 상책입니다. 다루기도 매우 불편할뿐더러, 아까 말했던 메모리를 넘쳐버리는 오류(오버런)가 생기기 딱 좋기 때문입니다. 이런 오류는 프로그램에 원인을 알 수 없는 고장을 일으키거나 보안 문제를 일으킬 수 있습니다.

메모리가 극단적으로 부족한 기기용 프로그램을 짜는 등 아주 드물게 고정된 크기의 버퍼나 C 스타일 문자열을 꼭 써야만 하는 상황이라면, 차라리 검증이 끝난 훌륭한 외부 라이브러리(3rd party fixed-length string library)를 가져다 쓰시는 것을 추천합니다.

권장 사항 값을 수정할 수 있는(non-const) C 스타일 문자열 변수는 피하시고, 대신 훨씬 똑똑하고 안전한 std::string을 사용하세요.

17.11 — C스타일 문자열 기호 상수

이전 레슨(17.10 - C스타일 문자열)에서는 C스타일 문자열을 만들고 그 안에 값을 넣는(초기화) 방법에 대해 알아보았습니다.

#include <iostream>

int main()
{
    char name[]{ "Alex" }; // C스타일 문자열
    std::cout << name << '\n';

    return 0;
}

C++에서는 값이 변하지 않는(상수) C스타일 문자열을 만드는 두 가지 방법을 제공합니다.

#include <iostream>

int main()
{
    const char name[] { "Alex" };        // 방법 1: C스타일 문자열 글자 그대로(리터럴) 초기화된 const C스타일 문자열
    const char* const color{ "Orange" }; // 방법 2: C스타일 문자열 리터럴을 가리키는 const 포인터

    std::cout << name << ' ' << color << '\n';

    return 0;
}

이 코드를 실행하면 다음과 같이 출력됩니다. Alex Orange

위의 두 가지 방법은 똑같은 결과를 만들어내지만, C++이 컴퓨터의 메모리(저장 공간)를 사용하는 방식에는 약간 차이가 있습니다.

방법 1의 경우, 먼저 "Alex"라는 글자가 메모리 어딘가(아마도 읽기만 가능한 구역)에 저장됩니다. 그러고 나서 프로그램은 길이가 5인 배열('A', 'l', 'e', 'x' 4글자 + 끝을 알리는 빈칸 문자 하나)을 담을 빈 공간을 새로 만들고, 그곳에 "Alex"를 복사해서 집어넣습니다. 결과적으로 "Alex"가 두 개(어딘가에 숨겨진 원본 하나, name 변수가 가진 복사본 하나) 생기는 셈이죠. 어차피 name은 const(상수)라서 앞으로 내용이 바뀔 일도 없는데, 굳이 복사본을 만드는 건 메모리를 낭비하는 비효율적인 방식입니다.

방법 2의 경우, 컴파일러(코드를 번역해 주는 프로그램)마다 처리 방식이 다를 수 있습니다. 하지만 보통은 "Orange"라는 글자를 읽기 전용 메모리에 한 번만 떡하니 저장해 두고, 그 위치(주소)를 포인터가 가리키게만 만듭니다. (불필요한 복사본을 만들지 않아요!)

프로그램을 더 빠르고 효율적으로 만들기 위해(최적화), 똑같은 글자들은 하나의 값으로 묶일 수도 있습니다. 예를 들어볼까요?

const char* name1{ "Alex" };
const char* name2{ "Alex" };

"Alex"라는 글자가 두 번 쓰였죠? 이 글자들은 어차피 변하지 않는 상수이기 때문에, 컴파일러는 메모리를 아끼기 위해 "Alex"를 딱 한 번만 저장해 둡니다. 그리고 name1과 name2가 모두 그 똑같은 저장 위치(주소)를 가리키게 공유하도록 만듭니다.

const C스타일 문자열의 타입 알아서 맞추기 (타입 추론)

C스타일 문자열에서 auto를 사용해 알아서 타입을 맞추게(타입 추론) 하는 것은 꽤 간단하고 직관적입니다.

auto s1{ "Alex" };  // const char* 타입으로 추론됨
auto* s2{ "Alex" }; // const char* 타입으로 추론됨
auto& s3{ "Alex" }; // const char(&)[5] 타입으로 추론됨 (길이가 5인 배열의 참조)

포인터와 C스타일 문자열 출력하기

여러분은 std::cout이 포인터의 종류에 따라 화면에 출력하는 방식이 조금 다르다는 걸 눈치채셨을 수도 있습니다. 다음 예시를 살펴볼까요?

#include <iostream>

int main()
{
    int narr[]{ 9, 7, 5, 3, 1 };
    char carr[]{ "Hello!" };
    const char* ptr{ "Alex" };

    std::cout << narr << '\n'; // narr은 int* 타입으로 변환(decay)됩니다.
    std::cout << carr << '\n'; // carr은 char* 타입으로 변환(decay)됩니다.
    std::cout << ptr << '\n';  // ptr은 이미 char* 타입입니다. (원문 주석의 name은 ptr의 오타입니다)

    return 0;
}

글쓴이의 컴퓨터에서는 이 코드가 다음과 같이 출력되었습니다.

003AF738
Hello!
Alex

왜 숫자(int) 배열은 메모리 주소(003AF738 같은 이상한 값)를 출력하고, 문자(char) 배열은 글자를 그대로 출력했을까요?

정답은 std::cout 같은 출력 기능이 여러분의 '의도'를 짐작하기 때문입니다. 문자가 아닌 다른 종류의 포인터를 넘겨주면, 포인터가 가지고 있는 원래 값(즉, 메모리 주소)을 그대로 화면에 보여줍니다. 하지만 char*나 const char* 타입(문자 포인터)을 넘겨주면, std::cout은 속으로 "아! 이 사람은 글자를 화면에 보여주고 싶구나!"라고 생각합니다. 그래서 메모리 주소를 보여주는 대신, 그 주소가 가리키고 있는 진짜 글자들을 출력해 버리는 것입니다!

대부분의 경우에는 이렇게 알아서 해주는 게 무척 편리하지만, 가끔은 생각지도 못한 엉뚱한 결과를 낳기도 합니다. 아래 코드를 볼까요?

#include <iostream>

int main()
{
    char c{ 'Q' };
    std::cout << &c;

    return 0;
}

이 코드를 작성한 사람은 문자 c가 저장된 진짜 메모리 주소(&c)를 확인하고 싶었을 겁니다. 하지만 &c는 타입이 char*(문자 포인터)가 되어버리죠. 그래서 std::cout은 눈치 없이 이것을 글자로 착각하고 출력하려고 시도합니다! 문제는 문자 c 뒤에는 문자열이 끝났다는 표시(널 종단자, null terminator)가 없기 때문에, 프로그램이 고장 난 것처럼 엉뚱하게 작동하게 됩니다(정의되지 않은 동작).

글쓴이의 컴퓨터에서는 이런 식으로 외계어가 출력되었습니다. Q╠╠╠╠╜╡4;¿■A

왜 이런 짓을 한 걸까요? 먼저 std::cout은 &c(문자 포인터)를 C스타일 문자열로 착각했습니다. 그래서 'Q'를 출력하고 멈추지 않고 계속 다음 메모리 공간으로 전진했습니다. 그 뒤의 메모리에는 알 수 없는 쓰레기 값들이 잔뜩 들어있었던 거죠. 그렇게 쓰레기 값들을 막 출력하다가, 우연히 0이라는 값이 들어있는 메모리를 만나고 나서야 "아! 여기서 문자열이 끝났구나!"라고 생각하고 출력을 멈춘 겁니다. 여러분의 컴퓨터에서는 변수 c 뒤에 어떤 메모리가 있느냐에 따라 전혀 다른 외계어가 보일 수도 있습니다.

사실 실제 코딩을 하면서 문자 변수의 메모리 주소를 출력하고 싶어 하는 경우는 거의 없기 때문에 흔하게 겪을 일은 아닙니다. 하지만 이 예시는 컴퓨터 내부에서 데이터가 어떻게 처리되는지, 그리고 프로그램이 어떻게 의도치 않은 방향으로 폭주할 수 있는지를 아주 잘 보여줍니다.

만약 정말로 문자 포인터(char*)의 메모리 주소를 꼭 화면에 출력하고 싶다면, static_cast라는 기능을 써서 타입을 const void*로 강제로 바꿔주면 됩니다.

#include <iostream>

int main()
{
    const char* ptr{ "Alex" };

    std::cout << ptr << '\n';                           // ptr을 C스타일 문자열(글자)로 출력합니다.
    std::cout << static_cast<const void*>(ptr) << '\n'; // ptr이 가지고 있는 메모리 주소를 출력합니다.

    return 0;
}

관련 컨텐츠 void*에 대해서는 19.5 레슨(Void 포인터)에서 다룰 예정입니다. 지금 당장 이게 어떻게 작동하는지 몰라도 여기서 쓰는 데는 전혀 문제없습니다.

C스타일 문자열 상수 대신 std::string_view를 사용하세요

요즘 사용하는 최신 C++에서는 굳이 C스타일 문자열 기호 상수를 쓸 이유가 거의 없습니다. 대신에 constexpr std::string_view 객체를 사용하는 것이 훨씬 좋습니다. 속도도 똑같이 빠르거나 오히려 더 빠르고, 헷갈리지 않고 항상 일관되게 작동하기 때문입니다.

권장 사항 C스타일 문자열 기호 상수는 피하고, 대신 constexpr std::string_view를 사용하는 것을 강력히 추천합니다!

17.12 — 다차원 C스타일 배열

틱택토(Tic-tac-toe) 게임을 떠올려보세요. 빙고랑 비슷한 게임이죠! 이 게임의 기본 판은 3x3 격자 모양이고, 두 명의 플레이어가 번갈아 가며 'X'와 'O' 기호를 그립니다. 기호 3개를 한 줄로 먼저 잇는 사람이 이기는 게임이죠.

게임판의 데이터를 9개의 개별 변수에 따로따로 저장할 수도 있겠지만, 우리는 이미 똑같은 종류의 데이터를 여러 개 다룰 때는 '배열(array)'이라는 묶음을 사용하는 게 훨씬 편하다는 것을 알고 있습니다.

int ttt[9]; // 정수형 C스타일 배열 (값 0 = 빈칸, 1 = 플레이어 1, 2 = 플레이어 2)

이 코드는 메모리에 9개의 칸이 일렬로 나란히 늘어선 C스타일 배열을 만듭니다. 우리는 이 데이터들이 아래처럼 한 줄로 쭉 늘어서 있다고 상상할 수 있어요.

// ttt[0] ttt[1] ttt[2] ttt[3] ttt[4] ttt[5] ttt[6] ttt[7] ttt[8]

배열의 차원(dimension)이라는 건, 배열 안의 특정 값을 콕 집어내기 위해 '방 번호(인덱스)'가 몇 개나 필요한지를 말합니다. 차원이 딱 하나뿐인 배열을 1차원 배열(single-dimensional array 또는 one-dimensional array)이라고 부릅니다. (줄여서 1d 배열이라고도 해요). 위에서 만든 ttt가 바로 1차원 배열의 예시입니다. ttt[2]처럼 방 번호 하나만 쓰면 원하는 값을 꺼낼 수 있으니까요.

하지만 가만히 생각해 보면, 한 줄로 길게 늘어선 이 1차원 배열은 평면(2차원) 공간에서 진행되는 실제 틱택토 게임판의 모습과는 거리가 좀 멉니다. 우리는 이것보다 더 멋진 방법을 쓸 수 있어요.

2차원 배열 (Two-dimensional arrays)

이전 수업에서 우리는 배열 안에 어떤 형태의 데이터든 다 넣을 수 있다고 배웠습니다. 이 말은 즉, 배열의 알맹이로 '또 다른 배열'을 넣을 수도 있다는 뜻입니다! 그런 배열을 만드는 방법은 아주 간단해요.

int a[3][5]; // 5개의 정수를 가진 배열이 3개 들어있는 배열

이렇게 배열 안에 배열이 들어있는 것을 2차원 배열(two-dimensional array, 줄여서 2d 배열)이라고 부릅니다. 방 번호를 적는 대괄호 []가 두 개 붙어있기 때문이죠.

2차원 배열을 다룰 때는 첫 번째(왼쪽) 괄호가 행(가로줄)을 고르고, 두 번째(오른쪽) 괄호가 열(세로칸)을 고른다고 생각하면 이해하기 아주 쉽습니다. 머릿속으로 이 2차원 배열이 아래와 같은 표 모양으로 펼쳐져 있다고 상상해 보세요.

//      열 0     열 1     열 2     열 3     열 4
// a[0][0] a[0][1] a[0][2] a[0][3] a[0][4]   행 0
// a[1][0] a[1][1] a[1][2] a[1][3] a[1][4]   행 1
// a[2][0] a[2][1] a[2][2] a[2][3] a[2][4]   행 2

2차원 배열의 값을 꺼내거나 바꿀 때는 그냥 괄호 두 개를 써주면 됩니다.

a[2][3] = 7; // a[행][열], 즉 행이 2이고 열이 3인 위치의 값

이제 이 방법을 쓰면 틱택토 게임판도 2차원 배열로 완벽하게 만들 수 있습니다!

int ttt[3][3];

짠! 이제 행과 열 번호를 이용해 아주 쉽게 다룰 수 있는 3x3 모양의 게임판이 완성되었습니다.

다차원 배열

차원이 2개 이상인 배열을 통틀어 다차원 배열이라고 부릅니다.

C++는 2차원을 넘어 3차원, 4차원 그 이상의 다차원 배열도 얼마든지 만들 수 있게 해줍니다.

int threedee[4][4][4]; // 4x4x4 배열 (정수 4개가 든 배열 4개가 다시 4개 모인 배열)

예를 들어, 유명한 게임 '마인크래프트'의 지형은 16x16x16 크기의 블록들(청크 섹션이라고 부름)로 나뉘어져 있는데, 이런 3차원 공간을 다룰 때 아주 유용하겠죠.

물론 3차원보다 더 복잡한 배열도 지원하지만, 실제로 쓰이는 일은 거의 없습니다.

2차원 배열은 메모리에 어떻게 저장될까?

컴퓨터의 메모리(램)는 일직선으로 된 1차원 공간입니다. 그래서 다차원 배열이라 할지라도 실제로는 그냥 한 줄로 길게 쭉 늘어서서 저장됩니다.

아래와 같은 2차원 배열이 있을 때, 메모리에 저장하는 방식에는 크게 두 가지가 있습니다.

//      열 0     열 1     열 2     열 3     열 4
// [0][0] [0][1] [0][2] [0][3] [0][4]   행 0
// [1][0] [1][1] [1][2] [1][3] [1][4]   행 1
// [2][0] [2][1] [2][2] [2][3] [2][4]   행 2

C++는 '행 우선 순서(row-major order)'라는 방식을 사용합니다. 이 방식은 위에서부터 한 가로줄(행)씩 차례대로, 왼쪽에서 오른쪽 방향으로 쭉 메모리에 채워 넣는 방식입니다.

[0][0] [0][1] [0][2] [0][3] [0][4] [1][0] [1][1] [1][2] [1][3] [1][4] [2][0] [2][1] [2][2] [2][3] [2][4]

포트란(Fortran) 같은 일부 다른 프로그래밍 언어들은 반대로 '열 우선 순서(column-major order)'를 사용합니다. 이건 세로칸(열)을 먼저 위에서 아래로 다 채우고, 그다음 오른쪽 세로칸으로 넘어가는 방식이죠.

[0][0] [1][0] [2][0] [0][1] [1][1] [2][1] [0][2] [1][2] [2][2] [0][3] [1][3] [2][3] [0][4] [1][4] [2][4]

C++에서 배열을 처음 만들고 값을 채워 넣을 때(초기화할 때), 값들은 바로 이 '행 우선 순서'대로 들어갑니다. 따라서 우리가 코드로 배열의 값들을 하나씩 훑어볼 때도, 컴퓨터 메모리에 저장된 순서(가로줄 먼저)대로 읽어들이는 것이 가장 빠르고 효율적입니다.

2차원 배열 초기화하기 (Initializing two-dimensional arrays)

2차원 배열에 처음 값을 넣어줄 때는 중괄호 {} 안에 또 중괄호를 넣어서 묶어주는 것이 제일 알아보기 쉽습니다. 안쪽에 있는 중괄호 한 덩어리가 가로줄(행) 하나를 뜻하게 됩니다.

int array[3][5]{
  { 1, 2, 3, 4, 5 },     // 행 0
  { 6, 7, 8, 9, 10 },    // 행 1
  { 11, 12, 13, 14, 15 } // 행 2
};

일부 똑똑한 컴파일러들은 안쪽 중괄호를 생략해도 알아서 처리해주지만, 코드를 읽기 쉽게 만들기 위해 꼭 안쪽 중괄호까지 모두 적어주는 것을 강력히 권장합니다.

안쪽 중괄호를 썼는데 배열의 전체 칸 수보다 값을 적게 넣었다면, 나머지 빈칸들은 알아서 0으로 채워집니다(값 초기화).

int array[3][5]{
  { 1, 2 },          // 행 0 = 1, 2, 0, 0, 0
  { 6, 7, 8 },       // 행 1 = 6, 7, 8, 0, 0
  { 11, 12, 13, 14 } // 행 2 = 11, 12, 13, 14, 0
};

값을 채워 넣으면서 배열을 만들 때는, 오직 가장 왼쪽(첫 번째) 대괄호 안의 숫자만 비워둘 수 있습니다.

int array[][5]{
  { 1, 2, 3, 4, 5 },
  { 6, 7, 8, 9, 10 },
  { 11, 12, 13, 14, 15 }
};

이렇게 하면, 컴퓨터(컴파일러)가 안쪽 중괄호 덩어리 개수를 직접 세어보고 "아, 행이 3개구나!" 하고 알아서 계산해 주기 때문입니다.

하지만 가장 왼쪽이 아닌 다른 대괄호들을 비워두는 것은 허용되지 않습니다. (에러가 나요!)

int array[][]{
  { 1, 2, 3, 4 },
  { 5, 6, 7, 8 }
};

당연히 일반 배열처럼 다차원 배열의 모든 칸을 한 번에 0으로 꽉 채울 수도 있습니다. 아주 간단하죠.

int array[3][5] {};

2차원 배열과 반복문

1차원 배열에 들어있는 모든 값을 한 번씩 다 확인하고 싶을 때는 반복문 하나면 충분했습니다.

#include <iostream>

int main()
{
    int arr[] { 1, 2, 3, 4, 5 };

    // 인덱스를 사용하는 for 반복문
    for (std::size_t i{0}; i < std::size(arr); ++i)
        std::cout << arr[i] << ' ';

    std::cout << '\n';

    // 범위 기반 for 반복문
    for (auto e: arr)
        std::cout << e << ' ';

    std::cout << '\n';

    return 0;
}

하지만 2차원 배열은 가로와 세로가 있으니 반복문이 2개 필요합니다. 하나는 '행'을 고르고, 다른 하나는 '열'을 골라야 하니까요.

반복문 2개를 겹쳐 쓸 때는, 어떤 것을 '바깥쪽 반복문'으로 하고 어떤 것을 '안쪽 반복문'으로 할지 결정해야 합니다. 방금 전에 컴퓨터가 일하기 편하게 하려면 메모리에 저장된 순서대로 접근하는 것이 가장 효율적이라고 했죠? C++는 가로줄(행)을 먼저 저장하는 '행 우선 순서'를 사용하니까, 가로줄(행)을 고르는 것을 바깥쪽 반복문으로 두고, 세로칸(열)을 고르는 것을 안쪽 반복문으로 두는 것이 가장 좋습니다.

#include <iostream>

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

    // 인덱스를 사용하는 이중 for 반복문
    for (std::size_t row{0}; row < std::size(arr); ++row) // std::size(arr)는 행의 개수를 반환합니다
    {
        for (std::size_t col{0}; col < std::size(arr[0]); ++col) // std::size(arr[0])은 열의 개수를 반환합니다
            std::cout << arr[row][col] << ' ';

        std::cout << '\n';
    }

    // 범위 기반 이중 for 반복문
    for (const auto& arow: arr) // 각 행 배열을 가져옵니다
    {
        for (const auto& e: arow) // 그 행 안의 각 원소를 가져옵니다
            std::cout << e << ' ';

        std::cout << '\n';
    }

    return 0;
}

2차원 배열 실전 예제 (A two-dimensional array example)

그럼 이제 2차원 배열을 실제로 어떻게 써먹는지 구구단(곱셈표)을 만드는 예제를 통해 살펴볼까요?

#include <iostream>

int main()
{
    constexpr int numRows{ 10 };
    constexpr int numCols{ 10 };

    // 10x10 배열 선언하기
    int product[numRows][numCols]{};

    // 구구단 계산하기
    // 어떤 수든 0을 곱하면 0이 되니까, 0행과 0열은 굳이 계산할 필요가 없어요.
    for (std::size_t row{ 1 }; row < numRows; ++row)
    {
        for (std::size_t col{ 1 }; col < numCols; ++col)
        {
            product[row][col] = static_cast<int>(row * col);
        }
    }

    for (std::size_t row{ 1 }; row < numRows; ++row)
    {
        for (std::size_t col{ 1 }; col < numCols; ++col)
        {
            std::cout << product[row][col] << '\t';
        }

        std::cout << '\n';
    }

    return 0;
}

이 프로그램은 1부터 9까지의 모든 구구단 값을 계산하고 화면에 예쁘게 표 형태로 보여줍니다. 표를 출력할 때 잘 보면, for 반복문이 0이 아니라 1부터 시작한다는 점을 알 수 있어요. 0행과 0열을 그대로 출력하면 화면에 숫자 0만 가득 찰 테니까, 그걸 빼고 출력하려고 일부러 1부터 시작한 거랍니다! 결과는 아래와 같습니다.

1    2    3    4    5    6    7    8    9    
2    4    6    8    10    12    14    16    18    
3    6    9    12    15    18    21    24    27    
4    8    12    16    20    24    28    32    36    
5    10    15    20    25    30    35    40    45    
6    12    18    24    30    36    42    48    54    
7    14    21    28    35    42    49    56    63    
8    16    24    32    40    48    56    64    72    
9    18    27    36    45    54    63    72    81    

데카르트 좌표계 vs 배열 인덱스

수학이나 기하학에서는 물건의 위치를 설명할 때 '데카르트 좌표계'라는 것을 자주 사용합니다. 말이 좀 어렵지만, 중학교 수학 시간에 배운 가로축(x)과 세로축(y)이 있는 그래프를 떠올리면 됩니다! 가로축은 "x", 세로축은 "y"라고 부르는 게 일반적이죠.

2차원 평면에서 어떤 물건의 위치는 { x, y } 쌍으로 표현할 수 있습니다. 여기서 x좌표는 중심에서 오른쪽으로 얼마나 떨어져 있는지, y좌표는 위로 얼마나 올라가 있는지를 나타냅니다. (참고로 컴퓨터 그래픽에서는 종종 y축이 반대로 뒤집혀서, y좌표가 아래쪽으로 얼마나 내려갔는지를 뜻하기도 합니다).

자, 그럼 우리가 배운 C++의 2차원 배열 모양을 다시 살펴볼까요?

//      열 0     열 1     열 2     열 3     열 4
// [0][0]  [0][1]  [0][2]  [0][3]  [0][4]  행 0
// [1][0]  [1][1]  [1][2]  [1][3]  [1][4]  행 1
// [2][0]  [2][1]  [2][2]  [2][3]  [2][4]  행 2

사실 이것도 일종의 2차원 좌표계입니다. 어떤 값의 위치를 [행][열] 로 나타내는 것뿐이죠. (수학 그래프와 달리 세로축 방향이 아래를 향하고 있다는 점이 다릅니다).

수학의 좌표계나 배열의 좌표계, 각자 따로 놓고 보면 이해하기 꽤 쉬운데요. 문제는 수학의 좌표인 { x, y }를 배열의 방 번호인 [행][열]로 바꾸려고 할 때 직관적이지 않아서 헷갈리기 쉽다는 점입니다.

핵심 통찰 여기서 아주 중요한 사실을 하나 알려드릴게요! 수학 좌표계의 'x좌표(가로)'는 배열 시스템에서 '몇 번째 열(column)인지'를 뜻합니다. 반대로 'y좌표(세로)'는 '몇 번째 행(row)인지'를 뜻하죠. 따라서 수학의 { x, y } 좌표를 배열에 쓰려면 [y][x] 순서로 적어줘야 합니다. 우리가 평소에 생각하는 x, y 알파벳 순서와 완전히 반대인 셈이죠!

이런 이유 때문에 코드로 2차원 반복문을 작성하다 보면 아래와 같은 모양이 만들어집니다.

for (std::size_t y{0}; y < std::size(arr); ++y) // 바깥쪽 반복문은 행, 즉 y를 나타냅니다
{
    for (std::size_t x{0}; x < std::size(arr[0]); ++x) // 안쪽 반복문은 열, 즉 x를 나타냅니다
        std::cout << arr[y][x] << ' '; // y(행)를 먼저 쓰고, 그 다음 x(열)를 써서 값을 꺼냅니다

여기서 배열의 값을 arr[y][x] 순서로 꺼내고 있다는 점을 꼭 기억해 두세요. 알파벳 순서가 거꾸로라서 처음엔 많이 어색하겠지만, 금방 익숙해지실 겁니다!

17.13 — 다차원 std::array

이전 레슨에서는 C 스타일의 다차원 배열(마치 엑셀 표처럼 가로세로로 늘어선 배열)에 대해 이야기했어요.

// C 스타일의 2차원 배열
int arr[3][4] {
    { 1, 2, 3, 4 },
    { 5, 6, 7, 8 },
    { 9, 10, 11, 12 }
};

하지만 아시다시피, 프로그램 전체에서 쓰는 전역 데이터를 저장할 때를 제외하고는 C 스타일 배열은 가급적 피하는 것이 좋습니다.

이번 레슨에서는 안전하고 현대적인 std::array를 사용해 다차원 배열을 어떻게 다루는지 알아볼 거예요. 초보자분들도 이해하기 쉽도록 아주 쉽게 풀어서 설명해 드릴게요!

표준 라이브러리에는 다차원 배열을 위한 클래스가 따로 없습니다

std::array는 기본적으로 1차원(한 줄짜리) 배열로 만들어져 있어요. 그럼 당연히 "다차원 배열을 위한 전용 표준 클래스는 없나요?"라는 궁금증이 생기겠죠. 정답은... 안타깝게도 없습니다.

2차원 std::array 만들기

2차원 std::array를 만드는 가장 정석적인 방법은 std::array 안에 또 다른 std::array를 넣는 거예요. 마치 상자 안에 상자를 넣는 마트료시카 인형처럼요! 코드로 보면 다음과 같습니다.

std::array<std::array<int, 4>, 3> arr {{  // 이중 중괄호 {{ }} 에 주의하세요
    { 1, 2, 3, 4 },
    { 5, 6, 7, 8 },
    { 9, 10, 11, 12 }
}};

여기서 눈여겨볼 만한 점들이 몇 가지 있어요:

• 다차원 std::array에 초기값을 넣어줄 때는 바깥쪽에 이중 중괄호 {{ }}를 사용해야 해요.
• 코드를 작성하는 방식이 꽤 길고 읽기도 어렵습니다.
• 템플릿이 안으로 중첩되는 방식 때문에 배열의 크기 순서가 뒤집혀 보입니다. 우리는 보통 3행 4열(3줄, 각 줄에 4개) 배열을 만들고 싶을 때 arr[3][4]라고 생각하는 게 자연스럽죠. 하지만 std::array<std::array<int, 4>, 3>에서는 숫자의 순서가 반대로 되어 있습니다. (안쪽 배열이 4칸짜리이고, 그 묶음이 총 3줄 있다는 뜻이에요.)

요소를 꺼내 쓰는(인덱싱) 방법은 C 스타일 2차원 배열과 똑같습니다:

std::cout << arr[1][2]; // 1번 행(두 번째 줄), 2번 열(세 번째 칸)의 요소를 출력합니다

또한 1차원 배열처럼 함수에 통째로 넘겨줄 수도 있어요:

#include <array>
#include <iostream>

template <typename T, std::size_t Row, std::size_t Col>
void printArray(const std::array<std::array<T, Col>, Row> &arr)
{
    for (const auto& arow: arr)   // 배열의 각 행(가로줄)을 가져옵니다
    {
        for (const auto& e: arow) // 해당 행의 각 요소를 가져옵니다
            std::cout << e << ' ';

        std::cout << '\n';
    }
}

int main()
{
    std::array<std::array<int, 4>, 3>  arr {{
        { 1, 2, 3, 4 },
        { 5, 6, 7, 8 },
        { 9, 10, 11, 12 }
    }};

    printArray(arr);

    return 0;
}

으악, 괄호가 너무 많아서 눈이 아프죠? 이건 겨우 2차원일 뿐이에요. 3차원, 4차원으로 넘어가면 코드는 훨씬 더 길고 끔찍해집니다!

별칭 템플릿으로 2차원 std::array 쉽게 만들기

이전 레슨에서 '타입 별칭(Type alias)'을 배우면서, 복잡한 타입에 짧고 쉬운 별명을 붙여줄 수 있다고 했었죠. 하지만 일반적인 타입 별칭을 쓰면 아래처럼 템플릿에 들어갈 모든 정보를 하나하나 고정해서 적어줘야 합니다.

using Array2dint34 = std::array<std::array<int, 4>, 3>;

이렇게 하면 3x4 크기의 2차원 정수 배열이 필요할 때마다 Array2dint34라는 이름을 쓸 수 있어요. 하지만 크기나 데이터 종류가 바뀔 때마다 이런 별칭을 매번 새로 만들어야 한다면 너무 귀찮겠죠!

이럴 때 별칭 템플릿(alias template)을 쓰면 아주 완벽합니다! 별칭을 만들 때 저장할 데이터의 종류(타입), 행(가로줄)의 개수, 열(세로줄)의 개수를 우리가 템플릿의 재료로 직접 지정해줄 수 있거든요.

// 2차원 std::array를 위한 별칭 템플릿
template <typename T, std::size_t Row, std::size_t Col>
using Array2d = std::array<std::array<T, Col>, Row>;

이제 3x4 크기의 2차원 정수 배열이 필요하면 언제 어디서든 그냥 Array2d<int, 3, 4>라고 쓰면 됩니다. 훨씬 깔끔해졌죠!

전체 예제 코드를 볼까요?

#include <array>
#include <iostream>

// 2차원 std::array를 위한 별칭 템플릿
template <typename T, std::size_t Row, std::size_t Col>
using Array2d = std::array<std::array<T, Col>, Row>;

// Array2d를 함수 매개변수로 사용할 때는 템플릿 매개변수를 다시 지정해 주어야 합니다
template <typename T, std::size_t Row, std::size_t Col>
void printArray(const Array2d<T, Row, Col> &arr)
{
    for (const auto& arow: arr)   // 배열의 각 행을 가져옵니다
    {
        for (const auto& e: arow) // 해당 행의 각 요소를 가져옵니다
            std::cout << e << ' ';

        std::cout << '\n';
    }
}

int main()
{
    // 3행 4열의 2차원 정수 배열을 정의합니다
    Array2d<int, 3, 4> arr {{
        { 1, 2, 3, 4 },
        { 5, 6, 7, 8 },
        { 9, 10, 11, 12 }
    }};

    printArray(arr);

    return 0;
}

코드가 얼마나 짧고 쓰기 편해졌는지 확인해 보세요!

이 별칭 템플릿의 또 다른 멋진 점은 우리가 원하는 순서대로 규칙을 정할 수 있다는 거예요. 원래 std::array는 '타입'을 먼저 쓰고 '크기'를 쓰기 때문에 그 규칙은 따랐습니다. 하지만 행(Row)과 열(Col) 중 무엇을 먼저 쓸지는 우리 마음이에요. C 스타일 배열이 행을 먼저 쓰는 방식이므로, 우리도 덜 헷갈리게 행(Row)을 열(Col)보다 먼저 쓰도록 만들었습니다.

이 방식은 3차원 이상의 복잡한 배열로 확장할 때도 아주 유용합니다.

// 3차원 std::array를 위한 별칭 템플릿
template <typename T, std::size_t Row, std::size_t Col, std::size_t Depth>
using Array3d = std::array<std::array<std::array<T, Depth>, Col>, Row>;

2차원 배열의 각 차원 길이 구하기

1차원 배열에서는 .size() 함수를 써서 배열의 길이를 쉽게 알 수 있었죠. 그런데 2차원 배열에서는 어떨까요? 이 경우 그냥 .size()를 호출하면 첫 번째 차원(보통 행의 개수인 3)의 길이만 달랑 알려줍니다.

이럴 때 원하는 차원의 요소를 하나 콕 집어낸 다음, 거기에 대고 .size()를 부르면 어떨까 하고 솔깃한 생각이 들 수 있어요. (하지만 꽤 위험한 방법이랍니다!)

#include <array>
#include <iostream>

// 2차원 std::array를 위한 별칭 템플릿
template <typename T, std::size_t Row, std::size_t Col>
using Array2d = std::array<std::array<T, Col>, Row>;

int main()
{
    // 3행 4열의 2차원 정수 배열을 정의합니다
    Array2d<int, 3, 4> arr {{
        { 1, 2, 3, 4 },
        { 5, 6, 7, 8 },
        { 9, 10, 11, 12 }
    }};

    std::cout << "Rows: " << arr.size() << '\n';    // 첫 번째 차원(행)의 길이를 구합니다
    std::cout << "Cols: " << arr[0].size() << '\n'; // 두 번째 차원(열)의 길이를 구합니다. 만약 첫 번째 차원의 길이가 0이라면 정의되지 않은 동작(오류)이 발생합니다!

    return 0;
}

첫 번째 차원(행)의 길이를 알기 위해 배열 전체에 .size()를 불렀습니다. 두 번째 차원(열)의 길이를 알려면, 먼저 arr[0]으로 첫 번째 줄을 꺼내온 다음 거기에 .size()를 부른 거죠. 3차원 배열이라면 arr[0][0].size()라고 했을 거예요.

하지만 위 코드는 큰 문제가 하나 있습니다. 만약 마지막 차원을 제외한 다른 차원의 길이가 0일 경우, 없는 걸 꺼내오려다 프로그램이 꼬여버리는 '미정의 동작(undefined behavior)'이 발생하게 됩니다!

더 안전하고 좋은 방법은, 우리가 템플릿을 만들 때 넘겨준 숫자에서 직접 길이를 가져오는 전용 함수를 따로 만드는 거예요.

#include <array>
#include <iostream>

// 2차원 std::array를 위한 별칭 템플릿
template <typename T, std::size_t Row, std::size_t Col>
using Array2d = std::array<std::array<T, Col>, Row>;

// Row 매개변수에서 행의 개수를 가져옵니다
template <typename T, std::size_t Row, std::size_t Col>
constexpr int rowLength(const Array2d<T, Row, Col>&) // 원한다면 std::size_t를 반환해도 됩니다
{
    return Row;
}

// Col 매개변수에서 열의 개수를 가져옵니다
template <typename T, std::size_t Row, std::size_t Col>
constexpr int colLength(const Array2d<T, Row, Col>&) // 원한다면 std::size_t를 반환해도 됩니다
{
    return Col;
}

int main()
{
    // 3행 4열의 2차원 정수 배열을 정의합니다
    Array2d<int, 3, 4> arr {{
        { 1, 2, 3, 4 },
        { 5, 6, 7, 8 },
        { 9, 10, 11, 12 }
    }};

    std::cout << "Rows: " << rowLength(arr) << '\n'; // 첫 번째 차원(행)의 길이를 구합니다
    std::cout << "Cols: " << colLength(arr) << '\n'; // 두 번째 차원(열)의 길이를 구합니다

    return 0;
}

이렇게 하면 배열의 실제 데이터가 아니라 배열의 '타입 정보'만 보고 길이를 알아내기 때문에, 길이가 0이어도 오류가 나지 않아요. 또한 굳이 강제로 형변환할 필요 없이 배열의 길이를 우리에게 익숙한 int 자료형으로 쉽게 받아올 수 있다는 장점도 있습니다.

2차원 배열 납작하게 펴기

차원이 2개 이상인 다차원 배열은 초보자뿐만 아니라 숙련자에게도 다루기 꽤 까다롭습니다:

• 만들거나 사용할 때 코드가 길고 복잡해집니다.
• 두 번째 이상의 차원 길이를 알아내기가 번거롭습니다.
• 반복문으로 모든 데이터를 살펴보기가 점점 더 어려워집니다 (차원이 늘어날수록 for문도 그 안에 겹겹이 계속 추가해야 하거든요).

다차원 배열을 좀 더 쉽게 다루는 꿀팁 중 하나는 바로 배열을 납작하게 펴는 것(flatten)입니다. 여러 방향으로 표처럼 늘어선 배열을 그냥 하나의 긴 1차원 배열(한 줄)로 줄여버리는 과정을 말해요.

예를 들어, 가로줄(Row)과 세로줄(Col)을 가진 2차원 배열을 억지로 만드는 대신, 단순히 Row * Col개의 요소를 가진 기다란 1차원 배열 하나를 만드는 거예요. 공간은 똑같이 차지하면서 형태만 단순해지는 거죠.

하지만 1차원 배열은 한 줄짜리라서 그 자체만으로는 2차원처럼 행렬 좌표를 써서 다룰 수는 없습니다. 이를 해결하기 위해, 겉보기엔 2차원 배열처럼 쓸 수 있게 해주는 '도구(인터페이스)'를 만들어 덮어씌울 수 있어요. 사용자가 가로, 세로 좌표를 입력하면, 이 도구가 알아서 1차원 배열의 알맞은 위치를 계산해 연결해 주는 원리입니다.

C++11 이상의 버전에서 이 방법을 어떻게 쓰는지 예제로 확인해 볼까요?

#include <array>
#include <iostream>
#include <functional>

// 두 개의 차원을 사용해 1차원 std::array를 정의할 수 있게 해주는 별칭 템플릿
template <typename T, std::size_t Row, std::size_t Col>
using ArrayFlat2d = std::array<T, Row * Col>;

// ArrayFlat2d를 2차원처럼 다룰 수 있게 해주는 수정 가능한 뷰(view)
// 이것은 뷰(보기 창)이므로, 대상이 되는 ArrayFlat2d가 메모리에 살아있어야 합니다
template <typename T, std::size_t Row, std::size_t Col>
class ArrayView2d
{
private:
    // m_arr을 ArrayFlat2d에 대한 참조자(&)로 만들고 싶을 수 있지만,
    // 참조자는 한 번 연결되면 대상을 바꿀 수 없어서 복사 할당이 불가능해집니다.
    // std::reference_wrapper를 사용하면 참조처럼 작동하면서도 복사 할당이 가능해집니다.
    std::reference_wrapper<ArrayFlat2d<T, Row, Col>> m_arr {};

public:
    ArrayView2d(ArrayFlat2d<T, Row, Col> &arr)
        : m_arr { arr }
    {}

    // 단일 인덱스로 요소 가져오기 (operator[] 사용)
    T& operator[](int i) { return m_arr.get()[static_cast<std::size_t>(i)]; }
    const T& operator[](int i) const { return m_arr.get()[static_cast<std::size_t>(i)]; }

    // 2차원 인덱스로 요소 가져오기 (C++23 이전에는 operator[]가 다중 차원을 지원하지 않아 operator()를 사용함)
    T& operator()(int row, int col) { return m_arr.get()[static_cast<std::size_t>(row * cols() + col)]; }
    const T& operator()(int row, int col) const { return m_arr.get()[static_cast<std::size_t>(row * cols() + col)]; }

    // C++23부터는 다차원 operator[]가 지원되므로 아래 주석을 해제하고 사용할 수 있습니다
//    T& operator[](int row, int col) { return m_arr.get()[static_cast<std::size_t>(row * cols() + col)]; }
//    const T& operator[](int row, int col) const { return m_arr.get()[static_cast<std::size_t>(row * cols() + col)]; }

    int rows() const { return static_cast<int>(Row); }
    int cols() const { return static_cast<int>(Col); }
    int length() const { return static_cast<int>(Row * Col); }
};

int main()
{
    // 3행 4열 크기를 가지는 1차원 std::array 정의
    ArrayFlat2d<int, 3, 4> arr {
        1, 2, 3, 4,
        5, 6, 7, 8,
        9, 10, 11, 12 };

    // 1차원 배열을 2차원처럼 보여주는 뷰 정의
    ArrayView2d<int, 3, 4> arrView { arr };

    // 배열의 크기 출력
    std::cout << "Rows: " << arrView.rows() << '\n';
    std::cout << "Cols: " << arrView.cols() << '\n';

    // 1차원 방식으로 배열 출력
    for (int i=0; i < arrView.length(); ++i)
        std::cout << arrView[i] << ' ';

    std::cout << '\n';

    // 2차원 방식으로 배열 출력
    for (int row=0; row < arrView.rows(); ++row)
    {
        for (int col=0; col < arrView.cols(); ++col)
            std::cout << arrView(row, col) << ' ';
        std::cout << '\n';
    }

    std::cout << '\n';

    return 0;
}

이 코드를 실행하면 다음과 같이 나옵니다:

Rows: 3
Cols: 4
1 2 3 4 5 6 7 8 9 10 11 12 
1 2 3 4 
5 6 7 8 
9 10 11 12 

C++23 이전 버전에서는 대괄호 [] 안에 숫자를 하나만 넣을 수 있기 때문에, 2차원 느낌을 내기 위해 보통 두 가지 우회 방법을 씁니다:

• 대괄호 대신 소괄호 ()를 사용합니다. 소괄호 안에는 숫자를 여러 개 받을 수 있거든요. 이렇게 하면 1차원으로 접근할 땐 []로, 다차원 좌표로 접근할 땐 ()로 구분해서 쓸 수 있습니다. 위 예제에서 우리가 선택한 방법이기도 해요.
• []를 썼을 때 하위 뷰(임시 객체)를 반환하게 해서 [][]처럼 대괄호를 연달아 이어 쓰게 만드는 방법입니다. 하지만 이건 구조가 너무 복잡해지고 차원이 높아지면 골치 아파져요.

다행히 C++23부터는 대괄호 [] 안에 쉼표로 인덱스를 여러 개 넣을 수 있게 규칙이 업그레이드되었습니다. 이제 굳이 소괄호 ()를 쓰지 않아도 [] 하나로 깔끔하게 처리할 수 있게 된 거죠.

관련 컨텐츠 std::reference_wrapper에 대한 자세한 내용은 레슨 17.5 -- std::reference_wrapper를 통한 참조 배열에서 다룹니다.

std::mdspan (C++23)

C++23에서 새롭게 도입된 std::mdspan은 메모리에 일렬로 나란히 붙어있는 데이터들을 마치 다차원 배열처럼 다룰 수 있게 해주는 멋진 '수정 가능한 뷰'입니다. 여기서 '수정 가능한 뷰'라는 말은 단순히 데이터 내용만 훔쳐보는 읽기 전용 뷰(std::string_view 같은 것)가 아니라, 원본 데이터가 변경 가능하다면 이 뷰를 통해서 데이터의 내용도 바꿀 수 있다는 뜻이에요.

아래 예제는 바로 위에서 살펴본 예제와 똑같은 결과를 내지만, 우리가 복잡하게 직접 만든 뷰 클래스 대신 C++ 표준 라이브러리의 std::mdspan을 사용했어요.

#include <array>
#include <iostream>
#include <mdspan>

// 두 개의 차원을 사용해 1차원 std::array를 정의할 수 있게 해주는 별칭 템플릿
template <typename T, std::size_t Row, std::size_t Col>
using ArrayFlat2d = std::array<T, Row * Col>;

int main()
{
    // 3행 4열 크기를 가지는 1차원 std::array 정의
    ArrayFlat2d<int, 3, 4> arr {
        1, 2, 3, 4,
        5, 6, 7, 8,
        9, 10, 11, 12 };

    // 1차원 배열을 연결하는 2차원 스팬(span) 정의
    // std::mdspan에는 데이터가 있는 메모리 주소(포인터)를 넘겨주어야 합니다.
    // std::array나 std::vector의 data() 함수를 쓰면 이 주소를 얻을 수 있습니다.
    std::mdspan mdView { arr.data(), 3, 4 };

    // 배열의 크기 출력
    // std::mdspan에서는 이것을 extents(범위)라고 부릅니다.
    std::size_t rows { mdView.extents().extent(0) };
    std::size_t cols { mdView.extents().extent(1) };
    std::cout << "Rows: " << rows << '\n';
    std::cout << "Cols: " << cols << '\n';

    // 1차원 방식으로 출력
    // data_handle() 함수를 쓰면 데이터 배열의 시작 주소를 얻을 수 있고,
    // 이를 이용해 요소에 접근할 수 있습니다.
    for (std::size_t i=0; i < mdView.size(); ++i)
        std::cout << mdView.data_handle()[i] << ' ';
    std::cout << '\n';

    // 2차원 방식으로 출력
    // 다차원 [] 연산자를 사용해 요소에 접근합니다.
    for (std::size_t row=0; row < rows; ++row)
    {
        for (std::size_t col=0; col < cols; ++col)
            std::cout << mdView[row, col] << ' ';
        std::cout << '\n';
    }
    std::cout << '\n';

    return 0;
}

코드가 직관적이라 이해하기 쉬우실 거예요! 그래도 몇 가지 핵심만 짚고 넘어가 볼까요:

• std::mdspan을 사용하면 우리가 원하는 만큼 차원의 개수를 쭉 늘려서 뷰를 만들 수 있어요.
• std::mdspan을 만들 때 첫 번째로 넣어주는 값은 배열 데이터가 모여있는 메모리의 시작 주소(포인터)여야 합니다. 구형 C 스타일 배열이라면 그냥 배열 이름을 쓰면 되고, std::array나 std::vector라면 .data() 함수를 호출해서 이 주소를 쉽게 가져올 수 있습니다.
• std::mdspan을 긴 1차원처럼 다루고 싶다면, .data_handle() 함수를 써서 포인터를 가져온 다음 거기에 []를 붙여 사용해야 해요.
• C++23부터는 대괄호 안에 여러 개의 숫자를 쉼표로 넣을 수 있으므로, 촌스럽게 [row][col]처럼 두 번 쓰지 않고 [row, col] 형식으로 세련되게 접근합니다.

참고로, 다가오는 C++26 버전에서는 std::array와 std::mdspan의 장점만을 합쳐서 아예 메모리 관리까지 알아서 해주는 완벽한 std::mdarray라는 기능이 추가될 예정이랍니다!

17.x — 17장 요약 및 퀴즈

• 고정 크기 배열(Fixed-size arrays) 또는 고정 길이 배열(fixed-length arrays)은 배열이 생성되는 시점에 길이를 알아야 하며, 이후에는 길이를 변경할 수 없습니다. C 스타일 배열과 std::array는 모두 고정 크기 배열입니다. 런타임에 크기를 조절할 수 있는 배열은 동적 배열(dynamic arrays)이라고 하며, std::vector가 이에 해당합니다.
• std::array의 길이는 반드시 상수 표현식(constant expression)이어야 합니다. 주로 정수 리터럴, constexpr 변수, 또는 범위 없는 열거자(unscoped enumerator)가 길이 값으로 제공됩니다.
• std::array는 집계형(aggregate)입니다. 즉, 생성자가 없으며 대신 '집계 초기화(aggregate initialization)'를 사용하여 초기화됩니다.
• 가능하다면 std::array를 constexpr로 정의하세요. constexpr로 만들 수 없는 상황이라면 대신 std::vector의 사용을 고려해 보는 것이 좋습니다.
• 클래스 템플릿 인수 추론(CTAD)을 사용하면 초기화 값을 통해 컴파일러가 std::array의 타입과 길이를 알아서 유추하게 할 수 있습니다.

std::array는 다음과 같이 선언된 템플릿 구조체(struct)로 구현되어 있습니다:

template<typename T, std::size_t N> // N은 비타입(non-type) 템플릿 매개변수입니다
struct array;

• 배열의 길이를 나타내는 비타입 템플릿 매개변수(N)의 타입은 std::size_t입니다.
• std::array의 길이를 구하는 방법:
• size() 멤버 함수를 사용하여 길이를 구할 수 있습니다 (부호 없는 size_type으로 반환됨).
• C++17에서는 std::size() 비멤버(non-member) 함수를 사용할 수 있습니다 (내부적으로 size() 멤버 함수를 호출하여 동일하게 반환함).
• C++20에서는 std::ssize() 비멤버 함수를 사용할 수 있으며, 이 함수는 부호 있는(signed) 큰 정수형(주로 std::ptrdiff_t)으로 길이를 반환합니다.
• 이 세 가지 함수는 배열이 참조(reference)로 전달된 경우를 제외하고 모두 constexpr 값을 반환합니다. (이 예외적인 결함은 C++23의 P2280에서 수정되었습니다.)

• std::array 인덱싱(요소 접근) 방법:
• 첨자 연산자 (operator[]) 사용: 경계 검사(bounds checking)를 하지 않으므로, 유효하지 않은 인덱스를 넣으면 미정의 동작(undefined behavior)이 발생합니다.
• at() 멤버 함수 사용: 런타임에 경계 검사를 수행합니다. 하지만 보통 인덱싱 전에 미리 경계 검사를 하거나 컴파일 타임에 검사하는 것을 원하므로, 이 함수는 가급적 피하는 것을 권장합니다.
• std::get() 함수 템플릿 사용: 인덱스를 비타입 템플릿 인수로 받으며, 컴파일 타임에 경계 검사를 수행합니다.

• template <typename T, std::size_t N> (또는 C++20의 template <typename T, auto N>) 형태의 매개변수를 가진 함수 템플릿을 사용하면, 요소 타입과 길이가 제각각인 다양한 std::array를 함수에 전달할 수 있습니다.
• std::array를 '값으로 반환(return by value)'하면 배열과 모든 요소가 복사됩니다. 배열의 크기가 작고 요소 복사 비용이 저렴하다면 괜찮지만, 상황에 따라서는 출력 매개변수(out parameter)를 사용하는 것이 더 나은 선택일 수 있습니다.
• 구조체, 클래스, 또는 배열을 이용해 std::array를 초기화할 때, 각 초기화 값에 요소 타입을 명시하지 않으면 컴파일러가 올바르게 해석할 수 있도록 한 쌍의 중괄호를 추가로 씌워주어야 합니다 ({{ }} 형태). 이는 집계 초기화의 특성 때문이며, 리스트 생성자를 사용하는 다른 표준 라이브러리 컨테이너들은 이런 추가 중괄호가 필요하지 않습니다.
• C++의 집계형은 중괄호 생략(brace elision)이라는 개념을 지원하여 특정 상황에서 중괄호를 생략할 수 있게 해줍니다. 일반적으로 스칼라(단일) 값으로 std::array를 초기화하거나, 각 요소의 타입이 명시적으로 지정된 클래스/배열로 초기화할 때는 중괄호를 생략할 수 있습니다.
• 참조(reference)로 이루어진 배열은 만들 수 없습니다. 하지만 수정 가능한 lvalue 참조처럼 동작하는 std::reference_wrapper의 배열은 만들 수 있습니다.
• std::reference_wrapper에 대해 알아둘 점:
• 할당 연산자(operator=)를 사용하면 참조하는 대상을 다른 객체로 변경(reseat)할 수 있습니다.
• std::reference_wrapper<T>는 T&로 암시적 변환됩니다.
• get() 멤버 함수를 사용해 T&를 가져올 수 있으며, 참조 중인 객체의 값을 업데이트할 때 유용합니다.
• std::ref()와 std::cref() 함수를 사용하면 std::reference_wrapper 객체를 더 쉽게 생성할 수 있습니다.

• CTAD를 사용하는 constexpr std::array가 올바른 개수의 초기화 값을 가졌는지 확인하려면 항상 static_assert를 활용하세요.
• C 스타일 배열은 C 언어에서 물려받았으며 C++ 핵심 언어에 내장되어 있습니다. 핵심 언어의 일부이기 때문에 고유한 선언 문법을 가집니다. 선언 시 대괄호([])를 사용하여 컴파일러에게 해당 객체가 C 스타일 배열임을 알립니다. 대괄호 안에는 배열의 길이를 나타내는 std::size_t 타입의 정수 값을 선택적으로 적을 수 있으며, 이 길이는 반드시 상수 표현식이어야 합니다.
• C 스타일 배열도 집계형(aggregate)이므로 집계 초기화를 사용할 수 있습니다. 초기화 리스트를 사용해 배열의 모든 요소를 초기화할 때는 길이를 명시하지 않고 컴파일러가 알아서 계산하도록 두는 것이 좋습니다.
• C 스타일 배열은 operator[]로 인덱싱할 수 있습니다. 이때 인덱스로 부호 있는 정수, 부호 없는 정수, 또는 범위 없는 열거형을 모두 사용할 수 있습니다. 덕분에 C 스타일 배열은 표준 라이브러리 컨테이너들이 겪는 부호 변환 관련 인덱싱 문제를 겪지 않습니다!
• C 스타일 배열은 const나 constexpr로 선언할 수 있습니다.
• C 스타일 배열의 길이를 구하는 방법:
• C++17: 부호 없는 std::size_t로 길이를 반환하는 std::size() 비멤버 함수를 사용합니다.
• C++20: 부호 있는 큰 정수형으로 길이를 반환하는 std::ssize() 비멤버 함수를 사용합니다.

• 대부분의 경우, C 스타일 배열이 수식에서 사용되면 배열의 첫 번째 요소(인덱스 0)의 주소를 가진 요소 타입의 포인터로 암시적 변환됩니다. 이를 흔히 배열 붕괴(array decay)라고 부릅니다.
• 포인터 연산(Pointer arithmetic)은 포인터에 덧셈, 뺄셈, 증감 연산자 등 특정 정수 산술 연산을 적용하여 새로운 메모리 주소를 만들어내는 기능입니다. 포인터 ptr이 있을 때, ptr + 1은 (가리키는 타입의 크기에 맞춰) 메모리상에 있는 그다음 객체의 주소를 반환합니다.
• 배열의 시작(0번 요소)부터 인덱싱할 때는 첨자 연산자([])를 사용하고, 특정 요소부터 상대적인 위치를 찾을 때는 포인터 연산을 사용하는 것이 좋습니다.
• C 스타일 문자열은 요소 타입이 char 또는 const char인 C 스타일 배열일 뿐입니다. 따라서 C 스타일 문자열도 배열 붕괴가 발생합니다.
• 배열의 차원(dimension)은 요소 하나를 선택하는 데 필요한 인덱스의 개수입니다.
• 차원이 하나뿐인 배열은 1차원 배열(single-dimensional array 또는 1d array)이라고 부릅니다. 배열 안의 배열은 두 개의 첨자가 필요하므로 2차원 배열(2d array)이라고 합니다. 차원이 1보다 큰 배열은 모두 다차원 배열(multidimensional arrays)입니다.
• 배열 평탄화(Flattening)는 다차원 배열의 차원을 줄여 (주로 1차원 배열로) 만드는 과정을 뜻합니다.
• C++23에 도입된 std::mdspan은 메모리에 연속적으로 나열된 요소들을 다차원 배열처럼 다룰 수 있게 해주는 뷰(view)입니다.

변수가 너무 많아질 때 생기는 문제 (확장성 문제)

학생 30명의 시험 점수를 기록하고 반 평균을 구하고 싶다고 상상해 볼까요? 이 작업을 하려면 변수 30개가 필요할 겁니다. 아마 아래처럼 만들어야겠죠.

// 30개의 정수형 변수를 할당합니다 (각각 이름이 다 달라야 해요!)
int testScore1 {};
int testScore2 {};
int testScore3 {};
// ...
int testScore30 {};

만들어야 할 변수가 정말 많죠! 게다가 반 평균을 구하려면 아래처럼 엄청나게 긴 코드를 짜야 할 거예요.

int average { (testScore1 + testScore2 + testScore3 + testScore4 + testScore5
     + testScore6 + testScore7 + testScore8 + testScore9 + testScore10
     + testScore11 + testScore12 + testScore13 + testScore14 + testScore15
     + testScore16 + testScore17 + testScore18 + testScore19 + testScore20
     + testScore21 + testScore22 + testScore23 + testScore24 + testScore25
     + testScore26 + testScore27 + testScore28 + testScore29 + testScore30)
     / 30; };

이건 타이핑하기도 힘들 뿐만 아니라, 똑같은 작업을 계속 반복해야 합니다. (게다가 숫자 하나를 실수로 잘못 쳐도 눈치채기 어렵겠죠)

그리고 이 값들을 가지고 뭔가 다른 작업(예: 화면에 점수 출력하기)을 하려면, 이 수많은 변수 이름을 처음부터 끝까지 다 다시 적어야 합니다.

자, 이제 반에 새로운 학생 한 명이 전학을 와서 프로그램을 수정해야 한다고 쳐볼까요? 우리는 전체 코드를 샅샅이 뒤져서 관련된 모든 곳에 testScore31 을 수동으로 직접 추가해야 합니다.

이미 잘 돌아가고 있는 코드를 고치는 건 언제나 새로운 버그를 만들 위험이 따릅니다. 예를 들어, 평균을 구할 때 나누는 수를 30 에서 31 로 바꾸는 걸 깜빡하기 정말 쉽겠죠!

겨우 30개의 변수만 해도 이 정도인데, 수백 개나 수천 개의 데이터를 다뤄야 한다면 어떨지 상상해 보세요. 똑같은 종류의 데이터가 여러 개 필요할 때, 이렇게 변수를 일일이 하나씩 만드는 방식은 확실히 한계가 있습니다.

데이터를 구조체(struct) 안에 묶어볼 수도 있을 거예요.

struct testScores
{
    // 30개의 정수형 변수를 할당합니다 (각각 이름이 다 달라야 해요!)
    int score1 {};
    int score2 {};
    int score3 {};
    // ...
    int score30 {};
}

이렇게 하면 점수들을 조금 더 깔끔하게 정리할 수 있고 함수에 데이터를 통째로 넘겨주기도 쉬워지지만, 가장 핵심적인 문제는 해결되지 않습니다. 여전히 각각의 점수 데이터를 하나하나 만들고, 일일이 다른 이름을 불러서 써야 한다는 점은 똑같거든요.

눈치채셨겠지만, C++에는 이런 골치 아픈 문제를 해결할 수 있는 방법들이 있습니다. 이번 장에서는 그중 한 가지 해결책을 소개해 드릴 거고요, 다음 장들에서는 또 다른 유용한 변형 방법들을 알아볼 예정입니다.

컨테이너

마트에 달걀 12개를 사러 갔다고 생각해 보세요. 달걀을 하나하나 낱개로 골라서 장바구니에 담지는 않으시죠? (안 그러시죠..?) 대신, 12개가 미리 담겨 있는 달걀 판 하나를 고를 겁니다.

여기서 달걀 판이 바로 일종의 컨테이너(용기) 로, 미리 정해진 개수(보통 6개, 12개, 24개)의 달걀을 담아두는 역할을 합니다.

시리얼은 어떨까요? 그 수많은 작은 시리얼 조각들을 찬장에 낱개로 흩뿌려 보관하고 싶진 않으실 거예요! 시리얼은 보통 종이상자에 담겨 나오는데, 이 상자 역시 컨테이너입니다. 우리는 일상생활에서 여러 개의 물건을 하나로 묶어 쉽게 관리하기 위해 이런 컨테이너들을 아주 흔하게 사용합니다.

프로그래밍에도 컨테이너가 있습니다. 아주 많을 수도 있는 여러 개의 데이터(객체)를 하나로 묶어서 쉽게 만들고 관리하기 위해서죠.

프로그래밍에서 컨테이너란 이름이 없는 여러 개의 데이터(이를 요소(element) 라고 부릅니다)를 저장할 수 있는 공간을 제공하는 데이터 타입을 말합니다.

핵심 포인트 우리는 주로 서로 관련 있는 여러 개의 값들을 한 묶음으로 다뤄야 할 때 컨테이너를 사용합니다.

사실 여러분은 이미 컨테이너를 하나 사용해 보셨습니다. 바로 문자열(string)이에요! 문자열 컨테이너는 여러 개의 '문자(character)'들을 모아서 저장해 주고, 나중에 텍스트로 출력할 수 있게 해줍니다.

#include <iostream>
#include <string>

int main()
{
    std::string name{ "Alex" }; // 문자열(string)은 문자들을 담는 컨테이너입니다.
    std::cout << name; // 문자열을 일련의 문자들의 연속으로 출력합니다.

    return 0;
}

컨테이너 안의 요소들에는 이름이 없습니다

컨테이너 자체에는 보통 이름이 있습니다. (이름이 없으면 어떻게 코딩할 때 꺼내 쓰겠어요?) 하지만 컨테이너 '안'에 들어있는 개별 요소들에는 이름이 없습니다. 만약 요소마다 이름이 있어야 한다면, 변수가 100개일 때 각기 다른 이름 100개를 지어줘야 할 테니까요! 이렇게 요소들에게 고유한 이름을 지어주지 않아도 원하는 만큼 데이터를 마구 넣을 수 있다는 점이 정말 중요하며, 일반적인 구조체와 컨테이너를 구분 짓는 가장 큰 차이점입니다. 앞서 살펴본 testScores 처럼 평범한 구조체들은 안에 든 데이터마다 각각의 이름이 꼭 필요하기 때문에 보통 컨테이너라고 부르지 않습니다.

위의 문자열 예시를 보면, 컨테이너 자체는 name 이라는 이름을 가졌지만, 그 안에 들어있는 개별 문자들('A', 'l', 'e', 'x')에는 각각의 이름이 따로 없습니다.

그렇다면 요소들의 이름이 없는데, 대체 어떻게 꺼내 쓸 수 있을까요? 모든 컨테이너는 안에 있는 데이터를 꺼내 쓸 수 있는 각자만의 '방법'들을 제공합니다. 정확히 어떤 방법을 쓰는지는 컨테이너의 종류마다 다릅니다. 이 부분은 다음 레슨에서 첫 번째 예시와 함께 자세히 알아볼 거예요.

핵심 포인트 컨테이너 안의 요소들은 각자의 이름이 없습니다. 덕분에 프로그래머가 일일이 이름을 지어주는 수고를 하지 않아도, 컨테이너 안에 원하는 만큼 많은 데이터를 넣을 수 있습니다.

각 컨테이너는 이 이름 없는 데이터들에 접근할 수 있는 고유한 방법을 제공하지만, 그 방법은 컨테이너의 종류에 따라 다릅니다.

컨테이너의 길이

프로그래밍에서는 컨테이너 안에 들어있는 데이터(요소)의 개수를 주로 길이(length) 또는 카운트(count) 라고 부릅니다.

이전 레슨인 '5.7 — std::string 소개'에서 std::string 의 length 라는 기능을 사용해 문자열 컨테이너 안에 문자가 몇 개 들어있는지 알아내는 방법을 보여드렸었죠.

#include <iostream>
#include <string>

int main()
{
    std::string name{ "Alex" };
    std::cout << name << " has " << name.length() << " characters\n";

    return 0;
}

위 코드는 이렇게 출력됩니다. Alex has 4 characters

C++에서는 컨테이너 안의 요소 개수를 말할 때 크기(size) 라는 단어도 정말 자주 씁니다. 하지만 이건 좀 아쉬운 작명이에요. 왜냐하면 "크기(size)"라는 말은 데이터가 메모리 공간을 몇 바이트나 차지하는지(sizeof 연산자가 알려주는 값)를 뜻하기도 하거든요.

그래서 우리는 헷갈리지 않게, 컨테이너 안에 들어있는 '데이터의 개수'를 말할 때는 가급적 "길이(length)"라는 용어를 쓰고, 데이터가 메모리에서 차지하는 '저장 공간의 용량'을 말할 때는 "크기(size)"라는 용어를 쓰겠습니다.

컨테이너로 할 수 있는 작업들 (연산)

다시 달걀 판 이야기로 돌아가 볼까요? 달걀 판으로 뭘 할 수 있을까요? 일단 달걀 판을 구해야겠죠. 그리고 뚜껑을 열어서 달걀을 하나 고를 수도 있고, 그 달걀로 마음대로 요리를 할 수도 있습니다. 판에서 달걀을 빼낼 수도 있고, 빈자리에 새 달걀을 채워 넣을 수도 있습니다. 달걀이 몇 개 남았는지 세어볼 수도 있죠.

이와 비슷하게, 프로그래밍의 컨테이너들도 보통 다음과 같은 기능들을 상당수 제공합니다.

• 컨테이너 만들기 (예: 텅 빈 컨테이너 만들기, 미리 정해둔 개수만큼 공간 확보하기, 초기값들을 넣어두고 시작하기 등)
• 요소에 접근하기 (예: 첫 번째 데이터 가져오기, 마지막 데이터 가져오기, 아무 데이터나 가져오기)
• 요소 넣고 빼기 (삽입과 삭제)
• 컨테이너에 들어있는 요소 개수 확인하기

물론 컨테이너를 관리하기 편하게 해주는 다른 추가 기능들을 제공하기도 합니다.

요즘 나오는 프로그래밍 언어들은 아주 다양한 종류의 컨테이너를 제공합니다. 이 컨테이너들은 구체적으로 어떤 기능들을 지원하는지, 그리고 그 기능이 얼마나 '빠른지(성능)'에 따라 차이가 납니다. 어떤 컨테이너는 아무 데이터나 엄청나게 빨리 찾을 수 있지만, 데이터를 중간에 넣거나 빼는 건 못할 수도 있습니다. 반대로 데이터를 넣고 빼는 건 빛의 속도인데, 데이터를 찾을 때는 처음부터 순서대로 하나씩 찾아야만 하는 컨테이너도 있죠.

모든 컨테이너는 저마다의 장점과 한계가 있습니다. 지금 내가 풀고 있는 문제에 딱 맞는 컨테이너를 고르는 것은 코드를 나중에 고치기 쉽게 만들고 전체적인 프로그램 속도를 높이는데 엄청나게 중요합니다. 이 주제는 나중에 다른 레슨에서 더 깊이 다루겠습니다.

요소의 자료형

대부분의 프로그래밍 언어(C++ 포함)에서 컨테이너는 동종(homogenous) 입니다. 말이 좀 어렵지만, 쉽게 말해 "컨테이너 안에는 모두 똑같은 자료형의 데이터만 넣어야 한다" 는 뜻입니다. (정수 컨테이너에는 정수만, 문자 컨테이너에는 문자만!)

어떤 컨테이너는 아예 들어갈 데이터 타입이 미리 정해져 있기도 합니다. (예: 문자열 컨테이너는 주로 문자(char)만 담습니다.) 하지만 대부분은 프로그래머가 직접 컨테이너에 담을 데이터 타입을 마음대로 정할 수 있습니다. C++에서는 보통 컨테이너를 '클래스 템플릿(class template)'이라는 것으로 구현해 둬서, 프로그래머가 원하는 타입을 템플릿 인자로 넘겨주면 그 타입에 맞게 알아서 변신하게끔 되어 있습니다. 이 내용은 다음 레슨에서 예시로 보여드릴게요.

덕분에 새로운 타입의 데이터를 담을 때마다 새로운 컨테이너를 굳이 또 만들 필요가 없어서 아주 유연하고 편리합니다. 그냥 기존 컨테이너에 "나 이번엔 정수 담을래!" 하고 지정만 해주면 바로 쓸 수 있거든요.

참고로 알아두세요... 동종 컨테이너의 반대말은 이종(heterogenous) 컨테이너입니다. 서로 다른 타입의 데이터들을 한 바구니에 마구 섞어 담을 수 있는 컨테이너죠. 파이썬(Python) 같은 스크립트 언어들에서 이런 이종 컨테이너를 주로 지원합니다.

C++에서의 컨테이너

C++ 표준 라이브러리(Standard Library)에는 흔히 쓰이는 컨테이너들을 만들어 모아둔 컨테이너 라이브러리(Containers library) 라는 부분이 있습니다. 이런 컨테이너 역할을 하는 클래스를 컨테이너 클래스(container class) 라고 부릅니다.

C++에서 "컨테이너"라는 단어는 일반적인 프로그래밍에서 쓰이는 의미보다 좀 더 좁은 의미로 쓰입니다. C++에서는 오직 이 '컨테이너 라이브러리' 안에 들어있는 클래스들만 공식적인 컨테이너로 인정해 줍니다. 그래서 우리는 일반적인 개념을 말할 때는 그냥 "컨테이너"라고 부르고, C++ 라이브러리 안에 있는 특정 클래스를 콕 집어 말할 때는 "컨테이너 클래스"라고 부르겠습니다.

심화 학습자를 위한 참고 다음의 타입들은 일반적인 프로그래밍 관점에서는 컨테이너가 맞지만, C++ 표준에서는 공식 컨테이너로 인정하지 않습니다.

• C 스타일 배열 (C-style arrays)
• std::string
• std::vector<bool>

C++에서 공식 컨테이너로 인정받으려면 여기서 명시된 모든 까다로운 조건들을 지켜야 합니다. (이 조건들에는 특정 함수들을 반드시 구현해야 한다는 내용도 있어서, C++의 공식 컨테이너는 무조건 클래스 형태여야만 합니다!) 위에 적힌 타입들은 이 모든 조건을 완벽히 지키지는 않거든요. 하지만 std::string 과 std::vector<bool> 은 대부분의 핵심 조건을 지키고 있어서 실제 상황에서는 컨테이너처럼 똑같이 동작합니다. 그래서 이들을 종종 "유사 컨테이너(pseudo-containers)"라고 부르기도 합니다.

제공되는 여러 컨테이너 클래스 중에서도 std::vector 와 std::array 가 압도적으로 가장 많이 쓰입니다. 그래서 앞으로 우리도 이 두 가지에 거의 모든 집중을 쏟을 겁니다. 다른 컨테이너 클래스들은 아주 특별한 상황에서만 가끔 쓰이는 편입니다.

배열(Array) 소개

배열(Array) 은 데이터들을 연속적으로 저장하는 컨테이너 자료형입니다.
"연속적"이라는 말은 데이터들이 메모리상에 중간에 빈 공간 없이 다닥다닥 붙어서 차례대로 저장된다는 뜻입니다. 배열은 이런 특징 덕분에 어떤 위치에 있는 데이터든 아주 빠르고 직접적으로 꺼내 볼 수 있습니다. 개념 자체도 아주 단순하고 쓰기 쉬워서, 서로 관련된 여러 데이터를 다뤄야 할 때 우리가 가장 먼저 선택하는 도구입니다.

C++에는 크게 세 가지 종류의 기본 배열이 있습니다: (C 스타일) 배열, std::vector 컨테이너 클래스, 그리고 std::array 컨테이너 클래스입니다.

• (C 스타일) 배열 은 옛날 C 언어 시절부터 물려받은 유산입니다. 예전 코드들과의 호환성을 위해 기본 C++ 언어 자체에 내장되어 있습니다. C++ 표준에서는 이걸 그냥 "배열"이라고 부르지만, 요즘 C++ 프로그래머들은 이름이 비슷한 std::array 와 헷갈리지 않게 보통 C 배열 이나 C 스타일 배열 이라고 부릅니다. ("벌거벗은 배열", "크기가 고정된 배열", "고정 배열", "내장 배열"이라고도 불러요.) 우리는 "C 스타일 배열"이라는 용어를 가장 선호하며, 세 가지 종류를 통틀어 말할 때만 "배열"이라고 부르겠습니다. 최신 프로그래밍 기준에서 볼 때, C 스타일 배열은 가끔 이상하게 동작할 때가 있고 심지어 위험하기까지 합니다. 왜 위험한지는 나중에 알아볼게요.
• C++에서 배열을 좀 더 안전하고 쓰기 쉽게 만들기 위해 2003년(C++03)에 도입된 것이 바로 std::vector 컨테이너 클래스입니다. std::vector 는 세 가지 배열 중에 가장 유연하고, 다른 배열들에는 없는 아주 다양하고 유용한 능력들을 많이 가지고 있습니다.
• 마지막으로, 위험한 C 스타일 배열을 직접적으로 대체하기 위해 2011년(C++11)에 std::array 컨테이너 클래스가 등장했습니다. std::vector 보다는 기능이 제한적이지만, 특히 크기가 작은 배열을 다룰 때 성능이 더 효율적일 수 있습니다.

현대의 C++ 프로그래밍에서도 이 세 가지 배열은 각자의 상황과 역할에 맞게 모두 쓰이고 있기 때문에, 우리는 세 가지 모두를 적절한 깊이로 공부할 예정입니다.

앞으로 나아가기

다음 레슨에서는 우리의 첫 번째 컨테이너 클래스인 std::vector 를 소개하고, 이 글의 맨 처음에 얘기했던 "변수가 너무 많아지는 확장성 문제"를 어떻게 효율적으로 해결하는지 그 여정을 시작해 보겠습니다. std::vector 와 관련된 새로운 개념들을 아주 많이 배워야 하고, 중간중간 생기는 또 다른 추가적인 문제들도 해결해야 해서 여기서 시간을 꽤 많이 보낼 거예요.

좋은 점이 하나 있다면, 모든 컨테이너 클래스들은 사용하는 방법(인터페이스)이 꽤 비슷하다는 점입니다. 그래서 하나(예: std::vector)를 확실히 다룰 줄 알게 되면, 다른 것(예: std::array)을 배우는 건 훨씬 쉽습니다. 나중에 다른 컨테이너를 배울 때는 눈에 띄는 차이점들 위주로 다루고 가장 중요한 핵심만 다시 짚어보도록 할게요.

저자의 말 (용어 정리)

용어에 대해 짧게 정리하고 갈게요!

• 표준 라이브러리에 있는 대부분의 혹은 모든 컨테이너 클래스에 두루두루 적용되는 이야기를 할 때는 컨테이너 클래스(container classes) 라는 용어를 쓰겠습니다.
• 다른 프로그래밍 언어의 배열들까지 포함해서 일반적인 모든 종류의 배열에 공통으로 적용되는 이야기를 할 때는 배열(array) 이라는 용어를 쓰겠습니다.

std::vector 는 이 두 가지 카테고리에 모두 속하기 때문에, 제가 어떤 용어를 쓰든 간에 std::vector 에도 당연히 적용되는 말이라고 생각하시면 됩니다.

16.2 — std::vector 소개와 리스트 생성자

이전 강의에서는 컨테이너와 배열을 함께 소개했습니다. 이번 강의에서는 이 장에서 계속 사용할 배열 타입인 std::vector 를 소개합니다. 그리고 지난 강의에서 이야기한 확장성 문제의 한 부분도 해결해 보겠습니다.

std::vector 소개

std::vector 는 C++ 표준 컨테이너 라이브러리에 있는 컨테이너 클래스 중 하나로, 배열을 구현합니다. std::vector 는 <vector> 헤더에 클래스 템플릿으로 정의되어 있고, 템플릿 타입 인수가 원소의 타입을 결정합니다. 그래서 std::vector<int> 는 int 타입 원소를 담는 std::vector 를 뜻합니다.

std::vector 객체를 만드는 방법은 간단합니다.

#include <vector>

int main()
{
    // 값 초기화 (기본 생성자 사용)
    std::vector<int> empty{}; // int 원소 0개를 담는 vector

    return 0;
}

변수 empty 는 원소 타입이 int 인 std::vector 입니다. 여기서는 값 초기화를 사용했기 때문에, 이 벡터는 비어 있는 상태(즉, 원소가 없는 상태)로 시작합니다.

원소가 하나도 없는 벡터는 지금은 별로 쓸모없어 보일 수 있습니다. 하지만 이후 강의에서 다시 보게 됩니다.

값 목록으로 std::vector 초기화하기

컨테이너의 목적은 관련된 값들을 관리하는 것이므로, 대부분의 경우에는 처음부터 값을 넣어서 만들고 싶습니다. 이때 원하는 초기값들을 넣은 리스트 초기화를 사용하면 됩니다. 예를 들면 다음과 같습니다.

#include <vector>

int main()
{
    // 리스트 생성 (리스트 생성자 사용)
    std::vector<int> primes{ 2, 3, 5, 7 };          // 값이 2, 3, 5, 7 인 int 원소 4개를 담는 vector
    std::vector vowels { 'a', 'e', 'i', 'o', 'u' }; // 값이 'a', 'e', 'i', 'o', 'u' 인 char 원소 5개를 담는 vector. CTAD (C++17)로 원소 타입 char 를 자동 추론함 (권장)

    return 0;
}

primes 에서는 원소 타입이 int 인 std::vector 를 만들겠다고 직접 지정했습니다. 초기값 4개를 넣었으므로, primes 는 값이 2, 3, 5, 7 인 원소 4개를 가집니다.

vowels 에서는 원소 타입을 직접 쓰지 않았습니다. 대신 C++17의 CTAD를 사용해서, 컴파일러가 초기값을 보고 원소 타입을 자동으로 추론하게 했습니다. 초기값 5개를 넣었으므로, vowels 는 값이 'a', 'e', 'i', 'o', 'u' 인 원소 5개를 가집니다.

리스트 생성자와 초기화 리스트

이제 위 코드가 어떻게 동작하는지 조금 더 자세히 보겠습니다.

강의 13.8 에서 초기화 리스트는 중괄호 안에 쉼표로 구분된 값 목록이라고 배웠습니다. (예: { 1, 2, 3 })

컨테이너에는 보통 리스트 생성자 라는 특별한 생성자가 있습니다. 이 생성자는 초기화 리스트를 사용해서 컨테이너 객체를 만들 수 있게 해 줍니다. 리스트 생성자는 보통 다음 세 가지를 합니다.

1. 모든 초기값을 담을 수 있도록 충분한 저장 공간을 마련합니다(필요하면).
2. 컨테이너의 길이를 초기화 리스트 원소 수에 맞게 설정합니다(필요하면).
3. 원소들을 초기화 리스트의 값으로 순서대로 초기화합니다.

즉, 컨테이너에 값들의 초기화 리스트를 넘기면 리스트 생성자가 호출되고, 그 값들로 컨테이너가 만들어집니다.

모범 사례 원소 값들을 넣어 컨테이너를 만들 때는, 그 값들의 초기화 리스트와 함께 리스트 초기화를 사용하세요.

관련 내용 직접 만든 클래스에 리스트 생성자를 추가하는 방법은 23.7 -- std::initializer_list 에서 다룹니다.

첨자 연산자 operator[] 로 배열 원소에 접근하기

이제 원소들의 배열을 만들었으니, 각 원소에는 어떻게 접근할까요?

잠깐 비유를 들어 봅시다. 똑같이 생긴 우편함 여러 개가 나란히 있다고 생각해 보세요. 구분하기 쉽게 각 우편함 앞에는 번호가 적혀 있습니다.

첫 번째 우편함은 0, 두 번째는 1 식입니다. 그래서 “번호 0 우편함에 넣으세요”라고 하면 첫 번째 우편함을 뜻한다는 걸 알 수 있습니다.

C++에서 배열 원소에 접근하는 가장 흔한 방법은 배열 이름과 첨자 연산자 operator[] 를 함께 쓰는 것입니다. 특정 원소를 고르려면 대괄호 안에 원하는 원소를 가리키는 정수 값을 넣습니다. 이 정수 값을 첨자(subscript) 또는 보통 인덱스(index) 라고 부릅니다. 우편함 예시처럼 첫 번째 원소는 인덱스 0, 두 번째 원소는 인덱스 1 로 접근합니다.

예를 들어 primes[0] 은 primes 배열에서 인덱스 0 인 원소(첫 번째 원소)를 반환합니다. 첨자 연산자는 원소의 복사본이 아니라 실제 원소에 대한 참조를 돌려줍니다. 그래서 배열 원소에 접근한 뒤에는 일반 변수처럼 사용할 수 있습니다(예: 값을 대입하거나, 출력하거나).

인덱스가 1 이 아니라 0 부터 시작하므로, C++의 배열은 0부터 시작하는 배열이라고 합니다. 보통 우리는 1 부터 세는 데 익숙하므로, 처음에는 헷갈릴 수 있습니다.

핵심 아이디어

인덱스는 실제로 배열의 첫 번째 원소로부터의 거리(offset) 입니다.

배열의 첫 번째 원소에서 시작해서 0 칸 이동하면, 여전히 첫 번째 원소에 있습니다. 그래서 인덱스 0 이 첫 번째 원소입니다.

배열의 첫 번째 원소에서 시작해서 1 칸 이동하면, 두 번째 원소에 도착합니다. 그래서 인덱스 1 이 두 번째 원소입니다.

인덱스가 절대 위치가 아니라 상대 거리라는 점은 17.9 -- Pointer arithmetic and subscripting 에서 더 자세히 다룹니다.

이 때문에 말로 설명할 때는 조금 헷갈릴 수 있습니다. 예를 들어 “배열 원소 1” 이라고 하면, 인덱스 0 인 첫 번째 원소를 뜻하는지, 인덱스 1 인 두 번째 원소를 뜻하는지 모호할 수 있습니다. 그래서 보통은 인덱스보다 순서로 말합니다(예: “첫 번째 원소”는 인덱스 0 인 원소).

예를 들어 보겠습니다.

#include <iostream>
#include <vector>

int main()
{
    std::vector primes { 2, 3, 5, 7, 11 }; // 처음 5개의 소수를 저장함 (int)

    std::cout << "The first prime number is: " << primes[0] << '\n';
    std::cout << "The second prime number is: " << primes[1] << '\n';
    std::cout << "The sum of the first 5 primes is: " << primes[0] + primes[1] + primes[2] + primes[3] + primes[4] << '\n';

    return 0;
}

출력 결과:

The first prime number is: 2
The second prime number is: 3
The sum of the first 5 primes is: 28

배열을 사용하면 이제 소수 5개를 저장하기 위해 이름이 다른 변수 5개를 따로 만들 필요가 없습니다. 대신 원소가 5개인 배열 primes 하나만 만들고, 인덱스 값만 바꿔서 다른 원소에 접근하면 됩니다.

operator[] 와 배열 원소에 접근하는 다른 방법들은 다음 강의 16.3 -- std::vector and the unsigned length and subscript problem 에서 더 이야기합니다.

범위를 벗어난 첨자

배열에 인덱스로 접근할 때는, 넣은 인덱스가 반드시 배열 안에 있는 유효한 원소를 가리켜야 합니다. 즉, 길이가 N 인 배열이라면 첨자는 0 부터 N-1 까지의 값이어야 합니다(양 끝 포함).

operator[] 는 범위 검사를 하지 않습니다. 즉, 인덱스가 0 부터 N-1 사이인지 확인하지 않습니다. 잘못된 인덱스를 operator[] 에 넘기면 정의되지 않은 동작이 발생합니다.

음수 인덱스를 쓰면 안 된다는 것은 비교적 기억하기 쉽습니다. 하지만 인덱스가 N 인 원소는 없다는 점은 놓치기 쉽습니다. 배열의 마지막 원소 인덱스는 N-1 이므로, 인덱스 N 을 쓰면 배열 끝 바로 다음 위치의 원소에 접근하려고 하게 됩니다.

팁 원소가 N 개인 배열에서 첫 번째 원소의 인덱스는 0, 두 번째는 1, 마지막은 N-1 입니다. 인덱스가 N 인 원소는 없습니다.

첨자로 N 을 사용하면 정의되지 않은 동작이 발생합니다. (실제로는 배열에 없는 N+1 번째 원소에 접근하려는 것이기 때문입니다)

팁 일부 컴파일러(예: Visual Studio)는 인덱스가 유효한지 런타임 assert 로 검사해 줍니다. 이런 경우 디버그 모드에서 잘못된 인덱스를 사용하면 프로그램이 assert 에 걸려 중단됩니다. 릴리스 모드에서는 이 assert 가 제거되므로 성능 손해는 없습니다.

배열은 메모리에 연속으로 배치된다

배열의 중요한 특징 중 하나는, 원소들이 메모리 안에 항상 연속으로 배치된다는 점입니다. 즉, 원소들이 메모리에서 서로 바로 옆에 붙어 있고, 중간에 빈 공간이 없습니다.

예를 들어 보겠습니다.

#include <iostream>
#include <vector>

int main()
{
    std::vector primes { 2, 3, 5, 7, 11 }; // 처음 5개의 소수를 저장함 (int)

    std::cout << "An int is " << sizeof(int) << " bytes\n";
    std::cout << &(primes[0]) << '\n';
    std::cout << &(primes[1]) << '\n';
    std::cout << &(primes[2]) << '\n';

    return 0;
}

작성자의 컴퓨터에서 한 번 실행했을 때 결과는 다음과 같았습니다.

An int is 4 bytes
00DBF720
00DBF724
00DBF728

이 int 원소들의 메모리 주소는 서로 4 바이트 차이가 납니다. 이것은 작성자의 컴퓨터에서 int 의 크기와 같습니다.

이 말은 배열이 원소마다 추가로 드는 숨은 비용 이 없다는 뜻입니다. 또, 컴파일러가 배열 안의 어떤 원소 주소든 빠르게 계산할 수 있게 해 줍니다.

관련 내용

첨자 접근이 어떤 계산으로 이루어지는지는 17.9 -- Pointer arithmetic and subscripting 에서 설명합니다.

배열은 몇 안 되는 임의 접근(random access) 이 가능한 컨테이너입니다. 즉, 컨테이너 안의 어떤 원소든 바로 접근할 수 있습니다. (반대로 순차 접근(sequential access)은 정해진 순서대로만 접근해야 합니다)

배열 원소에 대한 임의 접근은 보통 빠르고, 배열을 아주 쓰기 쉽게 만들어 줍니다. 이것이 배열이 다른 컨테이너보다 자주 선호되는 중요한 이유 중 하나입니다.

특정 길이의 std::vector 만들기

사용자에게 값 10개를 입력받아 std::vector 에 저장한다고 생각해 봅시다. 이 경우, 아직 값을 넣기 전이라도 길이가 10 인 std::vector 가 먼저 필요합니다. 그럼 어떻게 해야 할까요?

이렇게 초기화 리스트에 자리 채움용 값 10개를 넣어 만들 수도 있습니다.

std::vector<int> data { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; // int 값 10개를 담는 vector

하지만 이 방법은 여러 이유로 좋지 않습니다. 타이핑이 너무 많고, 초기값이 몇 개인지 한눈에 보기 어렵습니다. 나중에 개수를 바꾸고 싶어도 수정하기 불편합니다.

다행히 std::vector 에는 std::size_t 값 하나를 받아서, 그 길이의 std::vector 를 만드는 explicit 생성자(explicit std::vector<T>(std::size_t))가 있습니다.

std::vector<int> data( 10 ); // int 원소 10개를 담는 vector, 값 초기화되어 0 이 됨

이렇게 만들어진 각 원소는 값 초기화됩니다. int 의 경우에는 0 으로 초기화되고, 클래스 타입이면 기본 생성자가 호출됩니다.

하지만 이 생성자를 사용할 때 주의할 점이 하나 있습니다. 이 생성자는 반드시 직접 초기화로 호출해야 합니다.

비어 있지 않은 초기화 리스트는 리스트 생성자를 우선한다

왜 이전 생성자를 직접 초기화로 호출해야 하는지 이해하려면, 다음 정의를 보세요.

std::vector<int> data{ 10 }; // 이것은 무엇을 할까?

이 초기화는 서로 다른 두 생성자와 맞을 수 있습니다.

1. { 10 } 을 초기화 리스트로 해석하면, 리스트 생성자와 매칭되어 길이가 1이고 값이 10 인 벡터 가 됩니다.

2. { 10 } 을 중괄호로 감싼 단일 초기화 값으로 해석하면, std::vector<T>(std::size_t) 생성자와 매칭되어 길이가 10 이고 각 원소가 0 으로 값 초기화된 벡터 가 됩니다.

보통 클래스 타입 초기화가 둘 이상의 생성자와 맞으면 모호하다고 판단되어 컴파일 오류가 납니다. 하지만 C++에는 이 경우를 위한 특별 규칙이 있습니다.

초기화 리스트가 비어 있지 않으면, 맞는 리스트 생성자가 다른 생성자보다 우선 선택됩니다. 이 규칙이 없으면, 리스트 생성자는 인수를 하나만 받는 다른 생성자들과 자주 충돌하게 됩니다.

{ 10 } 은 초기화 리스트로 해석될 수 있고, std::vector 에는 리스트 생성자가 있으므로 이 경우에는 리스트 생성자가 우선됩니다.

핵심 아이디어

초기화 리스트를 사용해 클래스 타입 객체를 만들 때는 다음 규칙이 적용됩니다.

• 초기화 리스트가 비어 있으면, 리스트 생성자보다 기본 생성자가 우선됩니다.
• 초기화 리스트가 비어 있지 않으면, 맞는 리스트 생성자가 다른 맞는 생성자보다 우선됩니다.

이 차이를 더 분명히 보기 위해, 복사 초기화, 직접 초기화, 리스트 초기화를 비슷한 예제로 비교해 보겠습니다.

// 복사 초기화
std::vector<int> v1 = 10;     // 10 은 초기화 리스트가 아님. 복사 초기화는 explicit 생성자와 매칭되지 않음: 컴파일 오류

// 직접 초기화
std::vector<int> v2(10);      // 10 은 초기화 리스트가 아님. explicit 단일 인수 생성자와 매칭됨

// 리스트 초기화
std::vector<int> v3{ 10 };    // { 10 } 은 초기화 리스트로 해석됨. 리스트 생성자와 매칭됨

// 복사 리스트 초기화
std::vector<int> v4 = { 10 }; // { 10 } 은 초기화 리스트로 해석됨. 리스트 생성자와 매칭됨
std::vector<int> v5({ 10 });  // { 10 } 은 초기화 리스트로 해석됨. 리스트 생성자와 매칭됨

// 기본 초기화
std::vector<int> v6 {};       // {} 는 빈 초기화 리스트. 기본 생성자와 매칭됨
std::vector<int> v7 = {};     // {} 는 빈 초기화 리스트. 기본 생성자와 매칭됨

v1 의 경우, 초기값 10 은 초기화 리스트가 아니므로 리스트 생성자와 맞지 않습니다. 단일 인수 생성자 explicit std::vector<T>(std::size_t) 도 복사 초기화에서는 explicit 생성자와 매칭되지 않으므로 사용할 수 없습니다. 결국 맞는 생성자가 없어서 컴파일 오류가 납니다.

v2 의 경우, 초기값 10 은 초기화 리스트가 아니므로 리스트 생성자와는 맞지 않습니다. 대신 단일 인수 생성자 explicit std::vector<T>(std::size_t) 와는 맞기 때문에 그 생성자가 선택됩니다.

v3 에서는 { 10 } 이 리스트 생성자와도 맞고 explicit std::vector<T>(std::size_t) 와도 맞을 수 있습니다. 하지만 리스트 생성자가 다른 맞는 생성자보다 우선하므로 리스트 생성자가 선택됩니다.

v4 에서는 { 10 } 이 리스트 생성자와 맞습니다. 리스트 생성자는 non-explicit 생성자이므로 복사 초기화에도 사용할 수 있습니다. 그래서 리스트 생성자가 선택됩니다.

놀랍게도 v5 는 직접 초기화처럼 보이지만, 사실은 복사 리스트 초기화의 다른 문법 입니다. 즉, v4 와 같은 의미입니다.

이것은 C++ 초기화 문법의 조금 불편한 점 중 하나입니다. { 10 } 은 리스트 생성자가 있으면 그쪽과 매칭되고, 리스트 생성자가 없으면 단일 인수 생성자와 매칭됩니다. 즉, 리스트 생성자가 존재하느냐에 따라 동작이 달라집니다. 일반적으로 컨테이너에는 리스트 생성자가 있다고 생각하면 됩니다.

경고 어떤 클래스에 리스트 생성자가 없을 때 비어 있지 않은 초기화 리스트로 객체를 만들고 있었다면, 나중에 그 클래스에 리스트 생성자가 추가될 경우 어떤 생성자가 호출되는지가 바뀔 수 있습니다.

v6 와 v7 은 둘 다 빈 초기화 리스트로 초기화됩니다. 이 경우에는 기본 생성자가 우선됩니다.

정리하면, 리스트 초기화는 보통 원소 값 목록으로 컨테이너를 초기화하기 위해 만들어진 문법이며, 실제로도 그 목적에 사용하는 것이 맞습니다.

대부분의 경우 우리가 원하는 것도 바로 그것입니다. 따라서 10 이 원소 값 이라면 { 10 } 이 맞습니다. 하지만 10 이 컨테이너의 비리스트 생성자에 넘길 인수 라면 직접 초기화를 사용해야 합니다.

모범 사례 컨테이너(또는 리스트 생성자가 있는 타입)를 만들 때, 초기값이 원소 값이 아니라면 직접 초기화를 사용하세요.

팁 std::vector 가 클래스 타입의 멤버일 때는, std::vector 의 길이를 어떤 초기값으로 설정하는 기본 초기화를 어떻게 써야 할지 바로 떠올리기 어렵습니다.

#include <vector>
>
struct Foo
{
    std::vector<int> v1(8); // 컴파일 오류: 멤버 기본 초기화에서는 직접 초기화를 사용할 수 없음
};

이 코드는 동작하지 않습니다. 멤버 기본 초기화에서는 직접 초기화(괄호 초기화)를 사용할 수 없기 때문입니다.

클래스 타입 멤버에 기본 초기값을 줄 때는 다음 규칙이 있습니다.

• 복사 초기화 또는 리스트 초기화(직접 리스트 초기화 / 복사 리스트 초기화)만 사용할 수 있습니다.
• CTAD는 사용할 수 없습니다(즉, 원소 타입을 직접 써야 합니다).
  해결 방법은 다음과 같습니다.

  struct Foo
  {
    std::vector<int> v{ std::vector<int>(8) }; // 가능
  };

  이 코드는 원소 8개짜리 std::vector 를 만든 다음, 그것을 v 의 초기값으로 사용합니다.

const 와 constexpr std::vector

std::vector 타입 객체는 const 로 만들 수 있습니다.

#include <vector>

int main()
{
    const std::vector<int> prime { 2, 3, 5, 7, 11 }; // prime 과 그 원소들은 수정할 수 없음

    return 0;
}

const std::vector 는 반드시 초기화되어야 하고, 한 번 만들어진 뒤에는 수정할 수 없습니다. 이런 벡터의 원소들도 const 인 것처럼 취급됩니다.

하지만 std::vector 의 원소 타입 자체를 const 로 정의하면 안 됩니다. (예: std::vector<const int> 는 허용되지 않음)

핵심 아이디어 표준 라이브러리 컨테이너는 원소 자체를 const 로 가지도록 설계되지 않았습니다.

컨테이너의 상수성은 원소를 const 로 만드는 데서 오는 것이 아니라, 컨테이너 자체를 const 로 만드는 것 으로 결정됩니다.

std::vector 의 큰 단점 중 하나는 constexpr 로 만들 수 없다는 점입니다. constexpr 배열이 필요하다면 std::array 를 사용하세요.

왜 이름이 vector 일까?

사람들이 일상적으로 “vector” 라는 말을 쓰면, 보통 크기와 방향을 가진 기하학적 벡터 를 떠올립니다. 그런데 std::vector 는 그런 벡터가 아닌데 왜 이런 이름이 붙었을까요?

책 From Mathematics to Generic Programming 에서 Alexander Stepanov는 대략 이렇게 말했습니다.

“STL의 vector 라는 이름은 이전 프로그래밍 언어인 Scheme과 Common Lisp에서 가져왔다. 하지만 이것은 수학에서 훨씬 오래전부터 쓰이던 vector의 의미와 맞지 않았다. 이 자료구조는 사실 array 라고 불렸어야 했다. 안타깝게도 이런 실수를 한 번 하면, 그 결과는 아주 오랫동안 남을 수 있다.”

즉, 쉽게 말해 std::vector 라는 이름은 사실 조금 잘못 붙은 이름이지만, 이제는 바꾸기엔 너무 늦었다는 뜻입니다.

16.3 — std::vector와 부호 없는(unsigned) 길이 및 첨자(subscript) 문제

이전 레슨인 '16.2 -- std::vector 및 리스트 생성자 소개'에서는 배열의 인덱스를 지정하여 요소에 접근할 수 있게 해주는 operator[]에 대해 알아보았습니다.

이번 레슨에서는 배열 요소에 접근하는 다른 방법들과 함께, 컨테이너 클래스의 길이 (현재 컨테이너 클래스에 포함된 요소의 개수)를 구하는 몇 가지 다양한 방법들을 살펴볼 것입니다.

하지만 그 전에, C++ 설계자들이 저지른 한 가지 큰 실수에 대해, 그리고 그 실수가 C++ 표준 라이브러리의 모든 컨테이너 클래스에 어떤 영향을 미치는지 먼저 이야기해 보아야 합니다.

컨테이너 길이의 부호 문제

하나의 전제로 시작해 보겠습니다. 배열의 인덱스를 지정하는 데 사용되는 데이터 타입은 배열의 길이를 저장하는 데 사용되는 데이터 타입과 일치해야 합니다. 이는 가능한 가장 긴 배열의 모든 요소를 인덱싱할 수 있게 하고, 그 범위를 벗어나지 않도록 하기 위함입니다.

비야네 스트로우스트룹(Bjarne Stroustrup)이 회고하듯, C++ 표준 라이브러리의 컨테이너 클래스들이 설계될 당시(1997년경), 설계자들은 길이(와 배열 인덱스)를 부호 있는(signed) 타입으로 할지, 아니면 부호 없는(unsigned) 타입으로 할지 결정해야 했습니다. 그들은 부호 없는 타입을 선택했습니다.

그 이유는 다음과 같았습니다.

• 표준 라이브러리 배열 타입의 인덱스는 음수가 될 수 없습니다.
• 부호 없는 타입을 사용하면 부호에 쓰일 여분의 비트를 활용해 더 큰 길이의 배열을 만들 수 있습니다 (이는 16비트 시절에는 매우 중요한 문제였습니다).
• 인덱스 범위 검사 시 조건 확인을 두 번 할 필요 없이 한 번만 하면 됩니다 (인덱스가 0보다 작은지 확인할 필요가 없기 때문입니다).

돌이켜 보면, 이는 일반적으로 잘못된 선택이었다고 평가받습니다. 오늘날 우리는 다음과 같은 사실을 알고 있습니다:

• 암시적 변환 규칙으로 인해 부호 없는 값을 사용하여 음수를 방지하려는 의도는 통하지 않습니다 (음수인 부호 있는 정수는 그저 매우 큰 부호 없는 정수로 암시적 변환되어 쓰레기 결과를 초래합니다).
• 32비트나 64비트 시스템에서는 범위를 넓히기 위한 여분의 비트가 대개 필요하지 않습니다 (20억 개가 넘는 요소를 가진 배열을 만들 일은 거의 없으니까요).
• 게다가 흔히 사용되는 operator[]는 어차피 범위 검사를 수행하지도 않습니다.

이전 레슨인 '4.5 -- 부호 없는 정수, 그리고 이를 피해야 하는 이유'에서 우리는 수량을 저장할 때 부호 있는 값을 선호하는 이유에 대해 논의했습니다. 또한 부호 있는 값과 부호 없는 값을 섞어 쓰는 것은 예기치 않은 동작을 유발하는 지름길이라는 점도 언급했습니다. 따라서 표준 라이브러리 컨테이너 클래스들이 길이(그리고 인덱스)에 부호 없는 값을 사용한다는 것은 큰 문제입니다. 이러한 타입들을 사용할 때 부호 없는 값을 사용하는 것을 피할 수 없게 만들기 때문입니다.

당분간 우리는 과거의 이 결정과 그로 인해 발생하는 불필요한 복잡성을 안고 갈 수밖에 없습니다.

부호 변환은 축소 변환입니다. 단, constexpr인 경우는 예외입니다.

더 진행하기 전에, 부호 변환(부호 있는 타입에서 부호 없는 타입으로, 또는 그 반대로의 정수 변환)과 관련하여 '10.4 — 축소 변환, 리스트 초기화, 그리고 constexpr 초기화' 레슨에서 다루었던 내용을 빠르게 복습해 보겠습니다. 이번 장에서 이 주제를 아주 많이 다루게 될 것이기 때문입니다.

부호 변환은 축소 변환으로 간주됩니다. 왜냐하면 부호 있는 타입이나 부호 없는 타입은 서로 반대되는 타입의 범위에 포함된 모든 값을 오롯이 담을 수 없기 때문입니다. 이러한 변환이 런타임에 수행될 때, 컴파일러는 축소 변환이 허용되지 않는 문맥(예: 리스트 초기화)에서는 오류를 발생시킵니다. 반면, 이러한 변환이 수행되는 다른 문맥에서는 경고를 띄울 수도 있고 그렇지 않을 수도 있습니다.

예를 들어 보겠습니다:

#include <iostream>

void foo(unsigned int){}

int main(){
    int s { 5 };

    [[maybe_unused]] unsigned int u { s }; // 컴파일 오류: 리스트 초기화는 축소 변환을 허용하지 않음
    foo(s);                                // 경고 발생 가능: 복사 초기화는 축소 변환을 허용함

    return 0;
}

위의 예제에서 변수 u의 초기화는 컴파일 오류를 발생시킵니다. 리스트 초기화를 수행할 때는 축소 변환이 엄격히 금지되기 때문입니다. 반면 foo() 호출은 복사 초기화를 수행하는데, 이는 축소 변환을 허용합니다. 이 경우 컴파일러가 부호 변환 경고를 얼마나 적극적으로 잡아내느냐에 따라 경고가 나올 수도 있고 나오지 않을 수도 있습니다. 예를 들어, GCC와 Clang 컴파일러 모두 -Wsign-conversion 플래그를 사용하면 이 상황에서 경고를 띄웁니다.

하지만, 부호를 변환하려는 값이 constexpr(상수 표현식)이고 반대 타입의 동일한 값으로 문제없이 변환될 수 있다면, 이 부호 변환은 축소 변환으로 간주되지 않습니다. 이는 컴파일러가 컴파일 타임에 이 변환이 안전하다는 것을 확실히 보장할 수 있고, 만약 안전하지 않다면 컴파일 과정을 알아서 중단시킬 수 있기 때문입니다.

#include <iostream>

void foo(unsigned int){}

int main(){
    constexpr int s { 5 };                 // 이제 constexpr로 선언되었습니다.
    [[maybe_unused]] unsigned int u { s }; // 성공: s는 constexpr이며 안전하게 변환될 수 있으므로 축소 변환이 아닙니다.
    foo(s);                                // 성공: s는 constexpr이며 안전하게 변환될 수 있으므로 축소 변환이 아닙니다.

    return 0;
}

이 경우 s가 constexpr이고 변환할 값(5)이 부호 없는 값으로도 온전히 표현될 수 있으므로, 이 변환은 축소 변환으로 간주되지 않으며 아무런 문제 없이 암시적으로 수행될 수 있습니다.

이러한 축소 변환이 아닌 constexpr 변환(constexpr int에서 constexpr std::size_t로의 변환 등)은 우리가 앞으로 아주 유용하게, 자주 활용하게 될 핵심 개념입니다.

std::vector의 길이와 인덱스의 타입은 size_type입니다

레슨 '10.7 -- Typedef와 타입 별칭(type aliases)'에서, 우리는 타입의 이름이 달라질 수 있는 경우(예: 컴파일러 구현에 따라 정의되는 경우)에 typedef와 타입 별칭을 자주 사용한다고 언급했습니다. 예를 들어 std::size_t는 보통 unsigned long이나 unsigned long long과 같이 크기가 큰 부호 없는(unsigned) 정수 타입을 위한 typedef입니다.

각각의 C++ 표준 라이브러리 컨테이너 클래스들은 size_type(때로는 T::size_type으로 표기됨)이라는 이름의 중첩된(nested) typedef 멤버를 정의합니다. 이는 해당 컨테이너의 길이(그리고 지원되는 경우 인덱스)를 나타내는 데 사용되는 타입에 대한 별칭입니다.

여러분은 보통 공식 문서나 컴파일러의 경고/에러 메시지에서 size_type을 자주 보게 될 것입니다. 예를 들어, std::vector의 size() 멤버 함수에 대한 공식 문서를 보면 size()가 size_type 타입의 값을 반환한다고 명시되어 있습니다.

관련 내용 중첩된 typedef에 대해서는 레슨 '15.3 -- 중첩 타입 (멤버 타입)'에서 다룹니다.

size_type은 거의 항상 std::size_t의 별칭이지만, (드문 경우지만) 다른 타입을 사용하도록 재정의(override)될 수도 있습니다.

** 핵심 포인트**

• size_type은 표준 라이브러리 컨테이너 클래스 내부에 정의된 중첩 typedef로, 컨테이너 클래스의 길이 및 인덱스를 나타내는 타입으로 사용됩니다.
• size_type의 기본값은 std::size_t이며, 이 설정이 변경되는 일은 거의 없기 때문에 우리는 size_type을 사실상 std::size_t의 별칭이라고 가정해도 무방합니다.

심화 학습

• std::array를 제외한 모든 표준 라이브러리 컨테이너는 메모리 할당을 위해 std::allocator를 사용합니다. 이러한 컨테이너들의 경우, T::size_type은 사용된 할당자(allocator)의 size_type에서 파생됩니다. std::allocator는 최대 std::size_t 바이트의 메모리를 할당할 수 있으므로, std::allocator<T>::size_type은 std::size_t로 정의됩니다. 따라서 T::size_type의 기본값은 자연스럽게 std::size_t가 됩니다.
• 사용자 정의 할당자(custom allocator)를 만들고 그 안에서 T::size_type을 std::size_t가 아닌 다른 타입으로 정의한 경우에만 컨테이너의 T::size_type이 달라집니다. 이는 매우 드문 일이며 특정 애플리케이션의 특수한 목적을 위해 개별적으로 이루어지는 작업입니다. 따라서 여러분의 코드가 그러한 커스텀 할당자를 사용하지 않는 한(만약 사용한다면 여러분이 직접 그 사실을 알고 있을 것입니다), T::size_type이 std::size_t일 것이라고 가정하는 것이 일반적으로 안전합니다.
• 컨테이너 클래스의 size_type 멤버에 직접 접근할 때는 반드시 템플릿화된 컨테이너 클래스의 전체 이름으로 스코프(scope)를 명시해야 합니다. (예: std::vector<int>::size_type)

size() 멤버 함수 또는 std::size()를 사용하여 std::vector의 길이 구하기

size() 멤버 함수를 사용하여 컨테이너 클래스 객체에 현재 길이를 요청할 수 있습니다. (이 함수는 길이를 부호 없는(unsigned) 타입인 size_type으로 반환합니다)

#include <iostream>
#include <vector>

int main(){
    std::vector prime { 2, 3, 5, 7, 11 };
    std::cout << "length: " << prime.size() << '\n'; // 길이를 `size_type` (std::size_t의 별칭) 타입으로 반환합니다.
    return 0;
}

이 코드의 출력 결과는 다음과 같습니다.

length: 5

length()와 size() 멤버 함수를 모두 가지고 있는(두 함수는 동일한 작업을 수행합니다) std::string 및 std::string_view와 달리, std::vector를 비롯한 C++의 대부분의 다른 컨테이너 타입은 size() 함수만 가지고 있습니다. 이제 왜 컨테이너의 '길이(length)'를 종종 '크기(size)'라고 모호하게 부르는지 이해하셨을 것입니다.

C++17부터는 std::size() 비멤버 함수도 사용할 수 있습니다 (컨테이너 클래스의 경우, 이 함수는 내부적으로 단순히 size() 멤버 함수를 호출합니다).

#include <iostream>
#include <vector>

int main(){
    std::vector prime { 2, 3, 5, 7, 11 };
    std::cout << "length: " << std::size(prime); // C++17, 길이를 `size_type` (std::size_t의 별칭) 타입으로 반환합니다.

    return 0;
}

심화 학습

std::size()는 붕괴되지 않은 C 스타일 배열에도 사용할 수 있기 때문에, 때로는 size() 멤버 함수를 직접 호출하는 것보다 이 방법이 더 선호되기도 합니다.

특히 컨테이너 클래스나 붕괴되지 않은 C 스타일 배열을 모두 인수로 받을 수 있는 함수 템플릿을 작성할 때 아주 유용합니다.

참고: C 스타일 배열 붕괴에 대해서는 레슨 '17.8 -- C 스타일 배열 붕괴'에서 자세히 다룹니다.

위의 두 가지 방법 중 하나를 사용하여 배열의 길이를 구한 뒤, 이를 부호 있는 타입의 변수에 저장하려고 하면 부호 변환 경고나 오류가 발생할 가능성이 높습니다.

이 상황에서 가장 간단하게 해결할 수 있는 방법은 반환값을 원하는 타입으로 명시적 형변환(static_cast) 하는 것입니다.

#include <iostream>
#include <vector>

int main(){
    std::vector prime { 2, 3, 5, 7, 11 };
    int length { static_cast<int>(prime.size()) }; // 반환값을 int 타입으로 static_cast 합니다.
    std::cout << "length: " << length ;

    return 0;
}

C++20: std::ssize()를 사용하여 std::vector의 길이 구하기

C++20에서는 std::ssize() 비멤버(non-member) 함수를 새롭게 도입했습니다. 이 함수는 길이를 크기가 큰 부호 있는(signed) 정수 타입(일반적으로 std::size_t의 부호 있는 짝꿍으로 자주 사용되는 std::ptrdiff_t)으로 반환합니다.

#include <iostream>
#include <vector>

int main(){
    std::vector prime{ 2, 3, 5, 7, 11 };
    std::cout << "length: " << std::ssize(prime); // C++20, 길이를 크기가 큰 부호 있는 정수 타입으로 반환합니다.

    return 0;
}

이것은 길이를 구하는 세 가지 함수(size(), std::size(), std::ssize()) 중 유일하게 길이를 부호 있는(signed) 타입으로 반환하는 함수입니다.

이 방법을 사용하여 길이를 부호 있는 타입의 변수에 저장하고 싶다면, 두 가지 방법 중 하나를 선택할 수 있습니다.

첫째, 일반적인 int 타입은 std::ssize()가 반환하는 부호 있는 타입보다 크기가 작을 수 있습니다. 따라서 길이를 int 변수에 할당하려는 경우, 이 변환을 명확하게 하기 위해 결과값을 int로 명시적 형변환(static_cast) 해야 합니다. (그렇지 않으면 축소 변환(narrowing conversion) 경고나 컴파일 오류가 발생할 수 있습니다)

#include <iostream>
#include <vector>

int main(){
    std::vector prime{ 2, 3, 5, 7, 11 };
    int length { static_cast<int>(std::ssize(prime)) }; // 반환값을 int로 명시적 형변환(static_cast) 합니다.
    std::cout << "length: " << length;

    return 0;
}

둘째, 대안으로 auto 키워드를 사용하여 컴파일러가 해당 변수에 딱 맞는 올바른 부호 있는 타입을 스스로 추론하도록 맡길 수도 있습니다.

#include <iostream>
#include <vector>

int main(){
    std::vector prime{ 2, 3, 5, 7, 11 };
    auto length { std::ssize(prime) }; // std::ssize()가 반환하는 부호 있는 타입을 자동으로 추론하기 위해 auto를 사용합니다.
    std::cout << "length: " << length;

    return 0;
}

operator[]를 사용한 배열 요소 접근은 경계 검사를 수행하지 않습니다

이전 레슨에서 첨자 연산자 operator[] 에 대해 소개했습니다.

#include <iostream>
#include <vector>

int main(){
    std::vector prime{ 2, 3, 5, 7, 11 };

    std::cout << prime[3];  // 인덱스가 3인 요소의 값(7)을 출력합니다.
    std::cout << prime[9];  // 유효하지 않은 인덱스입니다 (미정의 동작 발생).

    return 0;
}

operator[]는 경계 검사를 수행하지 않습니다. operator[]에 들어가는 인덱스는 비상수일 수도 있습니다. 이 부분에 대해서는 이후 섹션에서 더 자세히 다루도록 하겠습니다.

at() 멤버 함수를 사용한 배열 요소 접근은 런타임 경계 검사를 수행합니다

배열 컨테이너 클래스들은 배열 요소에 접근하는 또 다른 방법을 지원합니다. at() 멤버 함수를 사용하면 런타임 경계 검사를 거쳐 배열 요소에 접근할 수 있습니다.

#include <iostream>
#include <vector>

int main(){
    std::vector prime{ 2, 3, 5, 7, 11 };

    std::cout << prime.at(3); // 인덱스가 3인 요소의 값을 출력합니다.
    std::cout << prime.at(9); // 유효하지 않은 인덱스입니다 (예외 발생).

    return 0;
}

위의 예제에서 prime.at(3) 호출은 인덱스 3이 유효한지 먼저 확인합니다. 유효한 인덱스이므로 배열의 3번 요소에 대한 참조를 반환하고, 우리는 그 값을 출력할 수 있습니다.

하지만 prime.at(9) 호출은 9가 이 배열의 유효한 인덱스가 아니기 때문에 (런타임에) 실패합니다. at() 함수는 참조를 반환하는 대신, 프로그램을 종료시키는 오류를 발생시킵니다.

** 심화 학습** at() 멤버 함수가 범위를 벗어난 인덱스를 만나면, 실제로는 std::out_of_range 타입의 예외를 던집니다. 이 예외가 프로그램 내에서 적절히 처리되지 않으면 프로그램이 강제 종료됩니다. 예외와 그 처리 방법에 대해서는 27장에서 자세히 다루게 됩니다.

operator[]와 마찬가지로, at()에 전달되는 인덱스는 비상수일 수 있습니다.

매 호출마다 런타임에 경계 검사를 수행해야 하기 때문에, at()은 operator[]보다 느립니다 (물론 더 안전하긴 합니다). 더 안전함에도 불구하고 실제 현업에서는 at()보다 operator[]가 일반적으로 훨씬 더 많이 사용됩니다. 그 주된 이유는, 애초에 유효하지 않은 인덱스를 사용하려는 시도 자체를 하지 않도록 인덱싱을 하기 전에 논리적으로 미리 경계 검사를 확실히 하는 것이 더 좋은 프로그래밍 습관이기 때문입니다.

constexpr 부호 있는 정수로 std::vector 인덱싱하기

constexpr int를 사용하여 std::vector를 인덱싱할 때, 우리는 이것이 축소 변환으로 취급되지 않으면서도 컴파일러가 자연스럽게 std::size_t로 암시적 변환을 수행하도록 내버려 둘 수 있습니다.

#include <iostream>
#include <vector>

int main(){
    std::vector prime{ 2, 3, 5, 7, 11 };

    std::cout << prime[3] << '\n';     // 성공: 3이 int에서 std::size_t로 변환되며, 축소 변환이 아닙니다.

    constexpr int index { 3 };         // constexpr 선언
    std::cout << prime[index] << '\n'; // 성공: constexpr 인덱스가 std::size_t로 암시적 변환되며, 축소 변환이 아닙니다.

    return 0;
}

비상수 값으로 std::vector 인덱싱하기

배열을 인덱싱하는 데 사용되는 첨자는 비상수일 수 있습니다.

#include <iostream>
#include <vector>

int main(){
    std::vector prime{ 2, 3, 5, 7, 11 };

    std::size_t index { 3 };           // 비상수(non-constexpr)
    std::cout << prime[index] << '\n'; // operator[]는 std::size_t 타입의 인덱스를 예상하므로 변환이 필요하지 않습니다.

    return 0;
}

하지만 우리의 모범 사례('4.5 -- 부호 없는 정수, 그리고 이를 피해야 하는 이유')에 따라, 우리는 일반적으로 수량을 저장할 때 부호 없는 타입의 사용을 피하고자 합니다.

첨자가 비상수인 부호 있는 값일 때, 우리는 다음과 같은 문제에 직면하게 됩니다.

#include <iostream>
#include <vector>

int main(){
    std::vector prime{ 2, 3, 5, 7, 11 };

    int index { 3 };                   // 비상수(non-constexpr)
    std::cout << prime[index] << '\n'; // 경고 발생 가능: 인덱스가 암시적으로 std::size_t로 변환됨, 축소 변환 발생

    return 0;
}

이 예제에서 index는 비상수인 부호 있는 int입니다. std::vector의 일부로 정의된 operator[]의 첨자는 size_type(std::size_t의 별칭) 타입을 갖습니다. 따라서 prime[index]를 호출할 때, 우리가 전달한 부호 있는 int는 std::size_t로 변환되어야 합니다.

이러한 변환은 위험하지 않아야 합니다 (std::vector의 인덱스는 음수가 아닐 것으로 예상되며, 음수가 아닌 부호 있는 값은 부호 없는 값으로 안전하게 변환되기 때문입니다). 하지만 이 변환이 런타임에 수행될 때 이는 축소 변환으로 간주되며, 컴파일러는 이것이 안전하지 않은 변환이라는 경고를 띄워야 합니다 (만약 경고를 발생시키지 않는다면, 경고가 발생하도록 컴파일러 설정을 수정하는 것을 고려해야 합니다).

배열 인덱싱은 매우 흔하게 사용되는 작업이고 이러한 변환이 일어날 때마다 경고가 생성되기 때문에, 컴파일 로그가 불필요한 경고들로 금세 도배될 수 있습니다. 또는 "경고를 오류로 처리(treat warning as errors)" 설정이 활성화되어 있다면 아예 컴파일이 중단될 것입니다.

이 문제를 피할 수 있는 방법은 여러 가지가 있지만 (예를 들어, 배열을 인덱싱할 때마다 int를 std::size_t로 static_cast 하는 등), 이 모든 방법은 필연적으로 코드를 지저분하게 하거나 복잡하게 만듭니다. 이 경우 가장 간단한 방법은 std::size_t 타입의 변수를 인덱스로 사용하고, 이 변수를 인덱싱 이외의 다른 용도로는 사용하지 않는 것입니다. 그렇게 하면 애초에 비상수 변환이 일어나는 것을 피할 수 있습니다.

팁 또 다른 좋은 대안은 std::vector 자체를 인덱싱하는 대신, data() 멤버 함수의 결과를 인덱싱하는 것입니다:

#include <iostream>
#include <vector>

int main(){
    std::vector prime{ 2, 3, 5, 7, 11 };

    int index { 3 };                          // 비상수 부호 있는 값
    std::cout << prime.data()[index] << '\n'; // 성공: 부호 변환 경고 없음

    return 0;
}

내부적으로 std::vector는 그 요소들을 C 스타일 배열에 보관합니다. data() 멤버 함수는 이 기반이 되는 C 스타일 배열에 대한 포인터를 반환하며, 우리는 이것을 인덱싱할 수 있습니다. C 스타일 배열은 부호 있는 타입과 부호 없는 타입 모두로 인덱싱하는 것을 허용하기 때문에, 부호 변환 문제에 부딪히지 않습니다. C 스타일 배열에 대해서는 레슨 '17.7 -- C 스타일 배열 소개'와 '17.8 -- C 스타일 배열 붕괴'에서 더 자세히 논의합니다.

저자의 노트 (Author’s note) 이와 같은 인덱싱 문제를 해결하기 위한 추가적인 옵션들은 레슨 '16.7 -- 배열, 루프, 그리고 부호 문제 해결책'에서 논의할 것입니다.

16.4 — std::vector 전달하기

std::vector 타입의 객체도 다른 평범한 데이터들처럼 함수에 쏙 집어넣을 수 있어요. 하지만 주의할 점이 있습니다! std::vector를 '값으로 전달(pass by value)'하게 되면, 벡터 안에 들어있는 모든 데이터를 통째로 복사하게 됩니다. 데이터가 많다면 컴퓨터가 아주 버거워하겠죠(비용이 큽니다).

그래서 이런 불필요하고 무거운 복사를 막기 위해, 우리는 보통 '참조로 전달(pass by reference)' 방식을 사용합니다. 원본의 위치만 알려주는 방식이죠! (보통은 데이터가 수정되지 않도록 const 참조를 씁니다.)

std::vector를 사용할 때는, 그 안에 '어떤 종류의 데이터(요소)'가 들어가는지도 벡터의 정체성(타입 정보)에 포함됩니다. 따라서 함수에서 std::vector를 받을 때는 그 안에 어떤 타입이 들어있는지 명확하게 적어주어야 해요.

#include <iostream>
#include <vector>

void passByRef(const std::vector<int>& arr) // 여기에 <int>를 명확하게 적어주어야 합니다
{
    std::cout << arr[0] << '\n';
}

int main()
{
    std::vector primes{ 2, 3, 5, 7, 11 };
    passByRef(primes);

    return 0;
}

다른 타입의 요소를 가진 std::vector 전달하기

방금 만든 passByRef() 함수는 정수가 들어있는 std::vector<int> 만 기다리고 있기 때문에, 실수(double) 같은 다른 종류의 데이터가 들어있는 벡터는 전달할 수 없어요.

#include <iostream>
#include <vector>

void passByRef(const std::vector<int>& arr)
{
    std::cout << arr[0] << '\n';
}

int main()
{
    std::vector primes{ 2, 3, 5, 7, 11 };
    passByRef(primes);  // 성공: 이것은 std::vector<int> 입니다

    std::vector dbl{ 1.1, 2.2, 3.3 };
    passByRef(dbl); // 컴파일 에러: std::vector<double>을 std::vector<int>로 변환할 수 없습니다

    return 0;
}

C++17 이상의 최신 버전에서는 CTAD를 써서 이 문제를 해결해보려고 할 수도 있을 거예요.

#include <iostream>
#include <vector>

void passByRef(const std::vector& arr) // 컴파일 에러: CTAD는 함수 매개변수를 추론하는 데 사용할 수 없습니다
{
    std::cout << arr[0] << '\n';
}

int main()
{
    std::vector primes{ 2, 3, 5, 7, 11 }; // 성공: CTAD를 사용하여 std::vector<int>로 추론합니다
    passByRef(primes);

    return 0;
}

하지만 안타깝게도, CTAD는 처음 벡터를 만들 때는 안에 든 값을 보고 타입을 척척 알아맞히지만, 아직 '함수의 매개변수' 자리에서는 작동하지 않는답니다.

예전에도 함수가 받는 데이터의 '타입'만 다르고 하는 일은 똑같을 때 비슷한 문제를 겪은 적이 있죠? 이럴 때 쓰기 딱 좋은 게 바로 함수 템플릿 이라는 기능이에요! 데이터 타입을 템플릿(틀)으로 만들어두면, C++이 알아서 우리가 넘겨주는 데이터에 맞춰 진짜 함수를 뚝딱 찍어내 줍니다.

관련 내용 함수 템플릿에 대해서는 '11.6 - 함수 템플릿' 강의에서 다루고 있어요.

이제 똑같은 템플릿 매개변수를 사용해서 함수 템플릿을 만들어 볼게요.

#include <iostream>
#include <vector>

template <typename T>
void passByRef(const std::vector<T>& arr)
{
    std::cout << arr << '\n';
}

int main()
{
    std::vector primes{ 2, 3, 5, 7, 11 };
    passByRef(primes); // 성공: 컴파일러가 passByRef(const std::vector<int>&) 함수를 만들어냅니다

    std::vector dbl{ 1.1, 2.2, 3.3 };
    passByRef(dbl);    // 성공: 컴파일러가 passByRef(const std::vector<double>&) 함수를 만들어냅니다

    return 0;
}

위 예제에서는 const std::vector<T>& 타입의 데이터를 받는 passByRef() 라는 단 하나의 함수 템플릿을 만들었어요. 여기서 T 는 바로 윗줄의 template <typename T> 에서 정의된 것인데요. 이 T 는 함수를 호출하는 사람이 어떤 타입이든 자유롭게 정할 수 있게 해주는 '빈칸' 역할을 합니다.

따라서 main() 함수에서 정수형 벡터인 primes 를 넣어 호출하면, 컴퓨터가 알아서 정수형 전용 함수인 void passByRef(const std::vector<int>& arr) 를 만들어내고 실행해요.

마찬가지로 실수형 벡터인 dbl 을 넣어 호출하면, 알아서 실수형 전용 함수인 void passByRef(const std::vector<double>& arr) 를 찍어내서 실행한답니다.

결과적으로, 단 하나의 템플릿만으로도 어떤 타입, 어떤 길이의 std::vector 든 다 받아낼 수 있는 만능 함수를 만든 셈이죠!

제네릭 템플릿이나 약식 함수 템플릿을 이용해 std::vector 전달하기

아예 벡터뿐만 아니라 '모든 종류의 객체'를 다 받아주는 더 강력한 템플릿을 만들 수도 있어요.

#include <iostream>
#include <vector>

template <typename T>
void passByRef(const T& arr) // [] 연산자가 오버로딩된 모든 타입의 객체를 받아줍니다
{
    std::cout << arr[0] << '\n';
}

int main()
{
    std::vector primes{ 2, 3, 5, 7, 11 };
    passByRef(primes); // 성공: 컴파일러가 passByRef(const std::vector<int>&) 함수를 만들어냅니다

    std::vector dbl{ 1.1, 2.2, 3.3 };
    passByRef(dbl);    // 성공: 컴파일러가 passByRef(const std::vector<double>&) 함수를 만들어냅니다

    return 0;
}

C++20 버전부터는 auto 매개변수를 이용한 약식 함수 템플릿 을 써서 똑같은 작업을 더 간단하게 할 수 있습니다.

#include <iostream>
#include <vector>

void passByRef(const auto& arr) // 약식 함수 템플릿
{
    std::cout << arr << '\n';
}

int main()
{
    std::vector primes{ 2, 3, 5, 7, 11 };
    passByRef(primes); // 성공: 컴파일러가 passByRef(const std::vector<int>&) 함수를 만들어냅니다

    std::vector dbl{ 1.1, 2.2, 3.3 };
    passByRef(dbl);    // 성공: 컴파일러가 passByRef(const std::vector<double>&) 함수를 만들어냅니다

    return 0;
}

이 두 가지 방법은 코드가 에러 없이 돌아가기만 한다면 정말 '아무 타입'이나 다 받아줍니다. std::vector 말고도 다른 데이터 타입에서 써먹고 싶은 함수를 만들 때 아주 유용하죠.

예를 들어, 위 함수들은 std::array 나 문자열인 std::string, 심지어 우리가 생각지도 못한 전혀 다른 타입에서도 잘 작동할 거예요.

하지만 단점도 있습니다. 아무거나 다 받다 보니, 문법적으로는 통과가 되더라도 실제 의미상으로는 전혀 말이 안 되는 데이터가 들어가서 나중에 골치 아픈 버그를 일으킬 위험이 있거든요.

배열의 길이 확인하기

방금 봤던 것과 비슷한 다음 템플릿 함수를 한번 살펴볼까요?

#include <iostream>
#include <vector>

template <typename T>
void printElement3(const std::vector<T>& arr)
{
    std::cout << arr[3] << '\n';
}

int main()
{
    std::vector arr{ 9, 7, 5, 3, 1 };
    printElement3(arr);

    return 0;
}

이 코드에서 printElement3(arr) 은 문제없이 잘 작동합니다. 하지만 방심한 초보 프로그래머를 노리는 무서운 함정이 하나 숨어있어요. 눈치채셨나요?

위 프로그램은 인덱스 번호가 3번인 (즉, 4번째에 있는) 값을 출력합니다. 배열 안에 4개 이상의 데이터가 있다면 아무 문제가 없죠. 하지만, 데이터가 4개도 안 되는 짧은 배열을 집어넣어도 컴퓨터(컴파일러)는 아무런 불만 없이 코드를 통과시켜 버립니다. 예를 들어볼게요.

#include <iostream>
#include <vector>

template <typename T>
void printElement3(const std::vector<T>& arr)
{
    std::cout << arr[3] << '\n';
}

int main()
{
    std::vector arr{ 9, 7 }; // 2개의 요소만 있는 배열 (사용 가능한 인덱스는 0과 1뿐입니다)
    printElement3(arr);

    return 0;
}

이렇게 되면 배열의 범위를 벗어난 곳에 접근하게 되어 프로그램이 엉뚱하게 작동하거나 뻗어버리는 정의되지 않은 동작이 발생하게 됩니다.

이럴 때 쓸 수 있는 한 가지 방법은 arr.size() 로 길이를 확인하는 검사기(assert)를 다는 거예요. 그러면 버그를 잡는 디버그 모드로 실행할 때 이런 에러를 미리 잡아낼 수 있죠. 단, std::vector 의 크기를 확인하는 기능은 프로그램이 '실행 중일 때'만 작동하기 때문에, 코드를 작성하는 시점에서는 미리 검사할 수 없다는 한계가 있습니다.

팁 사실 가장 좋은 방법은, 배열의 길이를 깐깐하게 확인해야 하는 상황이라면 아예 std::vector 를 쓰지 않는 것입니다. 대신 프로그램 실행 전에도 크기를 알 수 있는 std::array 를 쓰는 것이 훨씬 낫습니다. 그러면 코드를 짤 때 길이를 미리 검사(static_assert)할 수 있거든요. 이 내용은 나중에 '17.3 - std::array 전달 및 반환하기'에서 배울 거예요.

결론적으로 가장 좋은 해결책 은 애초에 "무조건 몇 개 이상의 데이터가 들어있는 벡터만 넣어주세요!" 라고 강요하는 함수 자체를 만들지 않는 것이랍니다.

16.5 — std::vector 반환하기, 그리고 이동 의미론(Move semantics) 소개

함수에 std::vector 를 넘겨줄 때, 우리는 보통 배열 데이터 전체를 복사하는 엄청난 비용을 피하려고 '(const) 참조' 방식을 사용합니다.

그렇기 때문에, std::vector 를 반환할 때는 그냥 '값으로 반환(return by value)'해도 괜찮다는 사실을 알게 되면 아마 깜짝 놀라실 거예요.

복사 의미론 (Copy semantics)

다음 프로그램을 한 번 볼까요?

#include <iostream>
#include <vector>

int main()
{
    std::vector arr1 { 1, 2, 3, 4, 5 }; // { 1, 2, 3, 4, 5 }를 arr1에 복사합니다.
    std::vector arr2 { arr1 };          // arr1을 arr2에 복사합니다.

    arr1[0] = 6; // 우리는 arr1을 계속 사용할 수 있습니다.
    arr2[0] = 7; // 그리고 arr2도 계속 사용할 수 있습니다.

    std::cout << arr1[0] << arr2[0] << '\n';

    return 0;
}

arr2 가 arr1 을 이용해 초기화될 때, std::vector 의 복사 생성자가 호출되면서 arr1 의 내용이 arr2 로 고스란히 복사됩니다.

여기서는 arr1 과 arr2 가 각자 독립적으로 살아남아야 하므로, 복사본을 만드는 것이 유일하고 합리적인 방법이에요. 결과적으로 이 예제에서는 초기화할 때마다 하나씩, 총 두 번의 복사가 일어납니다.

복사 의미론(Copy semantics) 이라는 거창한 말은 사실 별게 아닙니다. 그냥 "객체의 복사본을 어떻게 만들 것인가?"를 정해둔 규칙일 뿐이에요. 어떤 타입이 복사 의미론을 지원한다고 하면, 복사하는 규칙이 잘 정해져 있어서 그 타입의 객체를 안전하게 복사할 수 있다는 뜻입니다. 그리고 "복사 의미론이 발동되었다"는 말은 우리가 객체를 복사하게 만드는 어떤 행동을 했다는 뜻이죠.

클래스 타입의 경우, 보통 복사 생성자 나 복사 대입 연산자를 통해 이 규칙을 구현합니다. 대개는 클래스 안의 모든 데이터를 하나하나 다 복사하게 만들어 둬요. 방금 본 예제에서 std::vector arr2 { arr1 }; 라는 코드가 바로 복사 규칙을 작동시킨 겁니다.

그러면 std::vector 의 복사 생성자가 불려가서 arr1 의 모든 데이터를 arr2 로 복사하죠. 결국 arr1 은 arr2 와 똑같은 내용을 가지면서도, 서로 완전히 독립적인 남남이 됩니다.

복사하는 게 '최선'이 아닐 때

자, 이제 조금 다른 예제를 살펴볼까요?

#include <iostream>
#include <vector>

std::vector<int> generate() // 값으로 반환(return by value)합니다.
{
    // 의무적인 복사 생략(mandatory copy elision)이 적용되지 않도록 일부러 이름이 있는 객체를 사용합니다.
    std::vector arr1 { 1, 2, 3, 4, 5 }; // { 1, 2, 3, 4, 5 }를 arr1에 복사합니다.
    return arr1;
}

int main()
{
    std::vector arr2 { generate() }; // generate()의 반환값은 이 표현식이 끝날 때 사라집니다(죽습니다).

    // 여기서부터는 generate()의 반환값을 사용할 방법이 전혀 없습니다.
    arr2[0] = 7; // 우리는 오직 arr2에만 접근할 수 있습니다.

    std::cout << arr2[0] << '\n';

    return 0;
}

이번에 arr2 를 초기화할 때는, generate() 함수가 반환하는 임시 객체를 사용하고 있습니다. 이전 예제에서는 나중에도 계속 쓸 수 있는 이름 있는 변수(lvalue)를 썼지만, 이번에는 다릅니다. 이 임시 객체는 한 번 쓰이고 나면 이 줄이 끝날 때 바로 파괴되어 버리는 1회용(rvalue)이거든요. 어차피 이 임시 객체와 그 안의 데이터가 곧 사라질 운명이니, 우리는 어떻게든 그 데이터를 살려내서 arr2 안으로 가져와야만 합니다.

보통 이럴 때 우리가 하던 방식은 첫 번째 예제와 같습니다. 그냥 복사 규칙을 써서 무겁고 비싼 복사를 한 번 더 하는 거죠. 그렇게 하면 임시 객체가 파괴되더라도 arr2 가 자기만의 데이터를 안전하게 가질 수 있으니까요.

하지만 이전과 결정적으로 다른 점이 있습니다. 어차피 저 임시 객체는 죽을 운명이라는 거예요! 초기화가 끝나면 임시 객체는 더 이상 자기 데이터를 필요로 하지 않아요. 굳이 똑같은 데이터 두 세트가 동시에 존재할 필요가 없죠. 이런 상황에서 굳이 무겁게 복사를 한 다음에 원본 데이터를 버리는 것은, 너무 비효율적이고 안타까운 일입니다.

이동 의미론 (Move Semantics) 맛보기

그렇다면 복사하는 대신에, arr2 가 임시 객체의 데이터를 살짝 "훔쳐오는(steal)" 방법이 있다면 어떨까요?

그러면 arr2 가 그 데이터의 새로운 주인이 되고, 번거롭게 데이터를 복사할 필요도 없어집니다. 이렇게 데이터의 소유권이 한 객체에서 다른 객체로 넘어가는 것을 가리켜 데이터가 이동(moved)되었다 고 표현합니다. 이렇게 이동하는 비용은 정말 깃털처럼 가볍습니다 (보통 메모리 주소 포인터 몇 개만 쓱 바꿔치기하면 되니까, 거대한 배열을 통째로 복사하는 것보다 엄청나게 빠르죠!).

덤으로 얻는 장점도 있어요! 코드가 끝나고 임시 객체가 파괴될 때, 이미 데이터를 다 뺏기고 텅텅 비어있기 때문에 파괴할 데이터조차 남아있지 않습니다. 데이터를 없애는 데 드는 수고마저 덜게 되는 거죠.

이것이 바로 이동 의미론(Move semantics) 의 핵심입니다! 한 객체에서 다른 객체로 데이터를 어떻게 넘겨줄지 정해주는 규칙이죠. 이 마법 같은 규칙이 발동되면, 이동할 수 있는 데이터는 모조리 이동시키고, 이동이 불가능한 데이터만 복사합니다. 비싸고 느린 복사를 싸고 빠른 이동으로 대체할 수 있기 때문에 훨씬 더 효율적입니다.

핵심 포인트 이동 의미론은 특정 상황에서 데이터를 비싸게 복사하는 대신, 데이터의 소유권을 다른 객체로 아주 저렴하게 넘겨주는 훌륭한 최적화 기술입니다. (이동할 수 없는 데이터라면 어쩔 수 없이 복사하게 됩니다.)

이동 의미론은 언제 발동할까요?

보통은 같은 타입의 객체로 초기화하거나 값을 넣을 때, 복사 규칙이 사용됩니다. (복사 생략이 일어나지 않았다고 가정했을 때요)

참고 복사 생략(copy elision)에 대한 내용은 '14.15 강의 - 클래스 초기화와 복사 생략'에서 다루었습니다.

하지만, 다음 세 가지 조건이 모두 만족될 때 는 복사 대신 '이동'이 발동됩니다!

• 해당 객체의 타입이 이동 규칙을 지원할 때.
• 객체가 같은 타입의 1회용 임시 객체(rvalue) 로 초기화되거나 대입될 때.
• 이동 자체가 통째로 생략되지 않을 때.

여기서 슬픈 소식이 하나 있습니다. 아직 이 기능을 지원하는 타입이 그리 많지는 않다는 거예요. 하지만 다행히도 우리가 자주 쓰는 std::vector 와 std::string 은 둘 다 완벽하게 지원한답니다!

이동 규칙이 정확히 어떻게 굴러가는지에 대한 깊은 내용은 22장에서 파헤쳐 볼 예정입니다. 지금은 그저 "이동 의미론이 대체 뭔지", 그리고 "어떤 녀석들이 이동을 할 수 있는지" 정도만 알아두셔도 충분해요.

std::vector처럼 이동할 수 있는 타입은 '값으로 반환'해도 끄떡없어요

함수에서 '값으로 반환'하게 되면 그 결과물은 1회용 임시 객체(rvalue)가 됩니다. 따라서 반환되는 타입이 이동 의미론을 지원하기만 한다면, 목적지 객체에 데이터를 복사하는 대신 휙! 하고 이동 시킬 수 있어요. 덕분에 이런 타입들을 값으로 반환하는 건 비용이 거의 안 드는 아주 가벼운 작업이 됩니다!

핵심 포인트 우리는 std::vector 나 std::string 처럼 이동 가능한 타입 을 부담 없이 '값으로 반환'할 수 있습니다. 무겁게 복사하지 않고 가볍게 값을 휙 던져주니까요! (단, 이런 타입들을 함수에 인자로 넘겨줄 때는 여전히 'const 참조' 방식을 사용해야 합니다.)

"잠깐, 잠깐만요! 복사하기 무거운 애들은 '값으로 넘기기' 하면 안 된다면서요? 근데 이동이 가능하면 '값으로 반환'하는 건 괜찮다고요?" 네, 완벽하게 정답입니다!

깊이 알아보기 (선택 사항)

아래부터 이어지는 내용은 안 보셔도 무방하지만, 왜 이런 마법이 가능한지 이해하는 데 큰 도움이 될 거예요.

C++ 프로그래밍을 하면서 우리가 가장 많이 하는 행동 중 하나는, 함수에 어떤 값을 던져주고 다른 값을 받아오는 겁니다. 만약 주고받는 값이 클래스 타입이라면, 이 과정은 크게 4단계 로 나뉩니다.

1. 함수에 던져줄 값을 만듭니다.
2. 실제로 그 값을 함수 안으로 넘겨줍니다.
3. 함수 안에서 반환할 결과값을 만듭니다.
4. 실제로 그 결과값을 함수를 부른 쪽으로 돌려줍니다.

std::vector 를 이용한 예제로 이 과정을 살펴볼까요?

#include <iostream>
#include <vector>

std::vector<int> doSomething(std::vector<int> v2)
{
    std::vector v3 { v2[0] + v2[0] }; // 3단계: 호출한 곳으로 돌려줄 결과값을 만듭니다.
    return v3; // 4단계: 실제로 값을 돌려줍니다(반환).
}

int main()
{
    std::vector v1 { 5 }; // 1단계: 함수에 던져줄 값을 만듭니다.
    std::cout << doSomething(v1)[0] << '\n'; // 2단계: 실제로 값을 함수 안으로 넘겨줍니다.

    std::cout << v1[0] << '\n';

    return 0;
}

먼저 std::vector 가 '이동 능력'이 전혀 없다고 가정해 봅시다. 이 경우 위 프로그램은 무려 네 번의 복사 를 하게 됩니다.

1. 던져줄 값을 만들 때 초기화 내용을 v1 에 복사.
2. 함수에 값을 넘겨줄 때 v1 을 매개변수 v2 에 복사.
3. 결과값을 만들 때 초기화 내용을 v3 에 복사.
4. 결과값을 돌려줄 때 v3 를 바깥으로 복사.

자, 이제 이걸 어떻게 최적화할 수 있을지 이야기해 볼까요? 우리에겐 '참조'로 넘기기, '복사 생략(elision)', '이동 의미론', '출력 매개변수' 같은 다양한 무기들이 있습니다.

1번과 3번 복사는 최적화할 방법이 아예 없습니다. 함수에 넘겨줄 벡터가 필요하고, 반환할 벡터도 필요하기 때문에 무조건 뼈대가 되는 객체를 생성해야만 하거든요. 우리가 건드릴 수 있는 부분은 바로 2번과 4번 복사 입니다.

2번 복사 최적화하기

2번 복사 는 우리가 함수를 부를 때 '값으로 넘기기'를 했기 때문에 발생했습니다. 대안이 있을까요?

• 참조나 주소로 넘길 수 있나요? 네! 넘겨준 객체(v1)가 갑자기 사라지지 않는다는 게 보장되니까요.

• 이 복사를 생략할 수 있나요? 아니요. 쓸데없는 중복 복사가 아니기 때문에 불가능합니다.

• 출력 매개변수를 쓸 수 있나요? 아니요. 우린 지금 값을 넣는 중이지 받아오는 게 아니에요.

• 이동 의미론을 쓸 수 있나요? 아니요! 인자로 넘긴 v1 은 나중에도 써야 하는 멀쩡한 변수입니다. 만약 데이터를 v2 로 이동시켜 뺏어버리면, v1 은 텅 비어버리고 나중에 v1[0] 을 출력하려다 프로그램이 터질 수 있습니다.
  결론적으로 여기서는 'const 참조'로 넘기는 게 최고의 선택 입니다. 무거운 복사를 피할 수 있고 제일 안전하니까요!

4번 복사 최적화하기

4번 복사 는 함수 안에서 다 만든 값을 바깥으로 반환할 때 발생합니다.

• 참조나 주소로 반환할 수 있나요? 절대 안 됩니다! v3 는 함수 안에서 만들어져서 함수가 끝나면 파괴될 녀석입니다. 파괴될 녀석의 주소를 돌려주면 큰일 납니다.

• 이 복사를 생략할 수 있나요? 네, 가능성이 높습니다! 컴파일러가 똑똑하다면 코드를 요령껏 재배치해서 애초에 복사를 안 만들 수 있습니다. 하지만 컴파일러 마음이라 100% 보장할 수는 없어요.

• 출력 매개변수를 쓸 수 있나요? 네. 하지만 코드가 복잡하고 못생겨지며 제약이 너무 많아서 좋은 방법은 아닙니다.

• 이동 의미론을 쓸 수 있나요? 네! 어차피 v3 는 함수가 끝나면 파괴될 운명입니다. 무겁게 밖으로 복사할 필요 없이, 이동 의미론을 써서 v3의 데이터를 밖으로 휙 던져주고(이동) 빠지면 완벽합니다!

가장 좋은 시나리오는 컴파일러가 알아서 복사를 생략해 주는 거지만, 이건 우리가 통제할 수 없습니다. 그 다음으로 훌륭한 최고의 대안이 바로 이동 의미론입니다!

컴파일러가 복사를 안 없애줄 때 구세주가 되어주거든요. 게다가 이동할 수 있는 타입들은 우리가 '값으로 반환'하기만 하면 알아서 자동으로 발동합니다!

정리하자면... std::vector 처럼 이동이 가능한 타입들을 다룰 때는 '함수 인자로 넣을 땐 const 참조로, 밖으로 뺄 땐 값으로 반환' 하는 것이 최고의 비법입니다.

16.6 — 배열과 반복문 (Arrays and loops)

이 챕터의 첫 번째 강의(16.1 - 컨테이너와 배열 소개)에서는 비슷한 역할을 하는 변수들이 엄청나게 많아질 때 생기는 골치 아픈 문제들을 이야기했었죠. 이번 강의에서는 그 문제를 다시 한번 짚어보고, 배열 이 어떻게 이 문제들을 마법처럼 깔끔하게 해결해 주는지 알아볼 거예요!

변수가 너무 많아지는 문제, 다시 살펴보기

학생 5명으로 이루어진 반의 시험 점수 평균을 구한다고 해볼까요? (설명을 간단하게 하기 위해 학생 수를 5명으로 줄였어요.)

각각의 변수를 따로따로 만들어서 코드를 짜면 이렇게 될 겁니다.

#include <iostream>

int main(){
    // 5개의 정수 변수를 만듭니다 (각각 이름이 다 달라요!)
    int testScore1{ 84 };
    int testScore2{ 92 };
    int testScore3{ 76 };
    int testScore4{ 81 };
    int testScore5{ 56 };

    int average { (testScore1 + testScore2 + testScore3 + testScore4 + testScore5) / 5 };

    std::cout << "The class average is: " << average << '\n';

    return 0;
}

변수도 너무 많고, 직접 타이핑해야 할 것도 참 많죠?

만약 학생이 30명, 아니 600명이라면 어떨지 상상해 보세요. 게다가 새로운 시험 점수를 하나 추가하려면 변수를 새로 만들고, 값을 넣어주고, 평균 계산식에도 일일이 더해줘야 해요. 평균을 구할 때 나누는 숫자(위 코드에서는 5)를 바꾸는 것도 잊지 않으셨겠죠? 깜빡했다면 계산 결과가 틀려지는 오류가 발생할 거예요. 기존 코드를 손봐야 할 때마다 이렇게 실수할 위험이 커진답니다.

이쯤 되면 관련된 변수가 무더기로 있을 때는 배열 을 써야 한다는 걸 아실 거예요. 자, 개별 변수들을 std::vector 로 싹 바꿔볼게요!

#include <iostream>
#include <vector>

int main(){
    std::vector testScore { 84, 92, 76, 81, 56 };
    std::size_t length { testScore.size() };

    int average { (testScore[0] + testScore[1] + testScore[2] + testScore[3] + testScore[4])
        / static_cast<int>(length) };

    std::cout << "The class average is: " << average << '\n';

    return 0;
}

오, 훨씬 낫네요! 만들어야 하는 변수 개수가 확 줄었고, 평균을 구할 때 나누는 값도 직접 숫자를 적는 대신 배열의 길이(length)에서 바로 가져오고 있어요.

하지만 평균을 구하는 계산식은 아직도 좀 찜찜합니다. 배열 안에 있는 요소(데이터)들을 [0], [1] 처럼 일일이 손으로 다 적어줘야 하니까요. 이렇게 직접 적어주면, 우리가 적은 개수와 똑같은 길이의 배열에서만 이 계산식이 작동해요. 만약 배열 길이가 달라지면, 그때마다 그 길이에 맞는 새로운 계산식을 또 만들어야 하죠.

우리에게 진짜 필요한 건, 요소들을 하나하나 적는 노가다 없이 배열의 모든 요소에 쉽게 접근할 수 있는 방법 이에요.

배열과 반복문의 만남

이전 강의에서 배열의 인덱스(순서를 나타내는 번호)는 꼭 고정된 숫자일 필요가 없다고 배웠어요. 즉, 프로그램이 실행 중일 때 값이 변하는 '변수'를 인덱스로 쓸 수 있다는 뜻이에요!

위의 평균 계산식에서 쓴 인덱스들을 보면 0, 1, 2, 3, 4 처럼 차례대로 1씩 커지고 있죠. 그렇다면 어떤 변수의 값을 0부터 4까지 차례대로 변하게 만들 수 있다면, 일일이 숫자를 쓰는 대신 그 변수를 인덱스 자리에 쏙 넣으면 되지 않을까요? 우리는 이미 그 방법을 알고 있어요. 바로 for 반복문 을 쓰는 거예요!

이제 for 반복문을 써서 위의 예제를 다시 써볼게요. 반복문에서 1씩 커지는 변수를 배열의 인덱스로 쓸 겁니다.

#include <iostream>
#include <vector>

int main(){
    std::vector testScore { 84, 92, 76, 81, 56 };
    std::size_t length { testScore.size() };

    int average { 0 };
    for (std::size_t index{ 0 }; index < length; ++index) // index를 0부터 '길이-1'까지 반복시킵니다
        average += testScore[index];                      // 해당 `index` 번호에 있는 값을 average에 더합니다
    average /= static_cast<int>(length);                  // 다 더한 값을 길이로 나누어 평균을 계산합니다

    std::cout << "The class average is: " << average << '\n';

    return 0;
}

작동 원리는 아주 단순해요. index 변수가 0으로 시작해서 testScore[0] 의 값이 average 에 더해집니다. 그러고 나면 index 가 1로 늘어나죠. 그다음 testScore[1] 이 더해지고, 다시 index 가 2로 늘어납니다. 이렇게 계속되다가 마침내 index 가 5가 되면, index < length (5 < 5)라는 조건이 거짓(false)이 되면서 반복문이 알아서 종료됩니다.

이 시점이 되면 반복문 덕분에 testScore[0] 부터 testScore[4] 까지의 값이 모두 average 에 알차게 더해져 있을 거예요. 마지막으로, 이렇게 싹 다 더한 값을 배열의 길이로 나눠서 진짜 평균을 구하는 거죠.

이 방법은 코드를 관리하기에 정말 완벽해요! 반복문이 도는 횟수는 배열의 길이에 따라 자동으로 정해지고, 반복문 변수가 배열의 인덱스 역할을 알아서 척척 해줍니다. 이제 배열 요소를 일일이 손으로 적을 필요가 없어요. 만약 시험 점수를 추가하거나 빼고 싶다면? 처음에 배열을 만들 때 숫자만 추가/삭제하면 끝이에요. 나머지 코드는 단 한 줄도 고칠 필요 없이 완벽하게 작동한답니다!

이렇게 컨테이너(배열 같은 자료 구조)의 각 요소를 하나씩 순서대로 확인하는 것을 프로그래밍 용어로 순회(traversal) 라고 해요. 다른 말로는 반복(iteration) 한다거나 이터레이팅(iterating) 한다고도 부릅니다. 꼭 기억해 두세요!

작가의 노트 컨테이너 클래스들은 길이나 인덱스를 다룰 때 보통 size_t 라는 타입을 사용해요. 그래서 이번 강의에서도 똑같이 size_t 를 썼습니다. 음수까지 표현할 수 있는(signed) 타입들을 사용하는 방법은 다가오는 16.7 강의에서 다룰게요.

템플릿, 배열, 그리고 반복문: 무한한 확장성 열기!

• 배열은 데이터마다 일일이 이름을 붙이지 않고도 여러 개를 한 번에 저장할 수 있게 해줘요.
• 반복문은 요소들을 손으로 다 적지 않고도 배열을 쭉 훑어볼 수(순회) 있게 해줘요.
• 템플릿은 저장할 데이터의 '타입(종류)'을 내 마음대로 바꿀 수 있게 해줘요.

이 세 가지가 합쳐지면 정말 놀라운 일이 벌어집니다! 안에 들어있는 데이터가 정수든 소수든, 개수가 5개든 100개든 상관없이 어떤 컨테이너라도 완벽하게 다룰 수 있는 코드를 짤 수 있거든요.

이해를 돕기 위해, 방금 만든 평균 계산 코드를 '함수 템플릿'이라는 형태로 업그레이드해 볼게요.

#include <iostream>
#include <vector>

// std::vector 안에 있는 값들의 평균을 계산해 주는 함수 템플릿입니다
template <typename T>
T calculateAverage(const std::vector<T>& arr){
    std::size_t length { arr.size() };

    T average { 0 };                                      // 배열 안에 든 요소가 T 타입이면, 평균값을 저장할 변수도 T 타입이어야겠죠?
    for (std::size_t index{ 0 }; index < length; ++index) // 모든 요소를 처음부터 끝까지 순회합니다
        average += arr[index];                            // 모든 요소를 싹 다 더합니다
    average /= static_cast<int>(length);                  // 전체 개수로 나눕니다 (개수는 사람 수나 사물 개수처럼 자연스러운 정수니까요)

    return average;
}

int main(){
    std::vector class1 { 84, 92, 76, 81, 56 };
    std::cout << "The class 1 average is: " << calculateAverage(class1) << '\n'; // 정수형(int) 5개의 평균을 계산합니다!

    std::vector class2 { 93.2, 88.6, 64.2, 81.0 };
    std::cout << "The class 2 average is: " << calculateAverage(class2) << '\n'; // 소수형(double) 4개의 평균을 계산합니다!

    return 0;
}

이 코드를 실행하면 이렇게 출력됩니다.

The class 1 average is: 77
The class 2 average is: 81.75

위의 예제에서 우리는 calculateAverage() 라는 똑똑한 함수 템플릿을 만들었어요. 이 함수는 안에 든 데이터 종류나 길이에 상관없이 어떤 std::vector 를 던져줘도 평균을 구해냅니다. main() 함수를 보면 정수(int) 5개가 든 배열이든, 소수점(double) 4개가 든 배열이든 똑같이 잘 작동하는 걸 확인할 수 있어요!

calculateAverage() 함수는 안에서 사용된 더하기(+=)나 나누기(/=) 같은 연산이 가능한 타입(T)이라면 뭐든지 다 처리할 수 있습니다. 만약 더하기나 나누기를 할 수 없는 이상한 타입을 넣으면? 컴파일러가 알아채고 당장 오류를 뿜어낼 거예요.

참, 코드를 보면서 왜 길이를 나타내는 length 를 굳이 int 로 바꿨는지(static_cast<int>) 궁금하실 수도 있어요. 평균을 구할 때는 다 더한 총합을 항목의 '개수'로 나누죠. 개수라는 건 소수점이 없는 정수(integral value)잖아요? 그래서 코드를 읽을 때 "아, 의미상 정수로 나누는 게 맞지" 하고 바로 이해할 수 있도록 int 로 명확하게 바꿔준 거랍니다.

배열과 반복문으로 할 수 있는 일들

이제 반복문으로 컨테이너를 훑어보는(순회하는) 방법을 완벽히 알았으니, 실전에서 주로 이걸로 뭘 하는지 살펴볼게요. 우리는 보통 다음 4가지 중 하나를 하려고 반복문을 씁니다.

1. 새로운 값 계산하기: 기존 데이터들을 써서 새로운 결과 만들기 (예: 평균 구하기, 싹 다 더하기)
2. 원하는 데이터 찾기: 특정 요소 찾기 (예: 나랑 똑같은 값 있나?, 100점 맞은 사람 몇 명인지 세기, 제일 큰 값 찾기)
3. 각 요소마다 특정 작업하기: (예: 화면에 하나씩 예쁘게 출력하기, 모든 점수에 보너스 2점씩 더하기)
4. 순서 바꾸기: 요소들 다시 줄 세우기 (예: 작은 숫자부터 큰 숫자 순서로 정렬하기)

첫 번째부터 세 번째까지는 꽤 쉬워요. 반복문을 한 바퀴만 돌리면서 데이터를 슬쩍 보거나 입맛대로 바꾸면 되니까요.

하지만 요소들의 순서를 바꾸는(정렬) 작업은 꽤 까다롭습니다. 보통 반복문 안에 반복문을 또 넣어야 하거든요. 우리가 직접 머리를 싸매고 코드를 짤 수도 있지만, 사실 C++ 표준 라이브러리에 아주 훌륭한 알고리즘들이 이미 다 만들어져 있어요! 그냥 그걸 가져다 쓰는 게 훨씬 똑똑한 방법이죠. 이 부분은 나중에 알고리즘 챕터에서 더 자세히 알려드릴게요.

배열을 쓸 때 흔히 하는 실수: 1 차이 오류 (Off-by-one errors)

인덱스를 써서 배열을 훑어볼 때는 반복문이 정확한 횟수만큼 도는지 눈에 불을 켜고 확인해야 해요. 초보자뿐만 아니라 전문가도 가장 많이 하는 실수가 바로 '1 차이 오류'랍니다. 반복문이 실수로 한 번 더 돌거나 한 번 덜 도는 거죠.

보통은 index 를 0 부터 시작해서 index < length 일 때까지만 반복하도록 코드를 짭니다.

하지만 프로그래밍을 처음 하시는 분들은 실수로 조건에 작거나 같다(<=) 를 써서 index <= length 처럼 만드는 경우가 종종 있어요. 이렇게 되면 index 와 length 가 같아질 때도 반복문이 돌아가 버려요. 결국 배열의 크기를 넘어서 엉뚱한 메모리를 건드리게 되고, 프로그램이 알 수 없는 이상한 행동을 하게 만드는 무서운 결과를 낳습니다. 조심, 또 조심하세요!

16.7 — 배열, 루프, 그리고 부호(Sign) 문제 해결 방법

이전 레슨인 '4.5 - 부호 없는 정수와 이를 피해야 하는 이유'에서, 우리는 수량을 저장할 때 일반적으로 부호 있는 값을 선호한다고 배웠습니다. 부호 없는 값은 가끔 우리의 예상과 전혀 다르게 동작할 수 있기 때문이죠. 하지만 '16.3 - std::vector 와 부호 없는 길이 및 인덱스 문제' 레슨에서 다루었듯이, std::vector 와 같은 컨테이너 클래스들은 길이와 인덱스를 표현할 때 부호 없는 정수 타입인 std::size_t 를 사용합니다.

이로 인해 다음과 같은 골치 아픈 문제가 발생할 수 있습니다.

#include <iostream>
#include <vector>

template <typename T>
void printReverse(const std::vector<T>& arr)
{
    for (std::size_t index{ arr.size() - 1 }; index >= 0; --index) // index는 부호 없는(unsigned) 정수입니다
    {
        std::cout << arr[index] << ' ';
    }

    std::cout << '\n';
}

int main()
{
    std::vector arr{ 4, 6, 7, 3, 8, 2, 1, 9 };

    printReverse(arr);

    return 0;
}

이 코드를 실행하면 처음에는 배열을 거꾸로 잘 출력하는 것처럼 보입니다.

9 1 2 8 3 7 6 4

하지만 그 직후, 정의되지 않은 동작을 일으킵니다. 쓰레기 값을 출력하거나 프로그램이 아예 튕겨버릴 수 있죠.

여기에는 두 가지 큰 문제가 숨어 있습니다.

첫째, 우리의 루프는 index >= 0 (즉, 인덱스가 양수인 동안) 계속 실행되도록 작성되었습니다. 그런데 index가 부호 없는(unsigned) 타입이라면, 이 조건은 항상 참(true) 이 됩니다. 마이너스 값이 아예 존재할 수 없으니까요! 결과적으로 이 루프는 영원히 끝나지 않습니다.

둘째, index가 0일 때 1을 빼면(감소시키면), 마이너스 값이 되는 대신 엄청나게 큰 양수 로 한 바퀴 돌아가 버립니다(이를 랩어라운드, Wrap-around라고 합니다).

그리고 다음 루프에서 이 거대한 숫자를 배열의 인덱스로 사용하게 되죠. 이는 배열의 진짜 크기를 완전히 벗어난 접근(Out-of-bounds)이며, 프로그램을 망가뜨리는 원인이 됩니다. 만약 배열(벡터)이 텅 비어있을 때도 똑같은 문제가 발생합니다.

이런 문제를 피하는 여러 가지 꼼수가 있긴 하지만, 애초에 이런 방식 자체가 버그를 끌어당기는 자석과도 같습니다.

루프 변수로 부호 있는(signed) 타입을 사용하면 이런 문제를 훨씬 쉽게 피할 수 있지만, 대신 또 다른 귀찮은 점이 생깁니다. 다음은 부호 있는 인덱스를 사용해서 위 문제를 고쳐본 코드입니다.

#include <iostream>
#include <vector>

template <typename T>
void printReverse(const std::vector<T>& arr)
{
    for (int index{ static_cast<int>(arr.size()) - 1}; index >= 0; --index) // index는 부호 있는(signed) 정수입니다
    {
        std::cout << arr[static_cast<std::size_t>(index)] << ' ';
    }

    std::cout << '\n';
}

int main()
{
    std::vector arr{ 4, 6, 7, 3, 8, 2, 1, 9 };

    printReverse(arr);

    return 0;
}

이 코드는 우리가 원하는 대로 완벽하게 작동합니다. 하지만 코드가 굉장히 지저분해졌습니다. static_cast (타입 변환)가 두 번이나 들어갔기 때문이죠. 특히 arr[static_cast<std::size_t>(index)] 부분은 눈으로 읽기 너무 불편합니다. 안전성을 얻은 대신, 코드를 읽기 쉽게 만드는 가독성을 크게 희생한 셈입니다.

부호 있는 인덱스를 사용한 또 다른 예시를 볼까요?

#include <iostream>
#include <vector>

// std::vector의 평균값을 계산하는 함수 템플릿
template <typename T>
T calculateAverage(const std::vector<T>& arr)
{
    int length{ static_cast<int>(arr.size()) };

    T average{ 0 };
    for (int index{ 0 }; index < length; ++index)
        average += arr[static_cast<std::size_t>(index)];
    average /= length;

    return average;
}

int main()
{
    std::vector testScore1 { 84, 92, 76, 81, 56 };
    std::cout << "The class 1 average is: " << calculateAverage(testScore1) << '\n';

    return 0;
}

여기서도 static_cast 때문에 코드가 지저분해지는 건 여전합니다. 정말 끔찍하죠.

그럼 도대체 어떻게 해야 할까요? 안타깝게도 이 문제에 대해 완벽한 정답은 없습니다. 대신 우리가 쓸 수 있는 여러 가지 선택지들이 있습니다. 지금부터 저희가 생각하기에 가장 최악인 방법부터 가장 추천하는 방법 순서 로 소개해 드리겠습니다. 실무에서 다른 사람들이 작성한 코드를 보면 이 방법들을 모두 마주치게 될 것입니다.

저자의 참고 사항 여기서는 std::vector 를 기준으로 설명하지만, std::array 와 같은 모든 표준 라이브러리 컨테이너들도 똑같이 작동하며 같은 문제를 가지고 있습니다. 따라서 아래의 설명은 어떤 컨테이너를 쓰든 똑같이 적용됩니다.

부호 변환 경고 끄기 (비추천)

혹시 컴파일러에서 부호 변환 경고가 왜 기본적으로 꺼져 있는 경우가 많은지 궁금하셨다면, 바로 이 문제 때문입니다. 표준 라이브러리 컨테이너에 부호 있는 인덱스를 사용할 때마다 경고가 발생하거든요. 이 경고들이 컴파일 로그를 꽉 채워버리면, 정작 우리가 고쳐야 할 진짜 중요한 경고들을 놓치게 됩니다.

그래서 아예 이 경고들을 무시하도록 설정하는 것이 하나의 방법입니다. 가장 간단한 해결책이지만, 절대 추천하지 않습니다. 자칫하면 진짜 버그를 일으킬 수 있는 위험한 부호 변환 문제까지 모두 숨겨버리기 때문입니다.

부호 없는 루프 변수 사용하기

많은 개발자들이 "표준 라이브러리가 원래 부호 없는 인덱스를 쓰도록 만들어졌으니, 우리도 부호 없는 인덱스를 쓰면 되지!" 라고 생각합니다. 아주 타당한 의견입니다. 단, 부호가 있는 값과 없는 값이 섞여서 발생하는 문제(mismatch)가 생기지 않도록 각별히 조심해야 합니다. 가능하면 인덱스 루프 변수는 순수하게 '위치를 찾는 용도'로만 사용하는 것이 좋습니다.

그렇다면 어떤 부호 없는 타입을 사용해야 할까요?

이전 레슨에서 표준 라이브러리 컨테이너들은 size_type 이라는 내부 타입을 가지고 있다고 배웠습니다. .size() 함수도 이 타입을 반환하고, [] 기호도 이 타입을 인덱스로 사용하죠. 따라서 기술적으로는 size_type 을 사용하는 것이 가장 안전하고 일관된 방법입니다.

#include <iostream>
#include <vector>

int main()
{
    std::vector arr { 1, 2, 3, 4, 5 };

    for (std::vector<int>::size_type index { 0 }; index < arr.size(); ++index)
        std::cout << arr[index] << ' ';

    return 0;
}

하지만 이 방법엔 아주 큰 단점이 있습니다. 이름이 너무 길다는 것이죠! std::size_type 이라고 간단히 쓸 수 없고, std::vector<int>::size_type 처럼 컨테이너의 전체 이름을 다 적어줘야 합니다. 타이핑하기도 힘들고 읽기도 불편합니다.

심지어 템플릿 함수 안에서 사용할 때는 앞에 typename 이라는 키워드까지 붙여줘야 합니다.

#include <iostream>
#include <vector>

template <typename T>
void printArray(const std::vector<T>& arr)
{
    // 의존적 이름(dependent type)에는 typename 키워드 접두사가 필요합니다
    for (typename std::vector<T>::size_type index { 0 }; index < arr.size(); ++index)
        std::cout << arr[index] << ' ';
}

int main()
{
    std::vector arr { 9, 7, 5, 3, 1 };

    printArray(arr);

    return 0;
}

이 코드를 더 짧게 줄이기 위해 decltype 이나 별칭(using)을 쓸 수도 있지만, 여전히 기억하기 어렵고 복잡합니다.

그래서 많은 프로그래머들은 길고 복잡한 size_type 대신, 기억하기도 쉽고 치기도 편한 std::size_t 를 직접 사용합니다. (사실 size_type 도 결국 대부분 size_t 와 똑같기 때문입니다.)

for (std::size_t index { 0 }; index < arr.size(); ++index)

여러분이 직접 메모리 할당기를 만드는 고수급 개발자가 아니라면, 이 정도면 꽤 합리적인 방법입니다.

부호 있는 루프 변수 사용하기

표준 라이브러리를 다루기엔 조금 번거로워지지만, 루프 변수로 부호 있는 값을 사용하는 것은 우리가 평소에 쓰는 코드 스타일(수량엔 부호 있는 값을 쓴다)과 일치합니다. 좋은 습관을 일관되게 지킬수록 전체적인 에러는 줄어들기 마련이죠.

부호 있는 변수를 쓰려면 세 가지 문제를 해결해야 합니다.

1. 어떤 타입을 쓸 것인가?
2. 배열의 길이를 어떻게 부호 있는 값으로 가져올 것인가?
3. 부호 있는 루프 변수를 배열 인덱스(부호 없음)로 어떻게 변환할 것인가?

1. 어떤 부호 있는 타입을 사용해야 할까요? 엄청나게 큰 배열을 다루는 게 아니라면, 그냥 우리가 평소에 쓰는 기본 숫자인 int 를 쓰시면 됩니다.

만약 배열이 아주 크거나 좀 더 안전하게 코딩하고 싶다면, 이름은 좀 이상하지만 std::ptrdiff_t 라는 타입을 사용할 수 있습니다. 이는 std::size_t 의 부호 있는 버전이라고 생각하시면 됩니다.

이름이 너무 어려우니, 아래처럼 직접 별명을 만들어(alias) 사용하는 것도 좋은 팁입니다.

using Index = std::ptrdiff_t;
// index를 사용한 샘플 루프
for (Index index{ 0 }; index < static_cast<Index>(arr.size()); ++index)

2. 배열의 길이를 부호 있는 값으로 가져오기 C++20 이전 버전에서는 배열의 크기를 반환하는 .size() 의 결과값에 static_cast 를 씌워 부호 있는 타입으로 바꿔주는 것이 최선이었습니다.

하지만 C++20 부터는 구세주가 등장했습니다! 바로 std::ssize() 입니다. 이 함수는 알아서 배열의 크기를 '부호 있는 타입'으로 반환해 줍니다. C++ 언어를 만드는 사람들도 이제는 "부호 있는 인덱스를 쓰는 게 맞다"고 생각한다는 강력한 증거이기도 하죠.

#include <iostream>
#include <vector>

int main()
{
    std::vector arr{ 9, 7, 5, 3, 1 };

    for (auto index{ std::ssize(arr)-1 }; index >= 0; --index) // std::ssize는 C++20에 도입되었습니다
        std::cout << arr[static_cast<std::size_t>(index)] << ' ';

    return 0;
}

3. 부호 있는 루프 변수를 부호 없는 인덱스로 변환하기 부호 있는 변수를 만들었지만, 막상 배열 안에 arr[index] 처럼 넣으려고 하면 또 경고가 뜹니다. 그래서 매번 static_cast 를 써야 하는데 코드가 지저분해지죠.

이를 해결하기 위해 짧은 이름의 도우미 함수를 직접 만들 수도 있습니다.

#include <iostream>
#include <type_traits> // std::is_integral과 std::is_enum을 위해 필요
#include <vector>

using Index = std::ptrdiff_t;

// value를 std::size_t 타입의 객체로 변환하는 도우미 함수
// UZ는 std::size_t 타입 리터럴의 접미사입니다.
template <typename T>
constexpr std::size_t toUZ(T value)
{
    // T가 정수형 타입인지 확인합니다
    static_assert(std::is_integral<T>() || std::is_enum<T>());

    return static_cast<std::size_t>(value);
}

int main()
{
    std::vector arr{ 9, 7, 5, 3, 1 };

    auto length { static_cast<Index>(arr.size()) };  // C++20에서는 std::ssize() 사용을 권장합니다
    for (auto index{ length-1 }; index >= 0; --index)
        std::cout << arr[toUZ(index)] << ' '; // 부호 변환 경고를 피하기 위해 toUZ()를 사용합니다

    return 0;
}

arr[toUZ(index)] 라고 쓰니 아까보다 훨씬 읽기 편해졌죠?

원시 C 스타일 배열로 접근하기 (가장 추천하는 인덱싱 방법)

이전 레슨에서, 컨테이너를 직접 인덱싱하는 대신 .data() 함수를 써서 그 안에 숨겨진 진짜 C 스타일 배열을 꺼내 쓸 수 있다고 배웠습니다. C 스타일 배열은 부호가 있든 없든 가리지 않고 인덱스를 받아주기 때문에, 복잡한 변환 경고 문제를 완벽하게 피해갈 수 있습니다!

int main()
{
    std::vector arr{ 9, 7, 5, 3, 1 };

    auto length { static_cast<Index>(arr.size()) };  // C++20에서는 std::ssize() 사용을 권장합니다
    for (auto index{ length - 1 }; index >= 0; --index)
        std::cout << arr.data()[index] << ' ';       // 부호 변환 경고를 피하기 위해 data()를 사용합니다

    return 0;
}

저희는 인덱스를 꼭 써야 한다면 이 방법이 가장 좋다고 생각합니다:

• 부호 있는 변수와 인덱스를 마음껏 쓸 수 있습니다.
• 복잡한 별명이나 도우미 함수를 만들 필요가 없습니다.
• .data() 를 붙인다고 해서 코드가 크게 지저분해지지 않습니다.
• 최적화된 환경에서는 속도 저하도 전혀 없습니다.

아예 인덱싱을 쓰지 마세요

지금까지 여러 가지 꼼수와 방법들을 소개해 드렸지만, 사실 모두 어느 정도의 단점을 가지고 있습니다. 하지만 이 모든 스트레스에서 벗어날 수 있는 훨씬 깔끔하고 현명한 방법이 있습니다. 바로 인덱스 숫자 자체를 쓰지 않는 것입니다.

C++ 에는 인덱스 숫자 없이도 배열 안의 데이터들을 하나씩 꺼내볼 수 있는 훌륭한 기능들이 있습니다. 숫자를 쓰지 않으니 부호 문제로 골치 아플 일도 없죠! 가장 대표적인 두 가지 방법이 바로 범위 기반 for 루프(range-based for loops) 와 반복자(iterators) 입니다.

관련 내용 범위 기반 for 루프는 다음 레슨 (16.8)에서 배웁니다. 반복자(Iterators)는 다가오는 레슨 (18.2)에서 배웁니다.

만약 여러분이 인덱스 변수를 단지 '배열의 처음부터 끝까지 돌아보기 위한 용도'로만 쓰고 계셨다면, 무조건 인덱스를 쓰지 않는 방법을 우선으로 선택하세요.

모범 사례 가능한 한 정수 숫자를 이용한 배열 인덱싱은 피하세요.

16.8 — 범위 기반 for 문 (for-each 문)

이전 16.6 레슨(배열과 반복문)에서는 인덱스(순서 번호)를 사용해서 배열의 각 항목을 하나씩 확인하는 기본 for 문을 배웠습니다. 예시를 다시 한번 볼까요?

#include <iostream>
#include <vector>

int main()
{
    std::vector fibonacci { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };

    std::size_t length { fibonacci.size() };
    for (std::size_t index { 0 }; index < length; ++index)
       std::cout << fibonacci[index] << ' ';

    std::cout << '\n';

    return 0;
}

기본 for 문은 배열을 순서대로 살펴볼 때 아주 편리한 방법입니다. 하지만 배열의 길이를 잘못 계산하거나, 처음과 끝을 잘못 지정하는 등(off-by-one 에러) 실수하기가 아주 쉽다는 단점이 있습니다. 게다가 인덱스의 부호 문제로 골치를 앓을 수도 있죠.

배열을 처음부터 끝까지 쭉 훑어보는 작업은 프로그래밍에서 정말 자주 쓰입니다. 그래서 C++은 인덱스를 헷갈리게 계산하지 않아도 되는 아주 편리한 기능을 제공합니다. 바로 범위 기반 for 문 (또는 for-each 문 이라고도 부름)입니다! 이 반복문은 사용하기 훨씬 간단하고 안전하며, std::vector, std::array 등 C++에서 쓰는 거의 모든 배열 타입에 사용할 수 있습니다.

범위 기반 for 문

범위 기반 for 문 은 다음과 같은 형태로 작성합니다:

for (element_declaration : array_object)
   statement;

컴퓨터가 이 반복문을 만나면, array_object(배열) 안에 있는 항목들을 처음부터 끝까지 하나씩 차례대로 꺼내옵니다. 반복될 때마다 현재 항목의 값이 element_declaration (새로 만든 변수)에 쏙 들어가고, 그 밑에 있는 statement(실행할 코드)가 작동하는 방식입니다.

여기서 팁! 새로 선언하는 변수의 타입은 배열 안에 들어있는 항목의 타입과 똑같아야 합니다. 다르면 컴퓨터가 억지로 타입을 바꾸려다가 문제가 생길 수 있어요.

피보나치(fibonacci) 배열의 모든 항목을 출력하는 아주 간단한 예시를 볼까요?

#include <iostream>
#include <vector>

int main()
{
    std::vector fibonacci { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };

    for (int num : fibonacci) // fibonacci 배열을 순회하며 각 값을 `num`에 복사합니다.
       std::cout << num << ' '; // `num`의 현재 값을 출력합니다.

    std::cout << '\n';

    return 0;
}

이 코드를 실행하면 다음과 같이 나옵니다: 0 1 1 2 3 5 8 13 21 34 55 89

정말 놀랍지 않나요? 배열의 전체 길이가 얼마인지 직접 적을 필요도 없고, 헷갈리는 인덱스([i])를 쓸 필요도 없습니다!

작동 원리를 조금 더 자세히 살펴볼까요? 이 반복문은 fibonacci 배열의 모든 항목을 끝까지 훑어봅니다.

1. 첫 번째 반복: 변수 num 에 첫 번째 값인 0이 들어갑니다. 그리고 화면에 0을 출력하죠.
2. 두 번째 반복: num 에 두 번째 값인 1이 들어갑니다. 그리고 1을 출력합니다.

이런 식으로 배열에 남은 항목이 없을 때까지 알아서 착착 진행됩니다. 모든 항목을 다 보면 반복문은 스스로 조용히 종료되고, 프로그램은 다음 단계로 넘어갑니다.

핵심 포인트 여기서 선언한 변수(num)는 "몇 번째인가요?"를 알려주는 인덱스가 아닙니다. 배열 안에 들어있는 실제 값 그 자체입니다! 변수에 값이 쏙 들어간다는 것은, 원본 배열에 있는 값이 변수로 복사 된다는 뜻이에요. (데이터 덩어리가 크다면 복사하는 데 시간이 꽤 걸리겠죠?)

적극 권장 사항 컨테이너(배열 등) 안의 모든 항목을 훑어볼 때는 복잡한 일반 for 문보다 범위 기반 for 문 을 사용하는 것이 훨씬 좋습니다.

텅 빈 배열에서는 어떻게 될까요?

만약 컨테이너 안에 항목이 하나도 없다면, 범위 기반 for 문 안에 있는 코드는 아예 실행되지 않고 조용히 넘어갑니다.

#include <iostream>
#include <vector>

int main()
{
    std::vector empty { };

    for (int num : empty)
       std::cout << "Hi mom!\n";

    return 0;
}

안에 아무것도 없으니 위의 코드는 화면에 아무것도 출력하지 않습니다. 엄마 미안해요!

auto 키워드로 더 똑똑하게 쓰기

아까 변수 타입과 배열 항목의 타입을 똑같이 맞춰야 한다고 했죠? 이럴 때 auto 키워드를 쓰면 정말 찰떡궁합입니다. 컴퓨터(컴파일러)가 알아서 배열을 보고 "아, 이 배열에는 정수가 들어있으니 변수도 정수형이겠구나!" 하고 타입을 자동으로 맞춰주거든요. 우리가 일일이 적을 필요도 없고, 오타를 낼 걱정도 사라집니다.

위에서 본 예시에 auto 를 적용해 볼게요:

#include <iostream>
#include <vector>

int main()
{
    std::vector fibonacci { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };

    for (auto num : fibonacci) // 컴파일러가 num의 타입을 `int`로 자동 유추합니다.
       std::cout << num << ' ';

    std::cout << '\n';

    return 0;
}

std::vector fibonacci 에는 int(정수) 타입들이 들어있기 때문에, 컴퓨터는 num 이 int 타입이라는 것을 척 보고 알아냅니다.

적극 권장 사항 범위 기반 for 문을 쓸 때는 auto 키워드를 사용해서 컴퓨터가 스스로 타입을 알아내게 하세요.

auto 를 쓰면 좋은 점이 또 하나 있습니다. 나중에 배열의 데이터 타입이 int에서 더 큰 숫자인 long으로 바뀌더라도, 코드를 수정할 필요가 없습니다. 컴퓨터가 알아서 바뀐 타입에 맞춰주기 때문에 에러가 날 확률이 크게 줄어들죠!

참조(Reference)를 사용해서 무거운 복사 피하기

이번에는 글자들(std::string)이 들어있는 배열을 훑어보는 코드를 생각해 봅시다.

#include <iostream>
#include <string>
#include <vector>

int main()
{
    std::vector<std::string> words{ "peter", "likes", "frozen", "yogurt" };

    for (auto word : words)
        std::cout << word << ' ';

    std::cout << '\n';

    return 0;
}

이 코드가 반복될 때마다 배열에 있는 글자들이 변수 word 로 하나씩 '복사'됩니다. 글자 데이터(std::string)를 복사하는 건 컴퓨터에게 꽤 무겁고 힘든 작업이에요. 단순히 화면에 출력만 하고 버릴 건데, 굳이 무겁게 복사본을 만들 필요는 없겠죠?

다행히 변수를 참조 (reference) 로 만들면 이 문제를 해결할 수 있습니다! 그냥 배열에 있는 원본을 손가락으로 가리키기만 하는 방식이에요.

#include <iostream>
#include <string>
#include <vector>

int main()
{
    std::vector<std::string> words{ "peter", "likes", "frozen", "yogurt" };

    for (const auto& word : words) // 이제 word는 읽기 전용 참조(const reference)입니다.
        std::cout << word << ' ';

    std::cout << '\n';

    return 0;
}

위 예시에서 word 에 const auto& 를 붙였습니다. 이렇게 하면 매번 반복될 때마다 굳이 무겁게 복사본을 만들지 않고, 원본 데이터에 바로 연결됩니다! 화면에 출력만 할 거라서 const(읽기 전용, 수정 불가)를 붙여서 원본이 다치지 않게 안전장치도 걸어두었죠.

만약 원본 데이터를 직접 수정하고 싶다면 const를 빼고 그냥 auto& 라고 쓰면 됩니다.

언제 auto, auto&, const auto& 를 써야 할까요?

가벼운 데이터는 auto , 원본을 수정하고 싶을 때는 auto& , 무거운 데이터는 const auto& 를 쓰는 것이 기본 규칙입니다. 하지만 범위 기반 for 문을 쓸 때는 미래를 대비해서 무조건 const auto& 를 쓰는 것을 추천 하는 전문가들이 많습니다. 왜 그럴까요?

다음 코드를 한번 보세요.

#include <iostream>
#include <string_view>
#include <vector>

int main()
{
    std::vector<std::string_view> words{ "peter", "likes", "frozen", "yogurt" }; // 요소들이 std::string_view 타입입니다.

    for (auto word : words) // string_view는 보통 값으로 전달하므로, 여기서는 auto를 사용합니다.
        std::cout << word << ' ';

    std::cout << '\n';

    return 0;
}

std::string_view는 아주 가벼운 녀석이라서 복사해도 전혀 부담이 없습니다. 그래서 auto 를 썼죠. 그런데 만약 나중에 프로그램이 수정되어서, 이 배열이 무거운 std::string 배열로 바뀐다면 어떨까요?

#include <iostream>
#include <string>
#include <vector>

int main()
{
    std::vector<std::string> words{ "peter", "likes", "frozen", "yogurt" }; // 이 부분을 수정해야 하는 건 명백합니다.

    for (auto word : words) // 하지만 이 부분도 수정해야 한다는 건 눈치채기 어렵습니다.
        std::cout << word << ' ';

    std::cout << '\n';

    return 0;
}

이 코드는 아무 에러 없이 잘 실행됩니다. 하지만 auto라고 적어둔 코드 때문에, 갑자기 매번 무거운 문자열 복사 작업이 몰래 일어나게 됩니다. 우리도 모르는 사이에 프로그램이 엄청나게 느려져 버리는 엄청난 손해를 보게 되는 거죠!

이런 무서운 상황을 피하려면 어떻게 해야 할까요? 단순히 복사본을 피하고 싶다면, 처음부터 const auto& 를 기본으로 쓰는 것이 좋습니다. 원본을 살짝 가리키는 방식(참조)은 성능에 나쁜 영향을 거의 주지 않으면서도, 나중에 데이터 타입이 무거운 것으로 바뀌었을 때 갑자기 프로그램이 느려지는 대참사를 완벽하게 막아주기 때문입니다.

권장 사항 범위 기반 for 문에서 요소의 타입을 정할 때는 다음 기준을 따르세요.

• auto : 데이터를 복사해서 그 복사본을 수정하고 싶을 때.
• auto& : 원본 데이터를 직접 수정하고 싶을 때.
• const auto& : 그 외의 모든 경우 (그냥 원본 데이터를 살펴보기만 할 때. 이것이 가장 추천하는 방법입니다!)

다른 종류의 표준 배열(컨테이너)들과 함께 쓰기

범위 기반 for 문은 우리가 배운 기본 배열뿐만 아니라, std::array, std::vector는 물론이고 리스트(Linked list), 트리(Trees), 맵(Maps) 같은 C++의 아주 다양한 데이터 묶음과 모두 찰떡처럼 잘 작동합니다. 아직 이런 것들을 안 배웠어도 전혀 걱정 마세요! "범위 기반 for 문은 거의 모든 컨테이너에서 쓸 수 있는 만능 도구구나!" 라고만 기억해 두시면 됩니다.

#include <array>
#include <iostream>

int main()
{
    std::array fibonacci{ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 }; // 여기서는 std::array를 사용했다는 점에 주목하세요.

    for (auto number : fibonacci)
    {
        std::cout << number << ' ';
    }

    std::cout << '\n';

    return 0;
}

심화 학습자를 위한 참고 배열의 길이를 잃어버린 '퇴화된(decayed) C-스타일 배열'에서는 이 기능을 쓸 수 없습니다. 범위 기반 for 문은 배열이 언제 끝나는지 전체 길이를 꼭 알아야 하거든요. 또, 열거형(enum)에서도 바로 쓸 수는 없는데, 이를 해결하는 방법은 나중에 17.6 레슨에서 배우게 됩니다.

현재 항목의 인덱스(순서 번호) 알아내기

범위 기반 for 문은 아주 편리하지만, "지금 이게 몇 번째 항목이지?" 하고 알려주는 기능은 쏙 빠져있습니다. C++이 제공하는 여러 컨테이너 중에는 아예 순서 번호(인덱스)라는 개념 자체가 없는 애들도 있기 때문이죠.

이 반복문은 무조건 앞으로만 직진하고 중간에 건너뛰지 않기 때문에, 순서를 세는 변수(카운터)를 따로 하나 만들어서 숫자를 올려가는 방식을 쓸 수는 있습니다. 하지만 굳이 그렇게까지 순서 번호가 필요하다면, 범위 기반 for 문 대신 그냥 옛날 방식의 일반 for 문을 쓰는 게 더 나은 선택일 수 있습니다.

거꾸로 훑어보기 (C++20 버전 이상)

방금 말씀드렸듯, 이 반복문은 무조건 처음부터 끝까지 앞으로만 쭉 직진합니다. 하지만 가끔은 뒤에서부터 거꾸로 읽어오고 싶을 때가 있죠? 예전 C++ 버전에서는 이를 쉽게 할 수 없어서 일반 for 문을 써야만 했습니다.

하지만 최신 C++20 버전부터는 마법 같은 방법이 생겼습니다! Ranges 라이브러리의 std::views::reverse 라는 도구를 쓰면, 거꾸로 훑어보는 뷰(view)를 만들어낼 수 있습니다.

#include <iostream>
#include <ranges> // C++20
#include <string_view>
#include <vector>

int main()
{
    std::vector<std::string_view> words{ "Alex", "Bobby", "Chad", "Dave" }; // 알파벳 순서대로 정렬됨

    for (const auto& word : std::views::reverse(words)) // 역순 뷰(reverse view)를 생성합니다.
        std::cout << word << ' ';

    std::cout << '\n';

    return 0;
}

이 코드를 실행하면 이름이 거꾸로 출력됩니다:

Dave
Chad
Bobby
Alex

아직 Ranges 라이브러리에 대해 자세히 배우지는 않았으니, 지금은 "최신 버전에는 이런 멋진 마법도 있구나!" 하고 가볍게 알아두시면 충분합니다.

16.9 — 열거형을 활용한 배열 인덱싱과 길이 구하기

배열을 사용할 때 가장 큰 문제점 중 하나는, 0, 1, 2 같은 숫자 인덱스만으로는 그 칸에 들어있는 데이터가 어떤 의미인지 알 수 없다는 점 입니다.

5명의 시험 점수를 담아둔 배열을 예로 들어볼게요.

#include <vector>

int main()
{
    std::vector testScores { 78, 94, 66, 77, 14 };

    testScores[2] = 76; // 이 점수는 누구의 것일까요?
}

testScores[2]가 도대체 어느 학생의 점수를 뜻하는 걸까요? 코드만 봐서는 전혀 알 수가 없습니다.

일반 열거형(Unscoped enumerator)을 인덱스로 쓰기

이전 레슨에서 배열(또는 std::vector)의 칸 번호(인덱스)를 지정할 때는 보통 std::size_t라는 양수형 숫자 타입을 써야 한다고 배웠습니다.

그런데 일반적인 enum(범위를 지정하지 않은 열거형)은 컴퓨터가 알아서 std::size_t 타입의 숫자로 척척 변환해 줍니다! 이 원리를 이용하면, 숫자가 아니라 이름표(열거형) 를 배열의 인덱스로 써서 코드의 의미를 아주 명확하게 만들 수 있어요.

#include <vector>

namespace Students
{
    enum Names
    {
        kenny, // 0
        kyle, // 1
        stan, // 2
        butters, // 3
        cartman, // 4
        max_students // 5
    };
}

int main()
{
    std::vector testScores { 78, 94, 66, 77, 14 };

    testScores[Students::stan] = 76; // 이제 stan(스탠)의 시험 점수를 수정합니다.

    return 0;
}

이렇게 하면 배열의 각 칸이 누구의 점수인지 훨씬 쉽게 알 수 있죠! 게다가 열거자에 적힌 이름들은 기본적으로 '상수(constexpr)' 취급을 받기 때문에, 부호가 없는 숫자로 변환될 때 생기는 에러나 경고도 피할 수 있답니다.

상수가 아닌 열거형 변수 사용하기

일반 enum의 바탕이 되는 숫자 타입은 컴퓨터(컴파일러) 마음대로 결정됩니다. 양수만 될 수도 있고, 음수/양수 모두 되는 타입(signed)이 될 수도 있어요. 열거형 안의 이름표들을 직접 쓸 때는 알아서 처리되니 문제가 없지만, 열거형 '변수'를 따로 만들어서 쓰려고 하면 문제가 생길 수도 있습니다.

만약 기본 타입이 음수/양수 모두 되는 타입으로 잡혀 있다면, 이걸 배열 인덱스로 쓸 때 부호 변환 경고가 뜰 수 있어요.

#include <vector>

namespace Students
{
    enum Names
    {
        kenny, // 0
        kyle, // 1
        stan, // 2
        butters, // 3
        cartman, // 4
        max_students // 5
    };
}

int main()
{
    std::vector testScores { 78, 94, 66, 77, 14 };
    Students::Names name { Students::stan }; // 상수가 아님

    testScores[name] = 76; // Student::Names의 기본 타입이 부호 있는(signed) 타입이라면 부호 변환 경고가 뜰 수 있습니다.

    return 0;
}

이럴 때는 name을 상수로 만들거나, 아니면 아예 enum을 만들 때부터 "이 열거형은 무조건 부호 없는 양수(unsigned int)로 쓸 거야!" 라고 콕 짚어주면 해결됩니다.

#include <vector>

namespace Students
{
    enum Names : unsigned int // 바탕 타입을 unsigned int로 명시적으로 지정합니다.
    {
        kenny, // 0
        kyle, // 1
        stan, // 2
        butters, // 3
        cartman, // 4
        max_students // 5
    };
}

int main()
{
    std::vector testScores { 78, 94, 66, 77, 14 };
    Students::Names name { Students::stan }; // 상수가 아님

    testScores[name] = 76; // name이 unsigned(부호 없음)이므로 부호 변환 경고가 발생하지 않습니다.

    return 0;
}

개수 세기용 열거자 사용하기

눈치채셨나요? 아까부터 열거형 목록 맨 끝에 max_students라는 항목이 슬쩍 들어가 있었죠. 열거형은 따로 숫자를 안 적어주면 0부터 시작해서 1씩 커집니다. 그래서 앞에 5명의 학생이 있으면, 마지막에 오는 max_students는 자동으로 5 가 됩니다!

이걸 '개수 세기용 열거자' 라고 부를게요. 이 값은 전체 학생 수가 몇 명인지 알고 싶을 때 요긴하게 쓰입니다.

#include <iostream>
#include <vector>

namespace Students
{
    enum Names
    {
        kenny, // 0
        kyle, // 1
        stan, // 2
        butters, // 3
        cartman, // 4
        // 앞으로 추가될 학생들은 여기에 넣으세요
        max_students // 5
    };
}

int main()
{
    std::vector<int> testScores(Students::max_students); // 5개의 요소를 가진 벡터(배열)를 만듭니다

    testScores[Students::stan] = 76; // 이제 stan(스탠)의 시험 점수를 수정합니다.

    std::cout << "The class has " << Students::max_students << " students\n";

    return 0;
}

이 방법은 정말 마법 같아요! 나중에 학생 한 명을 더 추가하고 싶으면, max_students 바로 윗줄에 이름만 적어주면 됩니다. 그러면 max_students 값도 자동으로 1 늘어나고, 배열 크기도 알아서 커지기 때문에 다른 코드를 손댈 필요가 전혀 없습니다.

#include <vector>
#include <iostream>

namespace Students
{
    enum Names
    {
        kenny, // 0
        kyle, // 1
        stan, // 2
        butters, // 3
        cartman, // 4
        wendy, // 5 (추가됨)
        // 앞으로 추가될 학생들은 여기에 넣으세요
        max_students // 이제 6이 됩니다
    };
}

int main()
{
    std::vector<int> testScores(Students::max_students); // 이제 6개의 요소를 할당합니다

    testScores[Students::stan] = 76; // 여전히 잘 작동합니다

    std::cout << "The class has " << Students::max_students << " students\n";

    return 0;
}

개수 세기용 열거자로 배열 길이 꼼꼼하게 확인하기 (Asserting)

보통은 처음부터 초기값을 쫙 나열해서 배열을 만드는 경우가 많아요. 이때 우리가 만든 '학생 수(개수 세기용 열거자)'와 '실제 배열에 들어간 점수의 개수'가 똑같은지 확인해 주는 것이 좋습니다. 만약 학생 이름은 새로 적어놓고 점수 적는 걸 깜빡했다면 여기서 딱 걸리게 되거든요!

#include <cassert>
#include <iostream>
#include <vector>

enum StudentNames
{
    kenny, // 0
    kyle, // 1
    stan, // 2
    butters, // 3
    cartman, // 4
    max_students // 5
};

int main()
{
    std::vector testScores { 78, 94, 66, 77, 14 };

    // 시험 점수의 개수가 학생 수와 동일한지 확인합니다
    assert(std::size(testScores) == max_students);

    return 0;
}

팁 만약 일반 배열이 아니라 상수(constexpr) 배열을 쓰고 있다면 static_assert를 써야 합니다. std::vector는 상수를 지원하지 않지만, std::array나 C 스타일 배열은 지원하거든요.

모범 사례 상수로 만든(constexpr) 배열의 길이를 확인할 때는 static_assert 를 사용하세요. 일반 배열의 길이를 확인할 때는 assert 를 사용하세요.

배열과 enum class (스코프가 있는 안전한 열거형)

일반 enum은 이름들이 코드 이곳저곳에 섞여서 충돌할 위험이 있습니다. 그래서 C++에서는 좀 더 안전한 enum class를 쓰는 걸 추천하죠.

하지만 깐깐한 enum class는 자동으로 숫자로 변환되지 않기 때문에, 배열 인덱스로 바로 쓰려고 하면 에러를 뿜어냅니다.

#include <iostream>
#include <vector>

enum class StudentNames // 이제 enum class입니다
{
    kenny, // 0
    kyle, // 1
    stan, // 2
    butters, // 3
    cartman, // 4
    max_students // 5
};

int main()
{
    // 컴파일 에러: StudentNames에서 std::size_t로 변환할 수 없습니다.
    std::vector<int> testScores(StudentNames::max_students);

    // 컴파일 에러: StudentNames에서 std::size_t로 변환할 수 없습니다.
    testScores[StudentNames::stan] = 76;

    // 컴파일 에러: StudentNames에서 operator<<가 출력할 수 있는 타입으로 변환할 수 없습니다.
    std::cout << "The class has " << StudentNames::max_students << " students\n";

    return 0;
}

이걸 해결하는 가장 단순한 방법은 static_cast를 써서 강제로 숫자로 바꿔주는 건데... 코드가 너무 길어지고 못생겨집니다.

#include <iostream>
#include <vector>

enum class StudentNames
{
    kenny, // 0
    kyle, // 1
    stan, // 2
    butters, // 3
    cartman, // 4
    max_students // 5
};

int main()
{
    std::vector<int> testScores(static_cast<int>(StudentNames::max_students));

    testScores[static_cast<int>(StudentNames::stan)] = 76;

    std::cout << "The class has " << static_cast<int>(StudentNames::max_students) << " students\n";

    return 0;
}

타자 치기 너무 귀찮죠? 더 좋은 방법은 단항 + 기호에 "이 기호를 붙이면 열거형을 숫자로 바꿔줘!"라는 특별한 기능을 심어두는(오버로딩) 겁니다.

#include <iostream>
#include <type_traits> // std::underlying_type_t를 사용하기 위해 필요
#include <vector>

enum class StudentNames
{
    kenny, // 0
    kyle, // 1
    stan, // 2
    butters, // 3
    cartman, // 4
    max_students // 5
};

// 단항 + 연산자를 오버로딩하여 StudentNames를 기본 바탕 타입으로 변환합니다
constexpr auto operator+(StudentNames a) noexcept
{
    return static_cast<std::underlying_type_t<StudentNames>>(a);
}

int main()
{
    std::vector<int> testScores(+StudentNames::max_students);

    testScores[+StudentNames::stan] = 76;

    std::cout << "The class has " << +StudentNames::max_students << " students\n";

    return 0;
}

이렇게 하면 enum class 이름 앞에 +만 톡 붙여주면 되니까 훨씬 깔끔하죠! 하지만, 배열에 접근할 일이 너~무 많다면 매번 +를 붙이는 것도 일이 될 수 있으니, 그냥 안전한 공간(namespace나 class) 안에 일반 enum을 넣어서 쓰는 것도 좋은 선택이랍니다.

16.10 — std::vector 크기 조절과 용량

이번 장의 이전 레슨들에서는 컨테이너와 배열, 그리고 std::vector 에 대해 배웠어요. 배열 안의 데이터에 어떻게 접근하는지, 배열의 길이는 어떻게 아는지, 그리고 배열을 어떻게 쭉 훑어보는지(순회하는지)도 이야기했었죠. 예시로는 std::vector 를 사용했지만, 우리가 배운 개념들은 보통 모든 종류의 배열에 다 똑같이 써먹을 수 있는 것들이었어요.

이제 남은 레슨들에서는 std::vector 가 다른 대부분의 배열들과 확연히 다르게 만들어주는 '단 하나의 엄청난 특징' 에 집중해 볼 거예요. 바로 '처음 만들어진 이후에도 스스로 크기를 늘리거나 줄일 수 있는 능력' 이랍니다!

크기가 고정된 배열 vs 크기를 바꿀 수 있는 동적 배열

대부분의 배열은 아주 큰 단점이 하나 있어요. 처음 만들 때 배열의 길이를 미리 딱 정해야 하고, 한 번 정해지면 절대 바꿀 수 없다는 거죠. 이런 배열들을 '고정 크기 배열' 이라고 부릅니다. std::array 와 C언어 스타일의 배열이 바로 이 고정 크기 배열에 속해요. 이건 다음 장에서 더 자세히 다룰게요.

반면에 std::vector 는 '동적 배열(Dynamic array)' 이에요. 필요할 때마다 크기를 자유자재로 바꿀 수 있는 배열이죠. 이 유연함이 바로 std::vector 를 아주 특별하게 만들어줍니다.

프로그램 실행 중에 std::vector 크기 바꾸기

std::vector 는 만들어진 후에도 resize() 라는 기능(멤버 함수)을 써서 원하는 새로운 길이로 크기를 바꿀 수 있어요. 코드로 볼까요?

#include <iostream>
#include <vector>

int main(){
    std::vector v{ 0, 1, 2 }; // 3개의 요소를 가진 벡터 만들기
    std::cout << "The length is: " << v.size() << '\n';

    v.resize(5);              // 5개의 요소로 크기 늘리기
    std::cout << "The length is: " << v.size() << '\n';

    for (auto i : v)
        std::cout << i << ' ';

    std::cout << '\n';

    return 0;
}

이 코드를 실행하면 이렇게 출력돼요:

The length is: 3 The length is: 5 0 1 2 0 0

여기서 주목해야 할 아주 중요한 사실 두 가지가 있어요! 첫째, 크기를 늘렸을 때 원래 들어있던 데이터(0, 1, 2)는 지워지지 않고 그대로 유지 되었습니다! 둘째, 새로 생겨난 빈칸들은 기본값으로 알아서 채워집니다. 숫자의 경우 0 으로 채워지기 때문에, 새로 생긴 두 칸이 모두 0 이 된 것을 볼 수 있어요.

물론, 반대로 크기를 더 작게 줄일 수도 있습니다:

#include <iostream>
#include <vector>

void printLength(const std::vector<int>& v){
    std::cout << "The length is: "    << v.size() << '\n';
}

int main(){
    std::vector v{ 0, 1, 2, 3, 4 }; // 처음 길이는 5
    printLength(v);

    v.resize(3);                    // 3개의 요소로 크기 줄이기
    printLength(v);

    for (int i : v)
        std::cout << i << ' ';

    std::cout << '\n';

    return 0;
}

출력 결과:

The length is: 5 The length is: 3 0 1 2

std::vector 의 길이(Length) vs 용량(Capacity)

12채의 집이 일렬로 늘어서 있다고 상상해 보세요. 우리는 집의 개수(길이)가 12채라고 말할 겁니다. 그런데 그 집들에 실제로 사람들이 살고 있는지 알고 싶다면... 직접 초인종을 누르며 돌아다녀 봐야 알 수 있겠죠. 즉, '길이' 만 알 때는 그저 '몇 개가 존재하는지'만 알 수 있습니다.

이번엔 계란판을 생각해 볼까요? 지금 계란 5개가 들어있습니다. 여기서 계란의 개수(길이)는 5개입니다. 하지만 여기서 우리가 신경 써야 할 개념이 하나 더 있어요. "이 계란판이 꽉 찬다면 최대 몇 개까지 담을 수 있을까?" 하는 거죠. 이 계란판의 '용량(Capacity)' 은 12입니다. 총 12개를 담을 수 있는 공간이 있는데 현재 5개만 쓰고 있는 거죠. 따라서 우리는 7개의 계란을 더 사 와도 넘치지 않게 담을 수 있습니다. 길이와 용량 두 가지를 모두 알면, '현재 몇 개가 있는지'와 '앞으로 몇 개를 더 넣을 공간이 있는지'를 구분할 수 있게 됩니다.

지금까지 우리는 std::vector 의 '길이' 에 대해서만 이야기했어요. 하지만 std::vector 에는 '용량' 이라는 것도 있습니다. 쉽게 말해, 용량 은 '벡터가 데이터를 담기 위해 미리 준비해 둔 메모리 빈 공간의 크기'이고, 길이 는 '그 공간 안에서 실제로 사용 중인 데이터의 개수'입니다.

용량이 5인 std::vector 는 요소 5개를 담을 공간을 미리 확보해 둔 상태예요. 만약 여기에 2개의 데이터만 들어있다면, 이 벡터의 길이(사이즈)는 2입니다. 나머지 3칸은 미리 자리를 잡아두긴 했지만 아직 쓰고 있지 않은 '예비 공간'인 셈이죠. 나중에 데이터가 더 들어오면 넘치지 않게 바로 쓸 수 있습니다.

핵심 포인트

• 벡터의 길이(Length) : 현재 "사용 중인" 데이터가 몇 개인가?
• 벡터의 용량(Capacity) : 현재 메모리에 "확보해 둔 빈 공간"이 총 몇 개인가?

std::vector 의 용량 확인하기

capacity() 라는 함수를 쓰면 현재 벡터의 용량이 얼마인지 물어볼 수 있어요.

#include <iostream>
#include <vector>

void printCapLen(const std::vector<int>& v){
    std::cout << "Capacity: " << v.capacity() << " Length:"    << v.size() << '\n';
}

int main(){
    std::vector v{ 0, 1, 2 }; // 처음 길이는 3

    printCapLen(v);

    for (auto i : v)
        std::cout << i << ' ';
    std::cout << '\n';

    v.resize(5); // 5개의 요소로 크기 늘리기

    printCapLen(v);

    for (auto i : v)
        std::cout << i << ' ';
    std::cout << '\n';

    return 0;
}

이 코드를 실행하면 컴퓨터마다 조금 다를 수 있지만 대략 이렇게 나옵니다:

Capacity: 3 Length: 3 0 1 2 Capacity: 5 Length: 5 0 1 2 0 0

처음에 3개의 데이터로 벡터를 만들었죠? 이때 벡터는 딱 3개가 들어갈 공간만 준비(용량 3)하고 3개를 모두 사용(길이 3)합니다. 그다음 resize(5) 를 불러서 길이를 5로 늘려달라고 주문했어요. 벡터는 현재 빈 공간이 3칸밖에 없는데 5칸이 필요해졌으니, 추가 데이터를 담기 위해 더 큰 새로운 공간을 구해야만 했습니다. 결과적으로 벡터는 5개를 담을 공간(용량 5)을 마련했고, 5개 모두 사용 중(길이 5)인 상태가 되었습니다.

평소에 코딩할 때는 capacity() 함수를 직접 쓸 일이 많지는 않겠지만, 벡터의 내부 공간이 어떻게 변하는지 눈으로 확인하기 위해 이번 레슨에서는 자주 써볼 거예요.

메모리 재할당, 그게 왜 부담스러울까요?

std::vector 가 관리하는 메모리 공간의 크기를 바꾸는 과정을 '재할당' 이라고 부릅니다. 이 과정은 마치 '새 집으로 이사하는 것'과 비슷해요.

1. 벡터가 원하는 만큼의 데이터가 들어갈 수 있는 더 큰 새 집(새 메모리 공간)을 구합니다.
2. 원래 집에 있던 짐(데이터)들을 전부 하나하나 새 집으로 옮깁니다(복사 또는 이동). 그리고 원래 살던 헌 집은 시스템에 반납합니다.
3. 이제 벡터의 용량과 길이를 새 집에 맞춰 업데이트합니다.

겉보기에는 그냥 벡터가 쭉 늘어난 것처럼 보이지만, 컴퓨터 내부에서는 완전히 새로운 공간으로 싹 다 이사 를 한 거랍니다! 이사를 할 때 모든 짐을 다 싸서 옮겨야 하니 아주 힘들고 시간이 오래 걸리겠죠? 컴퓨터도 마찬가지라서, 메모리를 재할당하는 건 컴퓨터의 힘을 많이 쓰는(비용이 큰) 작업이에요. 그래서 가급적 이사를 너무 자주 하지 않도록 피하는 것이 좋습니다.

핵심 포인트 재할당은 컴퓨터에게 꽤 부담스러운 작업입니다. 불필요한 재할당은 피하는 것이 좋습니다.

길이와 용량을 굳이 나누는 이유가 뭔가요?

std::vector 는 공간이 부족하면 알아서 이사(재할당)를 하긴 하지만, 웬만하면 이사하는 걸 무척 귀찮아합니다. (마치 "안 하는 게 낫겠습니다"라고 말하던 소설 주인공 바틀비처럼 말이죠!) 이사하는 데 에너지가 너무 많이 드니까요.

만약 벡터가 '용량'이라는 개념 없이 '길이'만 알고 있다면 어떻게 될까요? 크기를 1칸 늘리든 줄이든, 무언가 바뀔 때마다 매번 새집을 구해서 이사(재할당)를 해야 할 겁니다. 정말 끔찍하죠! 하지만 길이와 용량을 따로 관리하면, 벡터가 언제 진짜 이사가 필요한지 똑똑하게 판단할 수 있습니다.

아래 예시를 볼까요.

#include <iostream>
#include <vector>

void printCapLen(const std::vector<int>& v){
    std::cout << "Capacity: " << v.capacity() << " Length:"    << v.size() << '\n';
}

int main(){
    // 길이가 5인 벡터 만들기
    std::vector v{ 0, 1, 2, 3, 4 };
    v = { 0, 1, 2, 3, 4 }; // 좋아요, 배열의 길이는 5
    printCapLen(v);

    for (auto i : v)
        std::cout << i << ' ';
    std::cout << '\n';

    // 벡터의 크기를 3개의 요소로 줄이기
    v.resize(3); // 여기에 3개의 요소로 이루어진 리스트를 할당할 수도 있습니다
    printCapLen(v);

    for (auto i : v)
        std::cout << i << ' ';
    std::cout << '\n';

    // 다시 5개의 요소로 크기 늘리기
    v.resize(5);
    printCapLen(v);

    for (auto i : v)
        std::cout << i << ' ';
    std::cout << '\n';

    return 0;
}

결과는 이렇습니다:

Capacity: 5 Length: 5 0 1 2 3 4 Capacity: 5 Length: 3 0 1 2 Capacity: 5 Length: 5 0 1 2 0 0

처음 5개의 데이터를 넣었을 때 용량과 길이가 모두 5였습니다. 그다음 v.resize(3) 을 불러서 배열을 작게 줄여달라고 했죠. 길이는 3으로 줄었지만, 주목하세요! 용량은 여전히 5 입니다. 벡터가 집(메모리)을 버리고 이사(재할당)를 하지 않았다는 뜻이에요. 단순히 뒤쪽 빈방의 불만 꺼둔 셈이죠. 마지막으로 다시 v.resize(5) 를 불렀습니다. 벡터는 이미 용량이 5, 즉 빈방이 준비되어 있었기 때문에 이번에도 귀찮은 이사를 할 필요가 없었습니다. 그냥 꺼뒀던 불을 켜고 길이만 5로 되돌린 다음, 뒤쪽 두 칸을 기본값(0)으로 채워주기만 하면 끝이었죠.

길이와 용량을 따로 나눈 덕분에 우리는 불필요한 이사(재할당)를 2번이나 아낄 수 있었습니다. 나중에 데이터를 하나씩 하나씩 계속 추가해야 할 일이 생길 텐데, 그때마다 매번 이사하지 않아도 된다는 건 정말 엄청난 장점이에요.

핵심 포인트 용량을 길이와 분리해서 기억해 두면, 크기가 변할 때마다 매번 무리해서 재할당하는 것을 막을 수 있습니다.

벡터에서 몇 번째 데이터를 꺼낼지(인덱싱)는 용량이 아니라 '길이' 기준입니다

여기서 초보자들이 흔히 하는 실수가 있어요! [] 기호나 at() 함수를 써서 벡터 안의 n번째 방에 들어갈 때, 쓸 수 있는 방 번호는 용량이 아니라 '길이' 까지만 허용됩니다.

위의 예시처럼 용량이 5이고 길이가 3인 상황을 생각해 보세요. 0번, 1번, 2번 방까지만 정상적으로 들어갈 수 있습니다. 용량이 5라고 해서 아직 사용하지도 않는 3번, 4번 방에 들어가려고 하면, 범위를 벗어났다는 에러(Out of bounds)가 나게 됩니다.

경고 데이터에 접근할 때 쓰는 방 번호(인덱스)는 반드시 0부터 벡터의 '길이' (용량 아님!) 사이여야 합니다!

std::vector 의 불필요한 용량 줄이기

벡터의 크기를 늘리면 필요에 따라 용량도 같이 늘어난다고 했죠. 하지만 반대로 길이를 줄인다고 해서 확보해 둔 용량이 알아서 줄어들지는 않습니다.

데이터 몇 개 안 쓸 거 같아서 빈방을 굳이 줄이겠다고 힘들게 재할당(이사)을 하는 건 사실 별로 좋은 선택이 아니에요. 하지만 만약 요소가 100,000개 들어있던 초대형 벡터에서 99,990개를 지워버리고 10개만 남겼다면? 안 쓰는 빈방이 99,990개나 되니 메모리 낭비가 너무 심하겠죠!

이럴 때 메모리 낭비를 해결하기 위해 std::vector 에는 shrink_to_fit() (내 몸에 딱 맞게 줄여줘!) 이라는 기능이 있습니다. "현재 사용 중인 길이에 맞춰서 안 쓰는 빈 용량은 좀 버려줘"라고 부탁하는 기능이에요. 다만 이건 말 그대로 '부탁'일 뿐 강제성은 없어서, 컴퓨터(컴파일러)가 상황을 보고 굳이 안 해도 되겠다 싶으면 무시할 수도 있습니다. 하지만 보통은 부탁을 잘 들어줍니다.

예시를 볼까요:

#include <iostream>
#include <vector>

void printCapLen(const std::vector<int>& v){
    std::cout << "Capacity: " << v.capacity() << " Length:"    << v.size() << '\n';
}

int main(){

    std::vector<int> v(1000); // 1000개의 요소가 들어갈 공간 할당하기
    printCapLen(v);

    v.resize(0); // 0개의 요소로 크기 줄이기
    printCapLen(v);

    v.shrink_to_fit();
    printCapLen(v);

    return 0;
}

결과는 이렇게 나옵니다:

Capacity: 1000 Length: 1000 Capacity: 1000 Length: 0 Capacity: 0 Length: 0

보시다시피, 길이를 0으로 줄였을 때는 용량이 그대로 1000이었지만, shrink_to_fit() 을 부르자 벡터가 불필요한 용량을 0으로 싹 줄여서 1000개짜리 빈 공간을 시스템에 예쁘게 돌려준 것을 확인할 수 있습니다!

16.11 — std::vector 와 스택(stack)의 동작 방식

여러분이 사용자가 여러 개의 값(예: 시험 점수들)을 입력하는 프로그램을 만든다고 상상해 보세요. 이때 사용자가 몇 개의 점수를 입력할지는 프로그램을 실행하기 전(컴파일 타임)에는 알 수 없고, 실행할 때마다 달라질 수 있습니다. 우리는 이 값들을 화면에 보여주거나 처리하기 위해 std::vector 에 저장할 거예요.

지금까지 배운 내용을 바탕으로 몇 가지 방법을 생각해 볼 수 있어요.

1. 첫 번째, 사용자에게 "몇 개의 점수를 입력할 건가요?"라고 물어보고, 그 개수만큼 벡터를 만든 다음 점수를 입력받는 거예요. 나쁜 방법은 아니지만, 사용자가 미리 정확한 개수를 알아야 하고 실수로 개수를 잘못 세면 안 된다는 단점이 있어요. 10개나 20개가 넘는 항목을 일일이 세는 건 정말 귀찮은 일이죠. 게다가 컴퓨터가 대신 개수를 세어줄 수 있는데, 굳이 사용자에게 세라고 할 필요가 있을까요?
2. 두 번째, 사용자가 아무리 많아도 특정 개수(예: 30개) 이상은 입력하지 않을 거라고 가정하고, 그만큼 큰 벡터를 미리 만드는 거예요. 그리고 다 입력할 때까지(혹은 30개에 도달할 때까지) 계속 입력받는 거죠. 다 입력하고 나면, 실제로 입력한 개수만큼 벡터의 크기를 줄이면 됩니다.

하지만 이 두 번째 방법의 단점은 사용자가 딱 30개까지만 입력할 수 있다는 거예요. 만약 30개보다 더 많이 입력하고 싶다면? 안타깝게도 방법이 없죠.

이 문제를 해결하기 위해 30개가 꽉 차면 벡터의 크기를 더 크게 늘리는 코드를 추가할 수도 있어요. 하지만 이렇게 되면 프로그램의 원래 목적(점수 처리)과 배열 크기 관리 코드가 섞이게 되어서, 프로그램이 훨씬 복잡해지고 버그가 생기기 쉬워집니다.

진짜 문제는 우리가 '사용자가 몇 개를 입력할지' 미리 짐작하려고 한다는 데 있어요. 입력할 개수를 미리 알 수 없는 상황에서는 훨씬 더 좋은 방법이 있답니다!

하지만 그 방법을 알아보기 전에, 잠깐 다른 이야기를 먼저 해볼게요.

스택(Stack)이란 무엇일까요?

비유를 하나 들어볼게요! 식당에 쌓여 있는 접시 무더기를 생각해 보세요. 왠지 모르겠지만 이 접시들은 엄청 무거워서 한 번에 딱 하나씩만 들 수 있다고 가정해 봅시다. 접시가 무겁고 쌓여 있기 때문에, 이 접시 더미를 다루는 방법은 딱 두 가지뿐이에요.

1. 맨 위에 새 접시를 올려놓는다 (기존 접시는 아래에 깔리게 됨)
2. 맨 위에 있는 접시를 빼낸다 (아래에 있던 접시가 드러남)

중간이나 맨 밑에서 접시를 빼거나 넣는 건 절대 안 돼요. 그러려면 한 번에 여러 개의 접시를 들어야 하니까요.

이렇게 스택(접시 더미)에 물건을 넣고 빼는 순서를 후입선출 (LIFO: Last-In, First-Out) 이라고 불러요. 즉, 가장 마지막에 들어간 접시가 가장 먼저 나오게 되는 구조랍니다.

프로그래밍에서의 스택

프로그래밍에서 스택(Stack) 은 이 LIFO(후입선출) 방식으로 데이터를 넣고 빼는 보관함(컨테이너)을 말해요. 주로 push(푸시) 와 pop(팝) 이라는 두 가지 핵심 동작으로 작동합니다.

그 외에도 스택에서 유용하게 쓰이는 동작들이 더 있어요.

스택은 프로그래밍에서 정말 흔하게 쓰여요. 이전에 '호출 스택(call stack)'에 대해 배운 적이 있죠? 어떤 함수들이 호출되었는지 기록해 두는 곳인데, 이름 그대로 이것도 스택이랍니다! (네, 비밀을 밝힌 것치곤 좀 싱겁죠 ㅎㅎ). 함수가 실행되면 그 함수에 대한 정보가 스택의 맨 위에 추가(Push)되고, 함수가 끝나면 맨 위에서 제거(Pop)돼요. 그래서 호출 스택의 맨 위는 항상 '지금 당장 실행 중인 함수'를 나타냅니다.

Push와 Pop이 어떻게 작동하는지 순서대로 볼까요?

(스택: 비어있음) Push 1 (스택: 1) Push 2 (스택: 1 2) Push 3 (스택: 1 2 3) Pop (스택: 1 2) Push 4 (스택: 1 2 4) Pop (스택: 1 2) Pop (스택: 1) Pop (스택: 비어있음)

C++ 에서의 스택

어떤 프로그래밍 언어들은 스택을 완전히 별개의 전용 보관함으로 만들어 둬요. 하지만 이러면 좀 불편할 때가 있어요. 예를 들어, 스택을 건드리지 않고 안에 있는 값들만 쭉 화면에 출력하고 싶을 때, 순수하게 스택 기능만 있으면 그렇게 하기가 어렵거든요.

그래서 C++ 에서는 스택처럼 쓸 수 있는 기능(멤버 함수)들을 이미 있는 보관함들( std::vector , std::deque , std::list 등)에 추가해 두었어요. 이 보관함들은 원래 끝부분에서 데이터를 빠르게 넣고 빼는 데 특화되어 있거든요. 덕분에 원래의 편리한 기능들을 그대로 쓰면서 스택처럼 활용할 수도 있답니다.

잠깐 참고로...

아까 들었던 접시 더미 비유도 좋지만, 배열(array)을 이용해 스택을 어떻게 만드는지 이해하기 위해 더 찰떡인 비유를 하나 들어볼게요.

위로 쭉 쌓아 올린 우편함들을 상상해 보세요. 각 우편함에는 편지를 딱 하나씩만 넣을 수 있고, 처음엔 다 비어있어요. 이 우편함들은 서로 단단히 못 박혀 있고, 맨 위쪽 우편함에는 독이 묻은 가시가 돋아 있어서 새로운 우편함을 중간이나 맨 위에 더 끼워 넣을 수는 없다고 쳐볼게요. (우편함의 전체 개수를 늘릴 수 없다는 뜻이에요!)

우편함 개수를 늘릴 수 없는데 어떻게 스택처럼 쓸 수 있을까요?

1. 먼저, 포스트잇 같은 마커(표시)를 사용해서 '여기가 스택의 맨 위야!'라고 표시해 둡니다. 이 표시는 항상 '비어있는 우편함 중 가장 밑에 있는 곳'을 가리켜요. 처음엔 다 비어있으니까 맨 아래 우편함에 표시를 붙이겠죠.
2. 이제 데이터를 넣을 때(Push)는, 표시가 붙어있는 우편함에 데이터를 넣고 표시는 한 칸 위로 올려 붙여요.
3. 반대로 데이터를 뺄 때(Pop)는, 표시를 한 칸 아래로 내린 다음, 그 우편함에 있던 데이터를 꺼내서 우편함을 다시 비워줍니다.

즉, 표시보다 아래에 있는 것들은 '스택에 들어있는 데이터'이고, 표시와 그 위에 있는 우편함들은 '비어있는 공간'인 셈이죠.

자, 이제 여기서 '표시'를 length (데이터 개수, 길이)라고 부르고, 전체 '우편함의 개수'를 capacity (용량)라고 불러봅시다!

이번 레슨의 나머지 부분에서는 std::vector 의 스택 기능이 어떻게 작동하는지 알아보고, 마지막으로 처음에 말했던 '점수 입력받기' 문제를 이 방법으로 어떻게 멋지게 해결하는지 보여드릴게요.

std::vector 의 스택 동작

std::vector 에서 스택 기능은 다음 함수들을 통해 사용할 수 있어요.

그럼 이 함수들을 사용하는 예제 코드를 살펴볼까요?

#include <iostream>
#include <vector>

void printStack(const std::vector<int>& stack)
{
    if (stack.empty()) // stack.size == 0 이라면
        std::cout << "비어있음";

    for (auto element : stack)
        std::cout << element << ' ';

    // \t 는 텍스트 줄을 맞추기 위한 탭(tab) 문자입니다
    std::cout << "\t용량(Capacity): " << stack.capacity() << "  길이(Length) " << stack.size() << "\n";
}

int main()
{
    std::vector<int> stack{}; // 빈 스택 만들기

    printStack(stack);

    stack.push_back(1); // push_back() 은 스택에 요소를 밀어 넣습니다(Push)
    printStack(stack);

    stack.push_back(2);
    printStack(stack);

    stack.push_back(3);
    printStack(stack);

    std::cout << "맨 위(Top): " << stack.back() << '\n'; // back() 은 마지막 요소를 반환합니다

    stack.pop_back(); // pop_back() 은 스택에서 요소를 빼냅니다(Pop)
    printStack(stack);

    stack.pop_back();
    printStack(stack);

    stack.pop_back();
    printStack(stack);

    return 0;
}

(GCC나 Clang 컴파일러에서는 이렇게 출력돼요)

비어있음 용량(Capacity): 0 길이(Length): 0 1 용량(Capacity): 1 길이(Length): 1 1 2 용량(Capacity): 2 길이(Length): 2 1 2 3 용량(Capacity): 4 길이(Length): 3 맨 위(Top):3 1 2 용량(Capacity): 4 길이(Length): 2 1 용량(Capacity): 4 길이(Length): 1 비어있음 용량(Capacity): 4 길이(Length): 0

기억나시나요? 여기서 길이(length)는 벡터 안에 있는 데이터의 개수, 즉 우리 스택에 쌓인 데이터의 개수를 의미해요.

대괄호 operator[] 나 at() 함수를 쓸 때와 다르게, push_back() 이나 emplace_back() 을 사용하면 벡터의 길이(length)가 자동으로 늘어나요. 만약 데이터를 넣을 공간(capacity, 용량)이 부족하면, 공간을 더 넓히는 재할당(reallocation) 작업이 자동으로 일어납니다.

위 예제에서도 공간이 3번이나 재할당되었죠 (용량이 0에서 1로, 1에서 2로, 2에서 4로 늘어났어요).

핵심 포인트 push_back() 과 emplace_back() 은 std::vector 의 길이를 늘려줍니다. 그리고 남은 용량이 부족하면 알아서 더 큰 공간으로 이사(재할당)를 갑니다.

Push할 때 넉넉하게 생기는 추가 용량

위의 출력 결과를 보면, 마지막으로 공간이 늘어날 때 요소를 1개만 더 넣었는데도 용량이 2에서 4로 껑충 뛰었죠? push_back으로 인해 공간이 늘어나야 할 때, std::vector 는 보통 앞으로 데이터가 더 들어올 것을 대비해서 공간을 좀 더 여유 있게 잡아둡니다. 그래야 다음에 데이터가 들어올 때 또 이사(재할당)를 가는 번거로움을 줄일 수 있거든요.

얼마나 여유 있게 잡을지는 여러분이 쓰는 컴파일러마다 조금씩 달라요.

• GCC와 Clang 은 현재 용량을 2배로 늘려요. (2에서 4로 늘어났죠!)
• Visual Studio 2022 는 현재 용량의 1.5배로 늘려요. (2에서 3으로 늘어납니다.)

그래서 어떤 컴파일러를 쓰느냐에 따라 출력 결과의 용량 부분이 조금 다르게 보일 수 있습니다.

스택처럼 쓸 때는 크기 조정(Resize)을 조심하세요

벡터 공간을 다시 할당(재할당)하는 건 컴퓨터 입장에서 꽤 힘든 일(계산 비용이 높음)이에요. 그래서 가능하면 재할당이 안 일어나게 하는 게 좋겠죠? 방금 본 예제에서 처음부터 용량을 딱 3으로 맞춰놓고 시작했다면 3번이나 이사를 가는 일을 피할 수 있었을 거예요.

그럼 첫 번째 예제의 시작 부분을 이렇게 고쳐보면 어떨까요?

std::vector<int> stack(3); // 괄호를 써서 초기화하면 벡터의 용량을 3으로 설정합니다

이렇게 고치고 다시 실행하면 이런 결과가 나옵니다.

0 0 0 용량(Capacity): 3 길이(Length): 3 0 0 0 1 용량(Capacity): 6 길이(Length): 4 0 0 0 1 2 용량(Capacity): 6 길이(Length): 5 0 0 0 1 2 3 용량(Capacity): 6 길이(Length): 6 맨 위(Top): 3 0 0 0 1 2 용량(Capacity): 6 길이(Length): 5 0 0 0 1 용량(Capacity): 6 길이(Length): 4 0 0 0 용량(Capacity): 6 길이(Length): 3

앗, 뭔가 이상하죠? 스택 맨 밑에 0이 세 개나 깔려버렸어요! 이유는 이렇습니다. 괄호로 초기화해서 벡터 크기를 정해주거나 resize() 함수를 사용하면, 용량(Capacity)뿐만 아니라 길이(Length)까지 함께 3으로 설정되어 버려요. 즉, 우리가 원했던 대로 빈 상자 3개가 준비된 게 아니라, 이미 0이라는 값이 들어있는 꽉 찬 상자 3개가 생겨버린 거죠. 그래서 우리가 push_back으로 넣은 값들은 그 0들 위에 차곡차곡 쌓이게 된 거예요.

resize() 함수를 써서 길이를 미리 늘려두는 건, 대괄호([ ])를 써서 특정 위치의 값을 콕 집어서 바꿀 때는 아주 좋아요. 하지만 스택처럼 맨 위에 계속 쌓아 올리려고 할 때는 이렇게 골칫거리가 됩니다.

우리가 진짜 원하는 건, 길이(Length)는 0으로 놔둔 채로 용량(Capacity, 여유 공간)만 늘려두는 기능이에요. 그래야 쓸데없이 0이 추가되지 않으면서 나중에 재할당되는 것도 막을 수 있으니까요.

reserve() 함수로 용량만 늘리기

이럴 때 쓰는 게 바로 reserve() 라는 함수예요! 이 함수는 현재 길이(데이터 개수)는 건드리지 않고, std::vector 의 전체 용량만 넉넉하게 잡아줍니다.

아까와 똑같은 코드에 reserve() 만 추가해서 용량을 설정해 볼게요.

#include <iostream>
#include <vector>

void printStack(const std::vector<int>& stack)
{
    if (stack.empty()) // stack.size == 0 이라면
        std::cout << "비어있음";

    for (auto element : stack)
        std::cout << element << ' ';

    // \t 는 텍스트 줄을 맞추기 위한 탭(tab) 문자입니다
    std::cout << "\t용량(Capacity): " << stack.capacity() << "  길이(Length) " << stack.size() << "\n";
}

int main()
{
    std::vector<int> stack{};

    printStack(stack);

    stack.reserve(6); // 6개의 요소가 들어갈 공간을 미리 확보합니다 (하지만 길이는 바꾸지 않아요)
    printStack(stack);

    stack.push_back(1);
    printStack(stack);

    stack.push_back(2);
    printStack(stack);

    stack.push_back(3);
    printStack(stack);

    std::cout << "맨 위(Top): " << stack.back() << '\n';

    stack.pop_back();
    printStack(stack);

    stack.pop_back();
    printStack(stack);

    stack.pop_back();
    printStack(stack);

    return 0;
}

실행 결과는 다음과 같습니다.

비어있음 용량(Capacity): 0 길이(Length): 0 비어있음 용량(Capacity): 6 길이(Length): 0 1 용량(Capacity): 6 길이(Length): 1 1 2 용량(Capacity): 6 길이(Length): 2 1 2 3 용량(Capacity): 6 길이(Length): 3 맨 위(Top): 3 1 2 용량(Capacity): 6 길이(Length): 2 1 용량(Capacity): 6 길이(Length): 1 비어있음 용량(Capacity): 6 길이(Length): 0

보이시나요? reserve(6) 을 불렀더니 용량은 6으로 늘어났지만 길이는 0으로 그대로 유지되었어요. 이미 여유 공간이 6이나 있으니까, 데이터를 넣을 때 더 이상 번거로운 재할당(이사)이 일어나지 않게 되었죠!

핵심 포인트

• resize() 함수는 벡터의 길이를 바꿉니다 (필요하면 용량도 늘림).
• reserve() 함수는 벡터의 용량만 바꿉니다 (길이는 안 건드림).

꿀팁 std::vector 의 요소를 늘리고 싶을 때:

• [ ] 를 써서 특정 위치(인덱스)에 접근할 계획이라면 resize() 를 쓰세요. 길이를 늘려줘야 오류가 안 나요.
• 스택처럼 push_back() 으로 맨 끝에 밀어 넣을 계획이라면 reserve() 를 쓰세요. 길이 변경 없이 여유 공간만 확보해 줍니다.

push_back() vs emplace_back()

push_back() 과 emplace_back() 둘 다 스택에 데이터를 넣는 역할을 해요. 이미 만들어져 있는 변수(객체)를 넣을 때는 둘이 똑같이 작동하니까, 좀 더 익숙한 push_back() 을 쓰는 게 좋습니다.

하지만, 스택에 넣기 위해서 일회용으로 쓰일 데이터(임시 객체)를 그 자리에서 바로 만들어서 넣을 때는 emplace_back() 이 훨씬 더 빠르고 효율적이에요.

#include <iostream>
#include <string>
#include <string_view>
#include <vector>

class Foo
{
private:
    std::string m_a{};
    int m_b{};
public:
    Foo(std::string_view a, int b)
        : m_a { a }, m_b { b }
        {}

    explicit Foo(int b)
        : m_a {}, m_b { b }
        {};
};

int main()
{
    std::vector<Foo> stack{};

    // 이미 만들어진 객체가 있을 때는, push_back 과 emplace_back 의 효율이 비슷합니다
    Foo f{ "a", 2 };
    stack.push_back(f);    // 이 방법을 더 권장합니다
    stack.emplace_back(f);

    // 밀어 넣기 위해 임시 객체를 새로 만들어야 할 때는, emplace_back 이 더 효율적입니다
    stack.push_back({ "a", 2 }); // 임시 객체를 먼저 만든 다음, 벡터 안으로 복사해 넣습니다
    stack.emplace_back("a", 2);  // 값만 전달해서 벡터 안에서 객체를 직접 만들어 버립니다 (복사할 필요 없음)

    // push_back 은 '명시적(explicit) 생성자'를 무시할 수 없지만, emplace_back 은 사용할 수 있습니다
    stack.push_back({ 2 }); // 컴파일 에러: Foo(int) 생성자는 explicit 으로 설정되어 있습니다
    stack.emplace_back(2);  // 이건 가능합니다 (ok)

    return 0;
}

위 코드에서 push_back({ "a", 2 }) 를 쓰면, 컴퓨터는 몰래 임시 Foo 객체를 하나 만들고, 그걸 다시 벡터 안으로 '복사'하는 과정을 거쳐요. 문자가 길어지거나 복잡한 데이터라면 이 '복사' 과정에서 시간이 꽤 걸릴 수 있어요.

반면에 emplace_back("a", 2) 를 쓰면, 굳이 임시 객체를 밖에서 만들 필요 없이 재료("a"와 2)만 쓱 넘겨줍니다. 그러면 벡터가 자기 집 안에서 그 재료를 가지고 직접 요리(객체 생성)를 해버리죠. 복사할 필요가 없으니 당연히 더 빠르겠죠! (이걸 완벽한 전달, perfect forwarding 이라고 불러요).

다만 주의할 점은, push_back() 은 좀 엄격해서 explicit 이라고 표시된 특별한 생성자는 알아서 쓰지 않지만, emplace_back() 은 그걸 가져다 써버릴 수 있어요. 그래서 자칫 의도치 않은 방식으로 값이 바뀌어 들어가는 실수를 할 수 있어서 약간 더 위험할 수 있습니다. (참고로 C++20 이전 버전에서는 emplace_back() 이 일부 초기화 방식을 지원하지 않았습니다.)

모범 사례 (Best Practice)

• 보관함에 넣기 위해 임시 객체를 새로 만들어야 하거나, explicit 생성자를 꼭 써야 할 때는 emplace_back() 을 사용하세요.
• 그 외 일반적인 경우에는 모두 push_back() 을 사용하는 것을 추천합니다.

스택 기능으로 처음 문제 해결하기

자, 이제 맨 처음에 이야기했던 '점수 입력받기' 문제를 어떻게 해결해야 할지 감이 오시죠? std::vector 에 데이터가 몇 개나 들어올지 미리 알 수 없다면, 스택 기능(push_back)을 써서 데이터를 차곡차곡 쌓아 넣는 게 정답입니다!

예제 코드를 볼까요?

#include <iostream>
#include <limits>
#include <vector>

int main()
{
    std::vector<int> scoreList{};

    while (true)
    {
        std::cout << "점수를 입력하세요 (끝내려면 -1 입력): ";
        int x{};
        std::cin >> x;

        if (!std::cin) // 잘못된 입력 처리 (예: 숫자가 아닌 문자 입력)
        {
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            continue; // 다시 입력받도록 루프 처음으로 돌아감
        }

        // 사용자가 다 입력했다면(-1), 반복문을 빠져나갑니다
        if (x == -1)
            break;

        // 사용자가 정상적인 점수를 입력했다면, 벡터에 밀어 넣습니다(push)
        scoreList.push_back(x);
    }

    std::cout << "입력하신 점수 목록: \n";

    for (const auto& score : scoreList)
        std::cout << score << ' ';

    return 0;
}

이 프로그램은 사용자에게 시험 점수를 계속 입력받아서 벡터에 차곡차곡 추가해요. 사용자가 점수 입력을 다 마치면(-1 입력), 벡터에 들어있는 모든 값을 쭉 보여줍니다.

놀랍지 않나요? 우리는 코드를 짜면서 점수가 몇 개인지 숫자를 세지도 않았고, 배열의 크기(길이)를 계산하거나 위치(인덱스)를 다룰 필요도 전혀 없었어요! 우리는 그저 '점수를 받아서 저장한다'는 핵심 논리에만 집중했고, 골치 아픈 저장 공간 관리는 전부 벡터가 알아서 처리해 주었답니다!

16.12 — std::vector<bool>

이전 O.1 레슨(비트 플래그와 std::bitset을 통한 비트 조작)에서, 우리는 std::bitset 이 8개의 불리언(Boolean, 참/거짓) 값을 단 하나의 바이트(1 byte) 안에 꽉꽉 압축해 넣는 방법에 대해 배웠습니다. 그리고 이 비트들은 std::bitset 의 기능을 통해 쉽게 수정할 수 있었죠.

그런데 std::vector 에도 아주 흥미로운 비밀 무기가 하나 숨겨져 있습니다. 바로 std::vector<bool> 이라는 특별한 버전인데요! 이것도 마찬가지로 8개의 참/거짓 값을 1바이트에 압축해서 메모리 공간을 훨씬 효율적으로 사용할 수 있게 해줍니다.

고급 학습자를 위한 참고 템플릿 클래스가 특정 타입(여기서는 bool )에 대해 아예 다른 방식으로 동작하도록 만들어진 것을 클래스 템플릿 특수화(Class template specialization) 라고 부릅니다. 이 내용은 나중에 26.4 레슨에서 더 자세히 다룰 예정입니다.

하지만 비트 조작을 위해 만들어진 전문 도구인 std::bitset 과는 다르게, std::vector<bool> 에는 비트를 직접 만지는 섬세한 기능(멤버 함수)들이 빠져있습니다.

std::vector<bool> 사용해 보기

대부분의 상황에서 std::vector<bool> 은(는) 평범한 벡터와 똑같이 작동합니다.

#include <iostream>
#include <vector>

int main()
{
    std::vector<bool> v { true, false, false, true, true };

    for (int i : v)
        std::cout << i << ' ';
    std::cout << '\n';

    // 인덱스 4의 불리언 값을 false로 변경합니다.
    v[4] = false;

    for (int i : v)
        std::cout << i << ' ';
    std::cout << '\n';

    return 0;
}

작성자의 64비트 컴퓨터에서 이 코드를 실행하면 다음과 같이 출력됩니다.

1 0 0 1 1
1 0 0 1 0

std::vector<bool> 의 치명적인 단점들 (주의사항)

공간을 아껴준다는 장점이 있지만, std::vector<bool> 을(를) 사용할 때는 반드시 알아둬야 할 중요한 단점들이 있습니다.

1. 기본 덩치가 큽니다 (High Overhead): 기본적으로 차지하는 메모리 크기가 꽤 큽니다 (작성자의 컴퓨터에서는 기본 크기가 무려 40바이트나 됩니다). 따라서 저장하려는 참/거짓 값의 개수가 아주 많지 않다면, 오히려 빈 공간(오버헤드) 때문에 메모리를 더 낭비하게 될 수 있습니다.
2. 들쭉날쭉한 성능: 성능이 어떤 환경(컴파일러 등)을 쓰느냐에 따라 크게 달라집니다. 어떤 환경에서는 엄청나게 빠르지만, 최적화가 엉망인 환경에서는 오히려 아주 느려질 수 있습니다.
3. 진짜 '벡터'가 아닙니다 (가장 중요!): 이름만 벡터일 뿐, C++에서 말하는 정식 '컨테이너'의 기준을 통과하지 못합니다! 메모리에 일렬로 예쁘게 늘어서 있지도 않고, 우리가 아는 진짜 bool 값을 저장하는 것도 아닙니다 (단순한 비트 조각들을 모아둔 것에 불과합니다).

이름은 벡터라서 평소에는 벡터처럼 행동하지만, C++의 다른 표준 기능들과 완벽하게 어울리지 못합니다. 즉, 다른 타입에서는 멀쩡하게 작동하던 코드가 std::vector<bool> 에서는 에러를 뿜어낼 수 있다는 뜻입니다.

예를 들어, 아래 코드는 T 가 bool 이 아닌 다른 모든 타입일 때는 잘 작동합니다.

template<typename T>
void foo( std::vector<T>& v )
{
    T& first = v[0]; // 첫 번째 요소에 대한 참조를 가져옵니다.
    // first를 사용하여 무언가를 수행합니다.
}

결론: std::vector<bool> 은 피하세요!

요즘 C++ 개발자들 사이의 공통된 의견은 "웬만하면 std::vector 은 쓰지 말자!" 입니다. 메모리를 조금 아껴서 얻는 이득보다, 이게 '진짜 컨테이너'가 아니기 때문에 생기는 골칫거리와 호환성 문제가 훨씬 크기 때문입니다.

안타깝게도 이 압축 버전의 std::vector<bool> 은(는) 기본적으로 켜져 있고, 이걸 끄고 진짜 bool 을 담는 평범한 벡터로 되돌릴 방법이 없습니다. 그래서 아예 C++ 표준에서 이 기능을 없애버리자는(deprecate) 목소리도 나오고 있으며, 나중에는 std::dynamic_bitset 같은 새로운 형태의 기능으로 교체하려는 작업이 진행 중입니다.

초보자를 위한 상황별 추천 가이드

그렇다면 대신 무엇을 써야 할까요? 다음과 같이 사용하는 것을 추천합니다.

• std::bitset 사용하기: 필요한 비트의 개수를 코드를 짤 때 이미 알고 있고, 저장할 데이터가 엄청나게 많지 않을 때 (예: 64k 이하) 아주 좋습니다.
• std::vector<char> 사용하기: 크기를 자유롭게 늘렸다 줄였다 해야 하는 참/거짓 목록이 필요하고, 메모리 공간을 한계까지 쥐어짜듯 아낄 필요가 없다면 이것을 강력히 추천합니다! 완벽하게 일반 벡터처럼 작동해서 에러 걱정이 없습니다.
• 외부 라이브러리 사용하기: 진짜 비트 조작이 가능한, 크기가 늘어나는 비트셋이 필요하다면 boost::dynamic_bitset 같은 믿을 만한 외부 도구를 쓰세요. 이런 도구들은 가짜 표준 컨테이너인 척하지 않아서 안전합니다.

가장 좋은 습관 (Best practice) std::vector<bool> 보다는 constexpr std::bitset 이나 std::vector<char> , 또는 외부 라이브러리의 동적 비트셋을 우선적으로 사용하세요!

16.x — 16장 요약

격려의 한마디 이번 장은 결코 쉽지 않았을 거예요! 우리는 정말 많은 내용을 다루었고, C++의 까다로운 부분들도 파헤쳐 보았습니다. 포기하지 않고 끝까지 오신 것을 축하드려요! 배열 은 여러분의 C++ 프로그램이 엄청난 능력을 발휘할 수 있게 해주는 핵심 열쇠랍니다.

컨테이너와 배열의 기초

• 컨테이너 (Container) 는 여러 개의 데이터(이를 요소 라고 불러요)를 담아두는 '보관함' 같은 데이터 타입입니다. 서로 관련 있는 값들을 한꺼번에 다루고 싶을 때 주로 사용하죠.
• 이 보관함 안에 들어있는 데이터의 개수를 길이 (Length) 또는 크기 (Size) 라고 부릅니다. C++를 포함한 대부분의 언어에서 컨테이너는 동종 (Homogenous) 인데, 이는 보관함 하나에는 한 가지 종류의 데이터(예: 정수면 정수만, 문자면 문자만)만 담을 수 있다는 뜻이에요.
• C++에는 여러 가지 유용한 보관함들을 미리 만들어둔 컨테이너 라이브러리 가 기본적으로 제공됩니다.
• 배열 (Array) 은 데이터들을 메모리상에 중간에 빈틈없이 연속적으로 (Contiguously) 나란히 붙여서 저장하는 보관함입니다. 데이터가 나란히 있기 때문에 어떤 위치에 있든 아주 빠르고 직접적으로 찾아갈 수 있어요.
• C++에는 세 가지 주요 배열이 있습니다: 기본 C 스타일 배열, std::vector, 그리고 std::array 입니다.
• 이 중 std::vector 는 C++에서 가장 많이 쓰이는 배열 보관함입니다. <vector> 라는 헤더 파일을 불러와서 사용하며, 꺾쇠 < > 안에 어떤 타입의 데이터를 담을지 적어줍니다. 예를 들어 std::vector<int> 는 '정수를 담는 벡터 보관함'을 만들겠다는 뜻이에요.
• 보관함을 처음 만들 때 중괄호 { }를 사용해서 안에 들어갈 값들을 바로 채워 넣을 수 있는데, 이를 리스트 생성자 를 사용한 초기화라고 합니다.

데이터 꺼내보기 (인덱스와 접근)

• 배열 안의 특정 값을 꺼낼 때는 배열 이름 옆에 대괄호 []를 쓰고, 그 안에 몇 번째 값을 꺼낼지 번호를 적습니다. 이 번호를 인덱스 (Index) 라고 해요.
• 주의할 점은 C++에서는 첫 번째 값이 1번이 아니라 0번부터 시작한다는 거예요! (이를 0 기반 (Zero-based) 시스템이라고 합니다). 즉, 첫 번째 값은 0번, 두 번째 값은 1번이 됩니다.
• 대괄호 []는 우리가 실수로 배열의 크기를 벗어난 엉뚱한 번호를 입력해도 경고해주지 않습니다. (이를 경계 검사 (Bounds checking) 를 하지 않는다고 해요). 범위를 벗어난 번호를 찾으려 하면 프로그램이 알 수 없는 오류를 일으킬 수 있으니 조심해야 합니다!
• 배열은 보관함 안에 몇 개의 데이터가 있든 상관없이 모든 데이터에 똑같이 빠른 속도로 접근할 수 있는데, 이를 임의 접근 (Random access) 이라고 부릅니다.

리스트 초기화 주의사항

std::vector v1 { 5 }; // 값 '5'가 들어있는 1개의 요소를 가진 벡터를 정의합니다.
std::vector v2 ( 5 ); // 기본값으로 초기화된 5개의 요소를 가진 벡터를 정의합니다.

• std::vector 는 내용을 바꿀 수 없는 상수(const)로 만들 수는 있지만, 컴파일 타임 상수(constexpr)로는 만들 수 없습니다.

크기 측정과 안전한 사용

• 컨테이너의 크기를 나타낼 때는 일반적인 정수형 대신 size_type 이라는 특수한 양수 전용 타입을 사용합니다. (주로 std::size_t라는 타입을 의미해요). 사용할 때는 std::vector<int>::size_type 처럼 전체 이름을 길게 적어줘야 합니다.
• 보관함에 데이터가 몇 개 들어있는지 알고 싶다면 size() 함수를 쓰면 됩니다. C++20부터는 std::ssize() 라는 함수도 추가되었는데, 이 함수는 크기를 일반적인 정수형(음수도 표현 가능한 타입)으로 알려줘서 수학 계산을 할 때 훨씬 편합니다.
• 대괄호 [] 대신 at() 이라는 함수를 사용해서 데이터를 꺼낼 수도 있습니다. 이 함수는 프로그램이 실행될 때 번호가 범위를 벗어나지 않았는지 안전하게 검사해 줍니다. 범위를 벗어나면 에러(예외)를 발생시키고 프로그램이 안전하게 멈추도록 도와주죠.

똑똑하게 데이터 전달하기 (복사와 이동)

• std::vector 도 함수에 전달할 수 있습니다. 하지만 그냥 전달하면 보관함 전체를 통째로 복사하게 되어 컴퓨터가 무척 힘들어합니다. 그래서 불필요한 복사를 막기 위해 보통 참조 (Reference) 라는 방식을 사용해서 원본의 '위치'만 알려주는 식으로 전달합니다.
• 복사 의미론 (Copy semantics) 은 데이터를 똑같이 하나 더 만들어내는 규칙을 말합니다.
• 반면, 데이터를 복사하는 대신 원래 있던 데이터를 새로운 곳으로 쓱 넘겨주는 것을 데이터가 이동 (Moved) 되었다고 합니다.
• 이동 의미론 (Move semantics) 은 이런 이동 규칙을 말해요. 무겁고 큰 데이터를 다룰 때, 일일이 복사하는 대신 소유권만 옮겨주면 프로그램이 훨씬 빠르고 효율적으로 동작합니다! std::vector 나 std::string 같은 타입은 함수에서 반환될 때 똑똑하게도 이 '이동' 방식을 사용합니다.

배열 안의 데이터 훑어보기 (순회)

• 보관함 안의 모든 데이터를 처음부터 끝까지 차례대로 살펴보는 것을 순회 (Traversal) 하거나 반복 (Iterating) 한다고 합니다.
• 보통 반복문(for 루프 등)을 써서 인덱스 번호를 하나씩 늘려가며 확인하는데, 이때 횟수를 한 번 더 돌거나 덜 도는 실수를 조심해야 합니다.
• 그래서 인덱스 번호 없이도 아주 쉽게 모든 데이터를 꺼내볼 수 있는 범위 기반 for 루프 (Range-based for loop) 를 사용하는 것이 훨씬 편하고 좋습니다! (초보자분들께 강력히 추천해요).
• 이 루프를 쓸 때는 타입 추론(auto) 기능을 활용하세요. 값을 바꿔야 하는 게 아니라면 항상 const auto& 를 사용하는 습관을 들이는 것이 좋습니다. 이렇게 하면 불필요한 데이터 복사를 막아줍니다.

동적 배열과 마법의 공간 조절

• 처음에 크기를 정하면 바꿀 수 없는 배열을 고정 크기 배열 (Fixed-size array) 이라고 합니다. 반면, 프로그램 실행 중에도 마음대로 크기를 늘렸다 줄였다 할 수 있는 배열을 동적 배열 (Dynamic array) 이라고 해요. std::vector 가 바로 이 동적 배열이라서 엄청난 인기를 누리는 것이죠! resize() 함수를 부르면 언제든 원하는 길이로 바꿀 수 있습니다.
• 여기서 아주 중요한 개념 두 가지가 있습니다:
• 용량 (Capacity) : 보관함이 꽉 차기 전까지 총 몇 개의 데이터를 담을 수 있는지 (미리 확보해 둔 빈 공간 포함).
• 길이 (Length) : 현재 보관함에 '실제로' 들어있는 데이터의 개수.

• 만약 빈 공간이 없는데 데이터를 더 넣으려고 하면? std::vector 는 스스로 더 큰 새 보관함을 구해와서 기존 데이터들을 모두 새 보관함으로 이사시킵니다. 이를 재할당 (Reallocation) 이라고 해요. 이사는 힘든 작업이니 가급적 적게 일어나는 게 좋겠죠?
• shrink_to_fit() 함수를 쓰면, 쓰지 않고 남은 빈 공간을 없애서 보관함 크기를 실제 내용물에 딱 맞게 줄여달라고 요청할 수 있습니다.

스택(Stack)처럼 사용하기

• 식당에 쌓여있는 접시 더미를 상상해 보세요. 가장 마지막에 올려놓은 접시를 가장 먼저 꺼내 쓰게 되죠? 이런 방식을 후입선출 (LIFO, Last-in, First-out) 이라고 합니다. 프로그래밍에서 이렇게 작동하는 보관함을 스택 (Stack) 이라고 부릅니다. 스택에 데이터를 넣는 것을 push , 빼는 것을 pop 이라고 해요.
• std::vector 는 이 스택처럼 쓸 수 있습니다! 맨 끝에 데이터를 추가할 때 push_back() 이나 emplace_back() 함수를 쓰면 됩니다.
• 새로운 임시 객체를 만들어서 바로 넣을 때는 emplace_back() 이 조금 더 빠르고 똑똑하게 동작합니다. 그 외의 평범한 상황에서는 push_back() 을 쓰시면 됩니다.

공간 늘리기 팁:

• resize() 함수: 배열의 '실제 길이'를 늘릴 때 사용합니다. (데이터가 실제로 추가됨)
• reserve() 함수: 데이터는 놔두고 '빈 공간(용량)'만 미리 넉넉하게 확보해 둘 때 사용합니다. (이사를 자주 안 가도록 미리 큰 집을 구하는 것과 같아요).

주의사항: 이상한 녀석, std::vector<bool>

• 참/거짓(bool) 값을 담기 위한 std::vector<bool> 이라는 특별한 녀석이 있습니다. 이 녀석은 메모리 공간을 아주 쪼잔하게 아끼려고 8개의 값을 1바이트 안에 억지로 구겨 넣는 꼼수를 부립니다.
• 문제는 이런 꼼수 때문에, 이 녀석은 진짜 배열도 아니고 C++의 컨테이너 표준 규칙도 따르지 않게 되어버렸다는 점입니다. 다른 정상적인 코드들과 섞여서 문제를 일으키기 딱 좋으니, std::vector<bool> 은 가급적 피하고 사용하지 않는 것이 속 편합니다!

개요

이 문서는 C++ 프로그램이 텍스트 형태의 소스 코드에서 실행 가능한 바이너리(Executable Binary) 파일로 변환되는 전체 과정을 설명합니다. C++의 빌드 과정은 크게 전처리, 컴파일, 링크의 단계로 나뉘며, 각 단계의 핵심 개념을 초보자도 이해할 수 있도록 명확하게 정리했습니다.

1. 프로그램의 시작점: main 함수 [01:39]

모든 C++ 프로그램은 main 함수를 가집니다. 이는 프로그램의 진입점(Entry Point)으로, 운영체제가 애플리케이션을 실행할 때 가장 먼저 코드를 읽고 실행하기 시작하는 부분입니다.

• 컴퓨터는 main 함수 내부의 코드를 위에서부터 아래로 한 줄씩 순차적으로 실행합니다.
• main 함수의 반환 타입은 정수형(int)이지만, 프로그래머가 명시적으로 값을 반환(return)하지 않아도 컴파일러가 자동으로 0을 반환하는 것으로 처리합니다. 이는 프로그램의 정상 종료를 의미하는 특별한 예외 규칙입니다.

2. 전처리기 (Pre-processor) [00:55]

컴파일러가 소스 코드를 기계어로 번역하기 직전에 수행되는 단계입니다.

• # 기호로 시작하는 구문(예: #include)을 전처리기 지시문이라고 부릅니다.
• 예를 들어 #include <iostream> 구문이 있다면, 전처리기는 iostream이라는 파일의 모든 내용을 찾아 복사한 뒤, 현재 파일의 해당 위치에 그대로 붙여넣습니다.

3. 연산자(Operator)와 함수 [02:54]

C++ 문법을 처음 접할 때 혼란스러울 수 있는 부분 중 하나는 꺾쇠 기호(<<)의 사용입니다.

• std::cout << "Hello World"에서 사용되는 << 기호는 단순한 기호가 아니라 오버로딩된 연산자(Overloaded Operator)입니다.
• C++에서 연산자는 근본적으로 함수와 동일하게 동작합니다. 즉, 위의 코드는 문자열 데이터를 콘솔 화면으로 밀어넣어 출력하도록 정의된 하나의 함수를 호출하는 것과 같습니다.

4. 컴파일 (Compilation) 과정 [08:20]

전처리기가 작업을 마친 후, 사람이 읽을 수 있는 C++ 코드를 컴퓨터가 이해할 수 있는 기계어(Machine Code)로 변환하는 과정입니다.

• 개별 컴파일: 프로젝트 내의 모든 .cpp 파일은 각각 독립적으로 컴파일됩니다. 이때 헤더 파일은 직접 컴파일되지 않으며, 전처리기를 통해 .cpp 파일에 포함된 상태로만 처리됩니다.
• 오브젝트 파일 생성: 각 .cpp 파일은 컴파일을 거쳐 각각 독립된 오브젝트 파일(.obj)로 변환됩니다.

5. 선언(Declaration)과 정의(Definition) [15:16]

코드를 여러 파일로 나누어 관리할 때 반드시 이해해야 하는 핵심 개념입니다.

• 선언 (Declaration): 컴파일러에게 특정 이름의 함수나 변수가 존재함을 알려주는 역할만 합니다. 내부 로직(본문)은 작성하지 않으며, 이를 통해 다른 파일에 있는 함수를 호출할 때 컴파일 오류가 발생하지 않도록 컴파일러를 납득시킵니다.
• 정의 (Definition): 해당 함수가 실제로 어떤 동작을 수행하는지 그 내부 로직(본문)을 작성하는 구역입니다.

6. 링커 (Linker)의 역할 [08:53]

컴파일러가 생성한 여러 개의 개별 오브젝트 파일(.obj)을 하나로 연결하여 최종적인 하나의 실행 파일(.exe)을 만드는 과정입니다.

• 링커의 주된 목적은 분리된 파일들을 접착제처럼 연결(Wiring)하는 것입니다.
• 만약 소스 코드에서 특정 함수를 '선언'하여 사용했으나, 프로젝트 전체를 뒤져봐도 그 함수의 실제 '정의'를 찾을 수 없다면 링커는 연결에 실패합니다. 이때 발생하는 오류가 바로 '확인되지 않은 외부 기호(Unresolved External Symbol)' 오류입니다.

7. 빌드 설정 (Build Configuration) [05:06]

개발 환경(예: Visual Studio)에서는 코드를 컴파일하고 빌드하는 규칙을 설정할 수 있습니다.

• Debug 모드: 프로그램의 논리적 오류를 쉽게 추적할 수 있도록 최적화(Optimization) 기능이 비활성화됩니다. 실행 속도는 상대적으로 느리지만 개발 과정에서 반드시 필요합니다.
• Release 모드: 최종 사용자에게 배포하기 위한 설정으로, 실행 속도와 성능을 극대화하기 위해 코드를 최적화합니다.

핵심 요약

위 본문에서 다룬 C++ 동작 원리의 중요한 핵심 개념은 다음과 같습니다.

1. main 함수: C++ 프로그램이 실행을 시작하는 최초의 진입점.
2. 전처리기: 실제 컴파일 이전에 # 지시문을 먼저 평가하여 필요한 파일의 내용을 복사 및 병합하는 작업 수행.
3. 컴파일러: 각각의 .cpp 파일을 독립적으로 기계어로 번역하여 개별적인 .obj(오브젝트) 파일을 생성하는 도구.
4. 선언과 정의: 선언은 대상의 존재 여부만 컴파일러에 알리는 것이고, 정의는 실제 동작 코드를 구현하는 것.
5. 링커: 컴파일된 여러 개의 .obj 파일을 하나로 결합하여 단일 .exe(실행) 파일을 생성하고, 선언과 정의가 일치하도록 연결하는 도구.

[https://youtu.be/SfGuIVzE_Os?si=mo0ZYpj_gP-4trat]

본 문서는 C++ 프로그래밍 언어의 기본적인 목적과 동작 원리를 이해하기 위해 작성된 자가 학습용 기술 문서입니다. 아래 내용은 제공된 영상에 기반하여 작성되었습니다.

1. C++를 학습하는 이유 [00:50]

C++는 하드웨어에 대한 직접적인 제어권과 뛰어난 성능을 제공하는 프로그래밍 언어입니다. 이러한 특성 때문에 다음과 같은 분야에서 필수적으로 사용됩니다.

• 고성능 애플리케이션: 빠른 실행 속도와 최적화가 요구되는 소프트웨어 개발에 적합합니다.
• 게임 개발: Unity, Unreal, Frostbite 등 업계 표준 게임 엔진은 대부분 C++로 작성되어 있습니다 [01:05].
• 네이티브 실행 환경: 특정 하드웨어 아키텍처나 플랫폼에서 직접 구동되어야 하는 프로그램 개발에 쓰입니다.

2. C++의 동작 원리 [01:28]

C++는 네이티브 언어로 분류되며, 다음과 같은 과정을 거쳐 실행됩니다.

1. 소스 코드 작성: 개발자가 C++ 문법에 맞춰 코드를 작성합니다.
2. 컴파일: 컴파일러가 소스 코드를 타겟 플랫폼의 CPU가 직접 이해하고 실행할 수 있는 기계어로 변환합니다.
3. 실행: 변환된 기계어가 타겟 플랫폼의 CPU에서 즉각적으로 명령을 수행합니다 [01:37].

이러한 특성 덕분에 특정 플랫폼용 컴파일러만 존재한다면 Windows, Mac, Linux 기반의 데스크톱은 물론 모바일(iOS, Android)과 콘솔 기기(PlayStation, Xbox, Nintendo 등) 등 광범위한 플랫폼을 지원할 수 있습니다 [01:58].

3. C++와 가상 머신(VM) 기반 언어의 차이 [02:42]

C++의 장점을 깊이 이해하기 위해서는 Java나 C#과 같은 가상 머신 기반 언어와의 차이점을 알아야 합니다.

• 가상 머신 기반 언어: 코드를 중간 언어로 우선 컴파일한 뒤, 프로그램 실행 시점에 가상 머신이 이를 기계어로 실시간 번역하여 실행합니다. 이는 외국어 책을 읽을 때 통역사가 옆에서 실시간으로 번역해 주는 것과 같습니다 [02:59].
• C++ (네이티브 언어): 타겟 플랫폼의 기계어로 완전히 번역된 상태의 결과물을 생성합니다. 이는 책 자체를 이미 해당 언어로 번역하여 출판한 것과 같아, 별도의 번역 과정 없이 즉시 실행될 수 있습니다 [03:46].

4. 성능에 관한 주의 사항 [04:11]

C++가 기계어로 직접 컴파일된다고 해서 무조건 빠른 속도를 보장하는 것은 아닙니다. 비효율적으로 작성된 C++ 코드는 오히려 런타임 최적화를 지원하는 Java나 C# 코드보다 느리게 동작할 수 있습니다. 따라서 C++의 진정한 성능을 끌어내기 위해서는 메모리 관리, 포인터, 자료구조 등을 올바르게 이해하고 최적화된 코드를 작성하는 방법을 학습해야 합니다 [04:29].

핵심 요약

• C++의 강점: 하드웨어에 대한 직접적인 제어와 뛰어난 성능을 제공하며, 고성능 소프트웨어 및 게임 엔진 개발의 핵심 언어입니다.
• 네이티브 컴파일: C++ 코드는 타겟 기기의 CPU가 직접 이해하는 기계어로 즉시 변환되므로 런타임 번역 과정이 불필요합니다.
• 플랫폼 독립성 확보: 적합한 컴파일러를 통해 데스크톱, 모바일, 콘솔을 아우르는 광범위한 환경에서 네이티브 코드를 실행할 수 있습니다.
• 최적화의 중요성: C++의 이점을 극대화하려면 메모리 구조에 대한 이해를 바탕으로 올바르고 효율적인 코드를 작성하는 능력이 필요합니다.

참고 영상 URL: https://www.youtube.com/watch?v=18c3MTX0PK0

새내기 프로그래머들이 클래스에 대해 자주 묻는 질문 중 하나는 바로 이것입니다.

*"멤버 함수를 실행할 때, C++은 대체 어떤 객체에서 그 함수를 실행해야 하는지 어떻게 기억하고 있는 걸까요?"*

먼저 이 상황을 확인해 보기 위해 아주 간단한 클래스를 하나 만들어 볼게요. 이 클래스는 숫자(정수) 하나를 품고 있고, 그 숫자를 가져오거나 바꾸는 간단한 함수들을 가지고 있습니다.

#include <iostream>

class Simple
{
private:
    int m_id{};

public:
    Simple(int id)
        : m_id{ id }
    {
    }

    int getID() const { return m_id; }
    void setID(int id) { m_id = id; }

    void print() const { std::cout << m_id; }
};

int main()
{
    Simple simple{1};
    simple.setID(2);

    simple.print();

    return 0;
}

여러분이 예상하신 대로, 이 프로그램은 다음 결과를 보여줍니다.

2

여기서 신기한 점이 있어요. 우리가 simple.setID(2); 를 불렀을 때, C++은 setID() 라는 함수가 simple 이라는 특정 객체를 위해 일해야 한다는 것을 알고 있습니다. 게다가 코드 안에 있는 m_id 가 사실은 simple.m_id 를 가리킨다는 것도 귀신같이 알아채죠.

그 비밀은 바로, C++이 뒤에서 몰래 this 라는 이름의 '숨겨진 포인터'를 사용하고 있기 때문입니다! 이번 레슨에서는 이 this 에 대해 더 자세히 파헤쳐 볼게요.

숨겨진 this 포인터

모든 멤버 함수 안에는 this 라는 키워드가 숨어 있습니다. 이건 '현재 작업 중인 바로 그 객체'의 주소가 적힌 지워지지 않는 명찰(const pointer)이라고 생각하시면 돼요.

보통 우리는 this 를 굳이 눈에 보이게 쓰지 않지만, 원한다면 직접 꺼내서 쓸 수도 있다는 걸 보여드릴게요.

#include <iostream>

class Simple
{
private:
    int m_id{};

public:
    Simple(int id)
        : m_id{ id }
    {
    }

    int getID() const { return m_id; }
    void setID(int id) { m_id = id; }

    void print() const { std::cout << this->m_id; } // `this` 포인터를 사용해 현재 객체를 가리키고, -> 기호로 m_id 변수를 콕 집어냅니다
};

int main()
{
    Simple simple{ 1 };
    simple.setID(2);

    simple.print();

    return 0;
}

이 코드도 방금 전 예제와 완전히 똑같이 작동하고, 2를 출력합니다. 여기서 이전 코드와 이번 코드의 print() 함수가 사실상 100% 똑같은 일을 한다는 걸 주목해 주세요.

void print() const { std::cout << m_id; }       // 내가 안 써도 C++이 알아서 this를 써줌 (암시적)
void print() const { std::cout << this->m_id; } // 내가 직접 this를 써줌 (명시적)

알고 보니 첫 번째 코드는 두 번째 코드를 쓰기 편하게 줄여 놓은 거였어요! 우리가 짠 코드를 컴퓨터가 알아들을 수 있게 번역(컴파일)할 때, 컴파일러는 객체의 멤버를 사용할 때마다 몰래 앞에 this-> 를 붙여줍니다. 덕분에 우리가 매번 귀찮게 this-> 를 반복해서 쓰지 않아도 되니까 코드가 훨씬 깔끔해지는 거죠.

잠깐 복습! 포인터(주소표)를 통해 객체 안의 내용물을 꺼낼 때는 -> 라는 화살표 기호를 씁니다. this->m_id 는 (*this).m_id 와 완전히 똑같은 뜻이에요.

this 는 어떻게 몰래 전달될까요?

아래의 함수 호출 코드를 돋보기로 들여다볼까요? simple.setID(2);

setID(2) 함수를 부를 때 괄호 안에 재료(인자)가 '2' 하나만 있는 것 같죠? 하지만 사실은 두 개랍니다! 컴파일러가 코드를 번역할 때, 이 줄을 이렇게 슬쩍 바꿔버립니다.

Simple::setID(&simple, 2); // 주목: 주인공이었던 simple 객체가 함수 괄호 안의 첫 번째 재료로 들어갔어요!

이제 이건 아주 평범한 함수 모양이 되었습니다. 그리고 함수 이름 앞에 있던 simple 객체는, 자신의 주소(&simple) 형태로 함수의 첫 번째 재료가 되어 전달되죠.

하지만 이건 절반의 설명일 뿐이에요. 함수를 부르는 쪽에서 재료를 하나 더 던져주기로 했으니, 함수를 정의하는 쪽에서도 그 재료를 받을 바구니(매개변수)를 하나 더 만들어야겠죠? 원래 우리의 setID() 함수는 이랬습니다.

void setID(int id) { m_id = id; }

이 코드가 최종적으로 어떻게 변하는지는 컴퓨터 환경마다 조금 다를 수 있지만, 대략 이런 모습으로 바뀝니다.

static void setID(Simple* const this, int id) { this->m_id = id; }

setId 함수 괄호 안 맨 왼쪽에 this 라는 새로운 바구니(매개변수)가 생겼네요! 이건 다른 곳을 가리키도록 바꿀 수는 없는 고정된 포인터(const pointer)입니다. 그리고 안쪽에 있던 m_id 도 방금 받은 this 를 사용해서 this->m_id 로 바뀌었죠.

(고급 독자를 위한 참고: 여기서 static 이란 뜻은, 이 함수가 특정 객체에 찰싹 달라붙어 있는 게 아니라, 클래스라는 동네 안에 있는 평범한 함수처럼 취급된다는 뜻입니다.)

총정리 해볼까요?

1. 우리가 simple.setID(2) 를 실행하면, 컴퓨터는 몰래 Simple::setID(&simple, 2) 를 실행해서 simple 의 주소표를 함수에 넘겨줍니다.
2. 이 함수 안에는 this 라는 숨겨진 바구니가 있어서, 방금 날아온 simple 의 주소표를 쏙 받아냅니다.
3. 함수 안에서 쓰인 멤버 변수 앞에는 컴파일러가 알아서 this-> 를 붙여줍니다. this 가 simple 을 가리키고 있으니, this->m_id 는 결국 simple.m_id 를 뜻하게 되는 거죠.

다행인 점은 이 모든 복잡한 과정이 100% 자동으로 일어난다는 것입니다. 작동 원리를 다 못 외우셔도 프로그래밍하는 데 아무 지장 없어요! 딱 한 가지만 기억하세요.

핵심 포인트 모든 일반 멤버 함수에는 현재 작업 중인 객체를 가리키는 this 라는 숨겨진 안내판(포인터)이 있습니다. this 는 항상 '지금 일하고 있는 바로 그 녀석'을 가리킵니다.

this 가 직접 나설 때 (명시적으로 쓰기)

대부분의 경우 여러분이 직접 this 를 타자 칠 일은 없습니다. 하지만 가끔 직접 써주면 아주 유용할 때가 있어요.

첫 번째로, 클래스의 변수 이름과 함수의 매개변수(들어오는 재료) 이름이 완전히 똑같을 때, this 를 써서 "누가 누군지" 확실히 구분해 줄 수 있습니다.

struct Something
{
    int data{}; // 이건 구조체(struct)라서 이름 앞에 m_ 을 안 붙였어요

    void setData(int data)
    {
        this->data = data; // this->data는 내 몸통 안에 있는 멤버 변수이고, 그냥 data는 밖에서 괄호 타고 들어온 재료입니다
    }
};

이 Something 안에는 data 라는 변수가 있어요. 그런데 setData() 함수가 받는 재료의 이름도 data 네요. 함수 안에서 그냥 data 라고 부르면, 컴퓨터는 내 몸통 안의 변수가 아니라 밖에서 들어온 재료 data 를 뜻하는 걸로 알아듣습니다.

그래서 "아니, 내 몸통 안에 있는 원래 내 data 말이야!" 라고 콕 집어 말해주기 위해 this->data 라고 쓰는 거죠. (물론 제일 좋은 방법은 처음부터 헷갈리지 않게 멤버 변수 이름 앞에 m_ 을 붙이는 거랍니다!)

*this 반환하기

두 번째로, 멤버 함수가 자기 자신(현재 객체)을 통째로 뱉어내게(반환하게) 만들면 아주 멋진 일이 벌어집니다. 이렇게 하면 여러 개의 함수를 한 줄에 기차처럼 칙칙폭폭 이어서 쓸 수 있거든요! 이걸 바로 함수 체이닝(Function chaining) 또는 메서드 체이닝(Method chaining) 이라고 부릅니다.

우리가 화면에 글자를 찍을 때 쓰는 std::cout 을 볼까요? std::cout << "Hello, " << userName;

컴퓨터는 이걸 이렇게 괄호 쳐서 먼저 계산합니다. (std::cout << "Hello, ") << userName;

먼저 앞부분이 실행돼서 화면에 "Hello, "를 찍어요. 그런데 이 줄이 여기서 끝이 아니라 뒤에 계속 이어져야 하잖아요? 만약 앞부분을 실행하고 남는 결과가 아무것도 없다면(void), 엉뚱하게 이런 모양이 돼버릴 겁니다.

void{} << userName; // 아무것도 없는 빈 공간에 userName을 밀어 넣으라니? (에러 발생!)

그래서 operator<< (화면에 글자 찍는 기능)는 자기 할 일을 다 하고 나면, 자기가 썼던 std::cout 객체를 다시 바깥으로 퉤! 하고 뱉어냅니다(반환합니다). 그럼 코드가 이렇게 바뀌죠.

(std::cout) << userName;

덕분에 우리는 std::cout 을 맨 처음에 딱 한 번만 쓰고도 << 기호를 이용해 원하는 만큼 글자를 계속 이어 붙일 수 있는 거예요.

이 마법 같은 기차놀이를 우리가 만든 클래스에도 똑같이 적용할 수 있습니다! 아래의 계산기 코드를 보세요.

class Calc
{
private:
    int m_value{};

public:
    void add(int value) { m_value += value; }
    void sub(int value) { m_value -= value; }
    void mult(int value) { m_value *= value; }

    int getValue() const { return m_value; }
};

여기서 5를 더하고, 3을 빼고, 4를 곱하고 싶다면 보통은 이렇게 답답하게 세 줄로 나눠서 적어야 합니다.

#include <iostream>

int main()
{
    Calc calc{};
    calc.add(5); // 끝나고 아무것도 안 뱉음 (void)
    calc.sub(3); // 끝나고 아무것도 안 뱉음 (void)
    calc.mult(4); // 끝나고 아무것도 안 뱉음 (void)

    std::cout << calc.getValue() << '\n';

    return 0;
}

하지만 각 함수가 끝날 때 자기를 부른 객체(*this)를 되돌려주도록(반환하도록) 살짝만 고쳐볼까요?

class Calc
{
private:
    int m_value{};

public:
    Calc& add(int value) { m_value += value; return *this; }
    Calc& sub(int value) { m_value -= value; return *this; }
    Calc& mult(int value) { m_value *= value; return *this; }

    int getValue() const { return m_value; }
};

각 함수 끝에 return *this; 가 추가된 게 보이시나요? 이제 우리는 이렇게 멋진 한 줄 코드를 쓸 수 있습니다!

#include <iostream>

int main()
{
    Calc calc{};
    calc.add(5).sub(3).mult(4); // 마법의 메서드 체이닝 (기차놀이!)

    std::cout << calc.getValue() << '\n';

    return 0;
}

세 줄이나 되던 코드가 한 줄로 예쁘게 줄었죠! 어떻게 이렇게 되는지 단계별로 볼까요?

1. 처음에 calc.add(5) 가 실행돼서 5를 더합니다. 그리고 자기를 부른 자기 자신(calc)을 그대로 뱉어냅니다.
2. 그럼 바로 뒤에 붙어있던 .sub(3) 은 방금 뱉어진 calc 를 받아서 거기서 3을 뺍니다. 그리고 또 자기를 뱉어냅니다.
3. 마지막으로 .mult(4) 가 받아서 4를 곱합니다.

함수가 끝날 때마다 자기 자신을 다음 타자에게 넘겨주니까, 끊기지 않고 계속 이어서 명령을 내릴 수 있는 거예요. 결국 값은 (((0 + 5) - 3) * 4) 가 되어서 8 이 저장됩니다.

(this 는 항상 지금 일하고 있는 진짜 객체를 가리키고 있기 때문에, "혹시 비어있으면(null) 어떡하지?" 하는 걱정은 안 하셔도 된답니다!)

왜 this 는 참조(&)가 아니라 포인터(*)일까요?

설명을 듣다 보니, this 는 언제나 어떤 객체를 찰떡같이 가리키고 있잖아요? 그럼 굳이 복잡하게 포인터를 써서 화살표(->) 기호를 쓸 게 아니라, 더 깔끔한 참조(reference)를 쓰면 되지 않았나 싶으실 거예요.

정답은 아주 재미있습니다. 처음에 C++ 언어를 만들면서 this 라는 개념을 집어넣었을 그 옛날 당시에는... C++에 아직 '참조(reference)'라는 문법 자체가 존재하지 않았기 때문이에요!

만약 오늘날 C++이 새로 만들어졌다면, 틀림없이 this 를 포인터 대신 참조로 만들었을 겁니다. (실제로 Java나 C# 같은 최신 언어들은 this 를 참조 방식으로 사용하고 있어요.)

15.2 — 클래스와 헤더 파일

지금까지 우리가 작성한 모든 클래스는 아주 간단해서, 클래스 안에서 직접 함수를 만들(구현할) 수 있었습니다. 예를 들어, 아래는 모든 함수가 클래스 안에 들어있는 간단한 Date 클래스입니다.

#include <iostream>

class Date
{
private:
    int m_year{};
    int m_month{};
    int m_day{};

public:
    Date(int year, int month, int day)
        : m_year { year }
        , m_month { month }
        , m_day { day}
    {
    }

    void print() const { std::cout << "Date(" << m_year << ", " << m_month << ", " << m_day << ")\n"; }

    int getYear() const { return m_year; }
    int getMonth() const { return m_month; }
    int getDay() const { return m_day; }
};

int main()
{
    Date d { 2015, 10, 14 };
    d.print();

    return 0;
}

하지만 클래스가 점점 길어지고 복잡해지면, 모든 함수 내용을 클래스 안에 두는 것이 오히려 코드를 관리하고 작업하기 어렵게 만듭니다. 이미 만들어진 클래스를 사용할 때는 공개된 기능 이 무엇인지만 알면 되지, 그 내부가 어떻게 돌아가는지까지 전부 알 필요는 없거든요. 함수가 어떻게 작동하는지 적힌 복잡한 내용들이 섞여 있으면, 정작 이 클래스를 어떻게 써야 하는지 한눈에 파악하기 힘들어집니다.

이 문제를 해결하기 위해, C++에서는 클래스의 "선언(껍데기)" 부분과 "구현(알맹이)" 부분을 나눌 수 있게 해줍니다. 즉, 함수 내용을 클래스 밖으로 빼서 정의할 수 있는 것이죠.

아래는 위와 똑같은 Date 클래스이지만, 생성자와 print() 함수의 내용을 클래스 밖으로 빼낸 모습입니다. 클래스 안에는 "이런 함수가 있을 거야"라고 알려주는 선언만 남겨두고, 실제 작동하는 코드는 밖으로 이동시켰습니다.

#include <iostream>

class Date
{
private:
    int m_year{};
    int m_month{};
    int m_day{};

public:
    Date(int year, int month, int day); // 생성자 선언

    void print() const; // 출력 함수 선언

    int getYear() const { return m_year; }
    int getMonth() const { return m_month; }
    int getDay() const  { return m_day; }
};

Date::Date(int year, int month, int day) // 생성자 정의 (실제 구현)
    : m_year{ year }
    , m_month{ month }
    , m_day{ day }
{
}

void Date::print() const // 출력 함수 정의 (실제 구현)
{
    std::cout << "Date(" << m_year << ", " << m_month << ", " << m_day << ")\n";
};

int main()
{
    const Date d{ 2015, 10, 14 };
    d.print();

    return 0;
}

일반 함수를 만들 때처럼, 클래스에 속한 함수도 클래스 밖에서 만들 수 있습니다. 유일한 차이점은 함수 이름 앞에 이 함수가 어떤 클래스 소속인지 알려주기 위해 클래스 이름 (여기서는 Date::)을 붙여야 한다는 것입니다. 이렇게 해야 컴퓨터(컴파일러)가 "아, 이건 그냥 함수가 아니라 Date 클래스의 함수구나!"라고 이해할 수 있습니다.

참고로, 값을 읽어오기만 하는 짧은 함수(getYear 같은 접근자 함수)는 여전히 클래스 안에 남겨두었습니다. 이런 함수들은 보통 한 줄짜리라서 클래스 안에 둬도 복잡해 보이지 않거든요. 오히려 밖으로 빼면 쓸데없이 코드 줄 수만 길어집니다. 그래서 이렇게 단순한 한 줄짜리 함수들은 보통 클래스 안에 그냥 둡니다.

클래스 정의를 헤더 파일에 넣기

소스 파일(.cpp) 안에 클래스를 만들면, 그 클래스는 오직 그 파일 안에서만 쓸 수 있습니다. 하지만 프로그램이 커지면 우리가 만든 클래스를 여러 파일에서 가져다 쓰고 싶어지겠죠?

이전 강의에서 함수 선언을 헤더 파일(.h) 에 넣을 수 있다고 배웠습니다. 그렇게 하면 여러 코드 파일에서 #include를 사용해 그 함수들을 불러올 수 있었죠. 클래스도 똑같습니다! 클래스의 껍데기(선언)를 헤더 파일에 넣고, 그 클래스를 쓰고 싶은 다른 파일들에서 #include로 불러오면 됩니다.

다만 함수와는 조금 다릅니다. 함수는 이름만 미리 알려줘도 쓸 수 있지만, 클래스는 컴퓨터가 그 크기가 얼마나 되는지, 안에 어떤 변수들이 있는지 정확히 알아야 메모리를 만들 수 있습니다. 그래서 헤더 파일에는 단순히 이름만 적는 게 아니라, 클래스의 전체적인 형태(정의)를 모두 적어주어야 합니다.

클래스 헤더와 코드 파일 이름 짓기

가장 일반적인 방법은 클래스와 동일한 이름의 헤더 파일 을 만들고, 클래스 밖으로 빼낸 함수들은 동일한 이름의 .cpp 파일 에 넣는 것입니다.

우리 Date 클래스를 .h 파일과 .cpp 파일로 쪼개볼까요?

Date.h:

#ifndef DATE_H
#define DATE_H

class Date
{
private:
    int m_year{};
    int m_month{};
    int m_day{};

public:
    Date(int year, int month, int day);

    void print() const;

    int getYear() const { return m_year; }
    int getMonth() const { return m_month; }
    int getDay() const { return m_day; }
};

#endif

Date.cpp:

#include "Date.h"

Date::Date(int year, int month, int day) // 생성자 정의
    : m_year{ year }
    , m_month{ month }
    , m_day{ day }
{
}

void Date::print() const // 출력 함수 정의
{
    std::cout << "Date(" << m_year << ", " << m_month << ", " << m_day << ")\n";
};

이제 Date 클래스를 사용하고 싶은 다른 파일이 있다면, 그냥 #include "Date.h"만 적어주면 됩니다. 단, 프로그램이 제대로 합쳐지려면(링크 단계) Date.cpp 파일도 프로젝트에 포함되어 같이 번역(컴파일)되어야 한다는 점을 잊지 마세요!

모범 사례

• 클래스의 전체적인 모양(정의)은 클래스 이름과 같은 헤더 파일에 넣으세요. 아주 단순한 함수들은 클래스 안에 그대로 둬도 됩니다.
• 복잡하고 긴 함수들은 클래스 이름과 같은 소스 파일(.cpp)에 따로 빼서 작성하세요.

헤더 파일에 클래스를 넣으면 규칙(ODR) 위반 아닌가요?

C++에는 "모든 것은 프로그램 전체에서 딱 한 번만 정의되어야 한다"는 단일 정의 규칙(ODR) 이 있습니다. 헤더 파일을 여러 곳에서 #include 하면 여러 번 정의되는 셈인데 괜찮을까요?

다행히도 클래스 같은 '타입(Types)'은 이 규칙에서 예외입니다! 그래서 여러 파일에서 클래스 정의를 불러와도 문제가 없습니다. 만약 이게 안 됐다면 클래스는 별로 쓸모가 없었을 거예요. 하지만 같은 파일 안에서 똑같은 클래스를 두 번 불러오는 것은 여전히 규칙 위반입니다. 이를 막기 위해 우리는 헤더 가드(#ifndef 같은 것)나 #pragma once를 사용합니다.

인라인 멤버 함수

클래스 자체는 예외지만, '함수'는 단일 정의 규칙(ODR)의 예외가 아닙니다. 그럼 헤더 파일에 함수가 들어있을 때 여러 번 불러오면 어떻게 오류를 피할 수 있을까요?

• 클래스 안에 작성된 함수들은 자동으로 inline 처리가 됩니다. 인라인 함수는 단일 정의 규칙의 예외라서 여러 번 불러와도 괜찮습니다.
• 클래스 밖에 작성된 함수들은 자동으로 inline 처리가 되지 않습니다. 그래서 이런 함수들을 헤더 파일에 두면 여러 번 정의되었다고 에러가 납니다. 이것이 바로 긴 함수들을 .cpp 파일에 따로 모아두는 이유입니다. (.cpp 파일은 프로그램에서 한 번만 만들어지니까요.)

만약 굳이 클래스 밖에 작성한 함수를 헤더 파일에 남겨두고 싶다면, 함수 앞에 명시적으로 inline 이라는 단어를 붙여주면 됩니다.

왜 모든 걸 헤더 파일에 넣지 않을까요?

함수 내용까지 전부 헤더 파일에 넣으면 편할 것 같지만, 두 가지 큰 단점이 있습니다.

1. 앞서 말했듯, 클래스 모양이 너무 복잡해져서 읽기 힘들어집니다.
2. 헤더 파일의 코드를 단 한 줄이라도 수정하면, 그 헤더를 가져다 쓴 모든 파일 을 다시 번역(컴파일)해야 합니다. 작은 프로젝트면 금방 끝나지만, 엄청나게 큰 상업용 프로그램이라면 코드를 한 줄 고치고 몇 시간씩 기다려야 할 수도 있습니다!

반면에 .cpp 파일의 코드를 수정하면, 그 .cpp 파일 딱 하나만 다시 번역하면 됩니다. 따라서 복잡한 코드는 최대한 .cpp 파일에 넣는 것이 훨씬 좋습니다.

물론 예외도 있습니다.

• 딱 한 파일에서만 쓸 아주 작은 클래스라면 그냥 .cpp 안에 다 몰아넣어도 됩니다.
• 복잡한 함수가 한두 개뿐이고 앞으로 수정할 일이 거의 없다면, 헤더 파일에 inline으로 넣는 게 편할 수 있습니다.
• 요즘 C++에서는 공유하기 쉽게 아예 모든 걸 헤더 파일에 때려 넣은 "헤더 전용(Header-only)" 라이브러리를 만들기도 합니다.
• 나중에 배울 템플릿(Template) 클래스의 경우, 규칙상 거의 무조건 헤더 파일에 모든 걸 작성해야 합니다.

멤버 함수의 기본 인수

일반 함수의 경우 기본 인수(입력하지 않으면 자동으로 들어가는 값)는 주로 선언(헤더 파일) 쪽에 적으라고 배웠습니다. 클래스 함수의 경우는 훨씬 간단합니다. 기본 인수는 무조건 클래스 안(선언부)에 적어주세요.

모범 사례 클래스 함수의 기본 인수는 항상 클래스 정의 안에 넣으세요.

라이브러리

여러분은 이미 std::string 처럼 C++ 표준 라이브러리에 있는 클래스들을 써왔습니다. 이때 #include <string> 이라고 헤더 파일만 불러왔지, string.cpp 같은 코드 파일을 프로젝트에 추가한 적은 없으실 겁니다.

헤더 파일은 "문법이 맞는지" 컴퓨터가 확인하게 해주는 역할만 합니다. 진짜 복잡한 내부 코드는 어디 있을까요? 이미 번역이 다 끝난 파일 형태로 숨겨져 있다가, 프로그램이 완성될 때(링크 단계) 자동으로 찰싹 달라붙습니다. 그래서 여러분은 그 코드를 볼 수 없는 것이죠.

기업들이 라이브러리를 팔거나 배포할 때도 보통 .h 헤더 파일과 '미리 컴파일된 파일'만 줍니다. 매번 다시 번역하기엔 너무 오래 걸리고, 용량도 아낄 수 있으며, 무엇보다 자기들의 소중한 코드를 남이 훔쳐보지 못하게 하기 위해서입니다.

지금 당장 여러분이 이런 라이브러리를 만들 일은 없겠지만, 이렇게 헤더 파일(.h)과 소스 파일(.cpp)을 나누어 작성하는 버릇을 들이면 나중에 훌륭한 프로그래머로 성장하는 데 큰 도움이 될 것입니다.

15.3 — 중첩 타입 (멤버 타입)

다음의 짧은 프로그램을 한 번 살펴볼까요?

#include <iostream>

enum class FruitType
{
    apple,
    banana,
    cherry
};

class Fruit
{
private:
    FruitType m_type { };
    int m_percentageEaten { 0 };

public:
    Fruit(FruitType type) :
        m_type { type }
    {
    }

    FruitType getType() { return m_type; }
    int getPercentageEaten() { return m_percentageEaten; }

    bool isCherry() { return m_type == FruitType::cherry; }
};

int main()
{
    Fruit apple { FruitType::apple };

    if (apple.getType() == FruitType::apple)
        std::cout << "I am an apple";
    else
        std::cout << "I am not an apple";

    return 0;
}

이 프로그램 자체에는 아무런 문제가 없습니다. 하지만 enum class FruitType 은 원래 Fruit 클래스와 세트로 함께 쓰려고 만든 건데, 클래스 밖에 따로 덩그러니 떨어져 있다 보니 두 개가 어떻게 연결되어 있는지 우리가 직접 눈치껏 알아내야 하는 불편함이 있습니다.

중첩 타입 (멤버 타입)

지금까지 우리는 '데이터 멤버(변수)'와 '멤버 함수', 이렇게 두 가지 종류를 가진 클래스를 보았습니다. 위의 Fruit 클래스도 이 두 가지를 모두 가지고 있죠.

그런데 클래스에는 또 다른 종류의 멤버가 들어갈 수 있습니다. 바로 중첩 타입 (또는 멤버 타입) 입니다! 중첩 타입을 만드는 방법은 아주 간단해요. 그냥 클래스 안에서 원하는 접근 지정자(public, private 등) 아래에 타입을 새롭게 정의하면 됩니다.

위의 프로그램을 Fruit 클래스 안에 '중첩 타입'을 정의하는 방식으로 다시 써보겠습니다.

#include <iostream>

class Fruit
{
public:
    // FruitType을 클래스 안으로 옮기고 public 접근 지정자 아래에 두었습니다.
    // 이름도 Type으로 짧게 바꾸고, enum class 대신 일반 enum으로 변경했습니다.
    enum Type
    {
        apple,
        banana,
        cherry
    };

private:
    Type m_type {};
    int m_percentageEaten { 0 };

public:
    Fruit(Type type) :
        m_type { type }
    {
    }

    Type getType() { return m_type;  }
    int getPercentageEaten() { return m_percentageEaten;  }

    // Fruit 클래스 내부에서는 더 이상 앞에 FruitType:: 을 붙일 필요가 없습니다.
    bool isCherry() { return m_type == cherry; } 
};

int main()
{
    // 참고: 클래스 밖에서는 이제 Fruit:: 이라는 소속을 붙여서 접근합니다.
    Fruit apple { Fruit::apple };

    if (apple.getType() == Fruit::apple)
        std::cout << "I am an apple";
    else
        std::cout << "I am not an apple";

    return 0;
}

여기서 짚고 넘어갈 만한 중요한 포인트가 몇 가지 있습니다.

첫째, FruitType 이 이제 클래스 안으로 쏙 들어왔고, 이름이 Type 으로 바뀌었습니다. (이름을 왜 바꿨는지는 곧 설명해 드릴게요!)

둘째, 중첩 타입인 Type 이 클래스의 맨 꼭대기에 정의되었습니다. 중첩 타입은 사용하기 전에 먼저 그 정체가 완전히 정의되어 있어야 하거든요. 그래서 보통 맨 처음에 적어줍니다.

모범 사례 중첩 타입은 항상 클래스의 맨 위쪽에 정의하세요.

셋째, 중첩 타입도 일반적인 접근 권한 규칙을 따릅니다. Type 은 public 아래에 정의되었기 때문에, 누구나 클래스 밖에서 이 타입과 그 안의 값들에 직접 접근할 수 있습니다.

넷째, 이름 공간(namespace)처럼 클래스도 그 안에 있는 이름들을 품어주는 '범위(Scope)' 역할을 합니다.

따라서 Type 의 진짜 풀네임은 Fruit::Type 이 되고, apple 의 풀네임은 Fruit::apple 이 됩니다.

클래스 '내부' 멤버들끼리는 굳이 저렇게 긴 풀네임을 쓰지 않아도 됩니다. 예를 들어 멤버 함수인 isCherry() 안에서는 Fruit:: 이라는 소속을 붙이지 않고 그냥 cherry 라고만 써도 찰떡같이 알아듣습니다.

하지만 클래스 '외부'에서는 반드시 풀네임(예: Fruit::apple)을 써야 합니다. 우리가 이름을 FruitType 에서 Type 으로 바꾼 이유가 바로 이겁니다. 밖에서 부를 때 Fruit::FruitType 이라고 쓰면 이름이 쓸데없이 겹치니까, 깔끔하게 Fruit::Type 이라고 쓸 수 있게 만든 거죠!

마지막으로, 기존의 범위가 있는 열거형(enum class)을 일반 열거형(enum)으로 바꾸었습니다. 이제 Fruit 클래스 자체가 울타리(범위) 역할을 든든하게 해주기 때문에, 굳이 enum class 를 써서 이중으로 울타리를 칠 필요가 없어진 거죠. 일반 enum 으로 바꾸었기 때문에 밖에서 Fruit::Type::apple 처럼 길게 안 쓰고 Fruit::apple 처럼 짧고 편하게 쓸 수 있습니다.

중첩 typedef 및 타입 별칭

클래스 안에는 typedef 나 using 을 이용한 '타입 별칭(별명)'도 넣을 수 있습니다.

#include <iostream>
#include <string>
#include <string_view>

class Employee
{
public:
    using IDType = int;

private:
    std::string m_name{};
    IDType m_id{};
    double m_wage{};

public:
    Employee(std::string_view name, IDType id, double wage)
        : m_name { name }
        , m_id { id }
        , m_wage { wage }
    {
    }

    const std::string& getName() { return m_name; }
    IDType getId() { return m_id; } // 클래스 안에서는 짧은 이름만 써도 됩니다.
};

int main()
{
    Employee john { "John", 1, 45000 };
    Employee::IDType id { john.getId() }; // 클래스 밖에서는 반드시 풀네임을 써야 합니다.

    std::cout << john.getName() << " has id: " << id << '\n';

    return 0;
}

이 코드를 실행하면 다음과 같이 출력됩니다.

John has id: 1

보시다시피 클래스 '안'에서는 그냥 IDType 이라고 편하게 쓰면 되지만, 클래스 '밖'에서는 Employee::IDType 처럼 정확한 풀네임을 써야 한다는 점을 기억해 주세요.

(타입 별칭의 장점은 10.7 레슨에서 다루었는데, 여기서도 같은 역할을 합니다. C++ 표준 라이브러리에서도 이런 중첩 typedef 를 아주 흔하게 사용합니다. 글을 쓰는 현재 기준으로 std::string 은 무려 10개나 되는 중첩 typedef 를 가지고 있답니다!)

중첩 클래스와 바깥 클래스 멤버 접근

클래스 안에 '또 다른 클래스'를 중첩해서 넣는 일은 꽤 드물지만, 가능하긴 합니다. C++에서 중첩 클래스(안쪽 클래스)는 자기를 감싸고 있는 바깥쪽 클래스의 this 포인터에 접근할 수 없습니다. 즉, 안쪽 클래스가 바깥 클래스의 멤버 변수나 함수를 '직접' 마음대로 꺼내 쓸 수는 없다는 뜻입니다. 왜냐하면 안쪽 클래스는 바깥 클래스 객체가 없어도 독립적으로 만들어질 수 있기 때문이에요. (바깥 클래스 객체가 아예 존재하지 않는 상황일 수도 있으니까요!)

하지만 안쪽 클래스도 어쨌든 바깥 클래스 식구(멤버) 중 하나이기 때문에, 바깥 클래스의 private 멤버에 접근할 수 있는 특별한 권한 자체는 가지고 있습니다. 단지 어떤 객체의 데이터인지 명확히 알려주기만 하면 됩니다.

예제를 통해 살펴볼까요?

#include <iostream>
#include <string>
#include <string_view>

class Employee
{
public:
    using IDType = int;

    class Printer
    {
    public:
        void print(const Employee& e) const
        {
            // Printer는 Employee의 'this' 포인터에 접근할 수 없기 때문에,
            // m_name과 m_id를 직접 출력할 수는 없습니다.
            // 대신, 사용할 Employee 객체를 통째로 전달받아야 합니다.
            // Printer는 Employee의 한 식구(멤버)이므로, 
            // 전달받은 객체(e)를 통하면 private 멤버인 e.m_name과 e.m_id에 직접 접근할 수 있습니다.
            std::cout << e.m_name << " has id: " << e.m_id << '\n';
        }
    };

private:
    std::string m_name{};
    IDType m_id{};
    double m_wage{};

public:
    Employee(std::string_view name, IDType id, double wage)
        : m_name{ name }
        , m_id{ id }
        , m_wage{ wage }
    {
    }

    // 이 예제에서는 사용되지 않으므로 접근 함수(getter)들을 제거했습니다.
};

int main()
{
    const Employee john{ "John", 1, 45000 };
    const Employee::Printer p{}; // 안쪽(중첩) 클래스의 객체를 생성합니다.
    p.print(john);

    return 0;
}

이 코드를 실행하면 다음과 같이 출력됩니다.

John has id: 1

중첩 클래스가 자주 쓰이는 아주 대표적인 예외 상황이 하나 있습니다. 바로 표준 라이브러리인데요, 데이터 모음(컨테이너)을 순회할 때 쓰는 대부분의 '반복자(iterator)' 클래스들이 자신이 탐색할 컨테이너의 중첩 클래스로 만들어져 있습니다. 예를 들어 std::string::iterator 는 std::string 의 중첩 클래스랍니다. (반복자는 나중에 다른 장에서 자세히 다룰게요.)

중첩 타입과 전방 선언

전방 선언이란, 컴파일러에게 "이런 타입이 앞으로 나올 테니까 놀라지 마"라고 이름만 미리 알려주는 것을 말합니다. 중첩 타입은 자기를 감싸고 있는 바깥 클래스 안에서 미리 전방 선언을 할 수 있습니다. 그러고 나서 나중에 바깥 클래스 안이나 밖에서 그 내용을 진짜로 정의하면 됩니다.

예를 들면 이렇게요.

#include <iostream>

class outer
{
public:
    class inner1;   // 정상: 감싸는 클래스 안에서 이름만 미리 전방 선언 가능
    class inner1{}; // 정상: 전방 선언했던 타입을 감싸는 클래스 안에서 정의
    class inner2;   // 정상: 감싸는 클래스 안에서 전방 선언 가능
};

class outer::inner2 // 정상: 전방 선언했던 타입을 감싸는 클래스 '밖'에서 정의
{};

int main()
{
    return 0;
}

하지만, 바깥 클래스 자체가 어떻게 생겼는지 정의되기도 전에 그 안에 들어갈 중첩 타입만 쏙 빼서 먼저 전방 선언할 수는 없습니다.

#include <iostream>

class outer;         // 정상: 중첩되지 않은 일반 클래스는 전방 선언 가능
class outer::inner1; // 오류: 바깥 클래스(outer)가 정의되기도 전에 중첩 타입(inner1)을 전방 선언할 수 없음

class outer
{
public:
    class inner1{}; // 참고: 여기서 중첩 타입이 선언됨
};

class outer::inner1; // 정상 (하지만 무의미함): 이미 바깥 클래스를 정의할 때 중첩 타입도 같이 선언되었기 때문

int main()
{
    return 0;
}

바깥 클래스를 정의한 '후'에 중첩 타입을 한 번 더 전방 선언하는 것은 기술적으로 오류는 나지 않지만, 이미 바깥 클래스 안에 중첩 타입에 대한 선언이 들어있을 테니 두 번 쓰는 셈이 되어 아무런 의미가 없습니다 (중복).

15.4 — 소멸자 소개

정리 문제 네트워크를 통해 데이터를 보내는 프로그램을 만들고 있다고 상상해 봅시다. 서버에 연결을 맺는 과정은 컴퓨터 입장에서 꽤 힘든(비용이 많이 드는) 작업입니다. 그래서 데이터를 매번 찔끔찔끔 보내기보다는, 한 번에 모아두었다가 왕창 보내고 싶을 겁니다. 이런 역할을 하는 클래스는 아마 아래 코드처럼 생겼을 거예요.

// 이 예제는 (의도적으로) 불완전하기 때문에 컴파일되지 않습니다.
class NetworkData
{
private:
    std::string m_serverName{};
    DataStore m_dataQueue{};

public:
    NetworkData(std::string_view serverName)
        : m_serverName { serverName }
    {
    }

    void addData(std::string_view data)
    {
        m_dataQueue.add(data);
    }

    void sendData()
    {
        // 서버에 연결
        // 모든 데이터 전송
        // 데이터 비우기
    }
};

int main()
{
    NetworkData n("someipAddress");

    n.addData("somedata1");
    n.addData("somedata2");

    n.sendData();

    return 0;
}

하지만 이 NetworkData 클래스에는 잠재적인 폭탄이 하나 숨어 있습니다. 바로 프로그램이 종료되기 전에 무조건 sendData() 함수를 '직접' 호출해 주어야 한다는 점입니다. 만약 이 클래스를 사용하는 사람이 깜빡 잊고 함수 호출을 안 하면, 데이터는 서버로 가지 못하고 프로그램이 꺼질 때 그대로 허공으로 날아가 버립니다.

"에이, 저렇게 뻔히 보이는데 함수 부르는 걸 잊어버리겠어?" 라고 생각하실 수도 있습니다. 네, 이 짧은 예제에서는 맞습니다. 하지만 아래 함수처럼 상황이 조금만 더 복잡해진다면 어떨까요?

bool someFunction()
{
    NetworkData n("someipAddress");

    n.addData("somedata1");
    n.addData("somedata2");

    if (someCondition)
        return false;

    n.sendData();
    return true;
}

이 코드를 볼까요? 만약 someCondition 이라는 조건이 참(true)이라면, 중간에 있는 return false;를 만나 함수가 일찍 끝나버립니다! 즉, 맨 밑에 있는 n.sendData(); 는 영영 실행되지 못하는 것이죠. 코드는 멀쩡히 잘 적혀 있지만, 특정 상황에서는 데이터 전송이 누락되어 버립니다. 프로그래밍을 하다 보면 이런 실수는 정말 흔하게 일어납니다.

이 문제를 좀 더 크게 바라봅시다. 메모리, 파일, 데이터베이스, 네트워크 연결 같은 자원(Resource) 을 사용하는 클래스들은, 객체(클래스로 만든 결과물)가 다 쓰이고 파괴되기 전에 반드시 문을 닫거나 전송을 마치는 등의 '정리' 작업이 필요합니다. 때로는 객체가 사라지기 전에 로그 파일에 기록을 남기거나, 서버에 정보를 보내야 할 수도 있죠.

이처럼 객체가 사라지기 전에 프로그램이 정상적으로 돌아가게 하려고 꼭 거쳐야 하는 모든 뒷수습 작업을 묶어서 정리(Clean up) 라고 부릅니다. 만약 이 중요한 뒷정리를 사용하는 사람(프로그래머)의 기억력에만 의존해서 직접 함수를 부르게 만든다면, 언젠가는 반드시 버그가 터지게 되어 있습니다.

그런데 애초에 왜 이걸 사람이 일일이 신경 써야 할까요? 객체가 수명을 다해 파괴될 때가 되었다면, "아, 이제 끝났으니 내가 알아서 뒷정리해야지!" 하고 자동으로 실행되게 할 수는 없을까요?

소멸자가 해결해 드립니다! 이전 강의인 '14.9 — 생성자 소개'에서 생성자(Constructor) 에 대해 배웠습니다. 생성자는 객체가 처음 태어날 때(만들어질 때) 자동으로 불려 와서 기초 설정을 해주는 특별한 함수죠.

이와 아주 비슷하게, 클래스에는 객체가 '파괴되어 사라질 때' 알아서 자동으로 호출되는 또 다른 특별한 함수가 있습니다. 이것을 바로 소멸자(Destructor) 라고 부릅니다. 소멸자 는 객체가 완전히 사라지기 직전에 필요한 모든 청소와 뒷정리를 스스로 하도록 설계되었습니다. (생성자가 '탄생'이라면 소멸자는 '죽음'을 담당한다고 보시면 됩니다!)

소멸자 이름 짓는 법 생성자처럼, 소멸자도 이름을 짓는 엄격한 규칙이 있습니다:

• 소멸자의 이름은 클래스 이름과 완전히 똑같아야 하며, 맨 앞에 물결표(~)를 붙여야 합니다.
• 소멸자는 어떤 값(인수)도 전달받을 수 없습니다. (괄호 안이 비어있어야 합니다.)
• 소멸자는 반환 타입(return type)이 아예 없습니다.
• 하나의 클래스에는 단 하나의 소멸자만 만들 수 있습니다.

또한, 소멸자를 코드에서 여러분이 '직접' 부르시면 안 됩니다. 객체가 파괴될 때 어차피 컴퓨터가 알아서 자동으로 불러주기 때문입니다. 굳이 똑같은 뒷정리를 두 번 할 필요는 없으니까요.

참고로, 소멸자 안에서 클래스의 다른 함수를 부르는 것은 아주 안전합니다. 소멸자 코드가 끝날 때까지는 객체가 아직 완전히 파괴된 것이 아니기 때문입니다.

소멸자 예제 코드로 직접 확인해 볼까요?

#include <iostream>

class Simple
{
private:
    int m_id {};

public:
    Simple(int id)
        : m_id { id }
    {
        std::cout << "Constructing Simple " << m_id << '\n';
    }

    ~Simple() // 여기가 우리의 소멸자입니다
    {
        std::cout << "Destructing Simple " << m_id << '\n';
    }

    int getID() const { return m_id; }
};

int main()
{
    // Simple 객체 할당
    Simple simple1{ 1 };
    {
        Simple simple2{ 2 };
    } // simple2는 여기서 사라집니다

    return 0;
} // simple1은 여기서 사라집니다

이 프로그램을 실행하면 다음과 같은 결과가 나옵니다:

Constructing Simple 1
Constructing Simple 2
Destructing Simple 2
Destructing Simple 1

결과를 잘 보세요. 각 Simple 객체가 파괴될 때 자동으로 소멸자가 불려 와서 메시지를 찍습니다. 눈여겨볼 점은 "Destructing Simple 2"가 1번보다 먼저 출력된다는 점입니다! 왜 그럴까요? simple2는 자기를 감싸고 있는 안쪽 중괄호 { } 가 끝나는 순간 수명을 다해 먼저 파괴되기 때문입니다. 반면에 simple1은 main() 함수가 완전히 끝날 때까지 살아있다가 제일 마지막에 파괴됩니다.

(기억해 두세요: 전역 변수나 정적 지역 변수 같은 정적 변수들은 프로그램이 켜질 때 만들어지고, 프로그램이 완전히 꺼질 때 파괴됩니다.)

NetworkData 프로그램 개선하기 자, 이제 강의 맨 처음에 봤던 골칫거리 코드로 돌아가 봅시다. 사용자가 까먹고 sendData() 를 안 부를까 봐 조마조마했던 부분을 소멸자로 시원하게 고쳐보겠습니다!

class NetworkData
{
private:
    std::string m_serverName{};
    DataStore m_dataQueue{};

public:
    NetworkData(std::string_view serverName)
        : m_serverName { serverName }
    {
    }

    ~NetworkData()
    {
        sendData(); // 객체가 파괴되기 전에 모든 데이터가 전송되도록 보장합니다
    }

    void addData(std::string_view data)
    {
        m_dataQueue.add(data);
    }

    void sendData()
    {
        // 서버에 연결
        // 모든 데이터 전송
        // 데이터 비우기
    }
};

int main()
{
    NetworkData n("someipAddress");

    n.addData("somedata1");
    n.addData("somedata2");

    return 0;
}

이제 NetworkData 안에 소멸자가 생겼습니다! 덕분에 객체가 파괴되기 직전에, 자기가 가지고 있던 모든 데이터를 '무조건' 서버로 알아서 보내고 깔끔하게 생을 마감할 것입니다. 마무리 정리가 100% 자동으로 이루어지니, 여러분은 신경 쓸 일도 줄어들고 오류가 날 확률도 획기적으로 낮아졌습니다.

암시적 소멸자 (자동 생성 소멸자) 만약 프로그래머가 클래스를 만들면서 소멸자를 깜빡하고(혹은 안 필요해서) 안 만들면 어떻게 될까요? C++ 컴파일러가 알아서 아무 내용도 없는 텅 빈 소멸자를 몰래 하나 만들어 줍니다. 이것을 암시적 소멸자(Implicit destructor) 라고 부르며, 그냥 자리만 차지하는 가짜 소멸자라고 생각하시면 됩니다.

만약 여러분이 만든 클래스가 파괴될 때 딱히 특별하게 청소할 거리가 없다면, 굳이 소멸자를 안 만드셔도 전혀 문제없습니다. 컴파일러가 알아서 빈 소멸자를 만들도록 내버려 두면 되니까요.

std::exit() 함수에 대한 경고 이전 강의인 '8.12 — 프로그램 일찍 종료하기'에서 std::exit() 라는 함수를 배웠습니다. 이 함수는 프로그램을 그 즉시 강제로 확 꺼버리는 기능이 있습니다. 문제는 프로그램이 이렇게 비상 종료될 때는, 사용 중이던 지역 변수들이 정상적인 파괴 과정을 거치지 못한다는 점입니다. 즉, 소멸자 가 호출되지 않고 그냥 날아가 버립니다! 만약 소멸자가 파일 저장 등 아주 중요한 뒷정리를 하도록 믿고 맡겨두셨다면, 이런 상황에서는 뒤통수를 맞을 수 있으니 꼭 주의해야 합니다.

고급 독자를 위한 정보 처리되지 않은 예외(Unhandled exceptions)로 인해 프로그램이 터져서 죽어버릴 때도 마찬가지입니다. 이때도 스택 풀기(Stack unwinding, 함수 호출 기록을 거꾸로 되짚어 가며 정리하는 과정)가 일어나지 않는다면, 프로그램 종료 전에 소멸자가 호출되지 않을 수 있습니다.

15.6 — 정적 멤버 변수

이전 레슨인 7.4 (전역 변수 소개)와 7.11 (정적 지역 변수)에서 우리는 전역 변수와 정적 지역 변수에 대해 배웠습니다. 이 두 종류의 변수는 모두 정적 지속 시간을 가집니다. 즉, 프로그램이 시작될 때 딱 만들어져서, 프로그램이 완전히 끝날 때 파괴된다는 뜻이에요. 이런 변수들은 자신이 속한 영역(스코프)을 벗어나더라도 자신의 값을 그대로 기억하고 유지한답니다.

예를 들어볼게요.

#include <iostream>

int generateID()
{
    static int s_id{ 0 }; // 정적 지역 변수 (static local variable)
    return ++s_id;
}

int main()
{
    std::cout << generateID() << '\n';
    std::cout << generateID() << '\n';
    std::cout << generateID() << '\n';

    return 0;
}

이 프로그램을 실행하면 화면에 이렇게 나옵니다:

1
2
3

여기서 정적 지역 변수인 s_id가 함수가 여러 번 호출되는 동안에도 초기화되지 않고 자신의 값을 계속 유지하고 있다는 점을 주목해 주세요.

클래스(Class)를 사용하면 이 static (정적) 키워드를 쓸 수 있는 곳이 두 군데 더 생깁니다. 바로 정적 멤버 변수 와 정적 멤버 함수 입니다. 다행히도 이 개념들은 꽤 직관적이고 이해하기 쉬워요. 이번 레슨에서는 정적 멤버 변수에 대해 알아보고, 다음 레슨에서 정적 멤버 함수를 다루겠습니다.

정적 멤버 변수

static 키워드를 멤버 변수에 어떻게 쓰는지 알아보기 전에, 먼저 아주 평범한 아래의 클래스를 살펴볼게요.

#include <iostream>

struct Something
{
    int value{ 1 };
};

int main()
{
    Something first{};
    Something second{};

    first.value = 2;

    std::cout << first.value << '\n';
    std::cout << second.value << '\n';

    return 0;
}

우리가 클래스로 객체(Object)를 만들 때, 각각의 객체는 자신만의 '일반 멤버 변수' 복사본을 가집니다. 마치 각자 개인 수첩을 하나씩 나눠 갖는 것과 같아요. 위 코드에서는 Something 클래스 객체를 두 개(first와 second) 만들었기 때문에, value라는 변수도 first.value와 second.value 두 개가 생깁니다. 이 둘은 완전히 서로 다른 변수예요.

그래서 위 프로그램의 결과는 다음과 같습니다:

2
1

하지만 static 키워드를 사용하면 멤버 변수를 '정적'으로 만들 수 있습니다. 개인 수첩을 갖는 일반 변수와 달리, 정적 멤버 변수 는 클래스로 만든 모든 객체들이 다 함께 사용하는 '공유 칠판' 같은 역할을 합니다.

위의 코드와 비슷하지만 static이 들어간 아래 프로그램을 살펴볼까요?

#include <iostream>

struct Something
{
    static int s_value; // s_value를 static으로 선언합니다 (초기화는 아래로 이동됨)
};

int Something::s_value{ 1 }; // s_value를 정의하고 1로 초기화합니다 (이 부분은 아래에서 다룰게요)

int main()
{
    Something first{};
    Something second{};

    first.s_value = 2;

    std::cout << first.s_value << '\n';
    std::cout << second.s_value << '\n';

    return 0;
}

이 프로그램의 결과는 다음과 같습니다:

2
2

s_value가 정적 멤버 변수이기 때문에, 클래스의 모든 객체가 이 변수를 공유합니다. 즉, first.s_value와 second.s_value는 사실 똑같은 하나의 변수를 가리키고 있는 거예요! 위 코드를 보면 first를 이용해 값을 2로 바꿨는데, second를 이용해서도 그 바뀐 값(2)을 똑같이 확인할 수 있습니다.

정적 멤버는 특정 객체에 묶여있지 않습니다

위의 예제처럼 객체(first나 second)를 통해서 정적 멤버에 접근할 수도 있지만, 사실 정적 멤버 는 객체를 단 하나도 만들지 않은 상태에서도 이미 존재합니다! 가만히 생각해 보면 당연한 일이에요. 정적 변수들은 프로그램이 시작될 때 만들어지고 끝날 때 파괴되기 때문에, 일반 멤버 변수들처럼 특정 객체가 만들어지고 사라지는 타이밍에 얽매이지 않거든요.

쉽게 말해, 정적 멤버는 클래스라는 울타리 안에 살고 있는 전역 변수 라고 생각하시면 됩니다. 클래스 안에 있는 정적 멤버나, 네임스페이스(namespace) 안에 있는 일반 변수나 사실상 거의 차이가 없어요.

핵심 포인트 정적 멤버는 클래스의 범위(Scope) 안에 존재하는 전역 변수입니다.

s_value라는 정적 멤버 변수는 특정 객체와 상관없이 독립적으로 존재하기 때문에, 클래스 이름과 범위 지정 연산자(::)를 사용해서 직접 접근할 수 있습니다. (예: Something::s_value)

class Something
{
public:
    static int s_value; // s_value를 static으로 선언합니다
};

int Something::s_value{ 1 }; // s_value를 정의하고 1로 초기화합니다 (이 부분은 아래에서 다룰게요)

int main()
{
    // 주의: 우리는 Something 타입의 객체를 전혀 만들지 않았습니다!

    Something::s_value = 2;
    std::cout << Something::s_value << '\n';
    return 0;
}

위 코드에서는 객체를 통하지 않고 클래스 이름인 Something을 이용해 s_value를 사용했습니다. 우리가 Something 객체를 단 하나도 만들지 않았는데도 Something::s_value를 사용하고 값을 바꿀 수 있죠? 정적 멤버를 사용할 때는 이렇게 클래스 이름을 통해 접근하는 것이 가장 좋은 방법입니다.

모범 사례 정적 멤버에 접근할 때는 항상 클래스 이름과 범위 지정 연산자(::)를 사용하세요. (예: Something::s_value)

정적 멤버 변수 정의하고 초기화하기

클래스 안에서 정적 멤버 변수를 선언(static int s_value;)하는 것은 컴퓨터에게 "이런 정적 변수가 존재할 거야~"라고 알려주는 역할만 할 뿐, 실제로 변수를 만들어내는(정의하는) 것은 아닙니다. 정적 멤버 변수는 사실상 전역 변수와 같기 때문에, 반드시 클래스 밖(전역 범위)에서 명시적으로 정의를 해주고 값을 초기화해 주어야 합니다.

위 예제에서는 이 코드가 그 역할을 했죠:

int Something::s_value{ 1 }; // s_value를 정의하고 1로 초기화합니다

이 한 줄의 코드는 두 가지 역할을 합니다. 전역 변수처럼 정적 멤버 변수를 실제로 만들어내고, 거기에 1이라는 초기값을 넣어주는 거죠. 만약 초기값을 따로 주지 않으면 기본적으로 0으로 채워집니다.

참고로 이렇게 밖에서 정의할 때는 접근 제어자(private, protected 등)의 영향을 받지 않습니다. 클래스 안에서 private으로 숨겨놨더라도, 밖에서 정의하고 초기화하는 것은 문제가 안 돼요. (정의하는 행위 자체는 접근으로 치지 않거든요.)

클래스 안에서 정적 멤버 변수 초기화하기 (지름길)

항상 클래스 밖에서 초기화해야 한다면 귀찮겠죠? 몇 가지 예외적인 지름길이 있습니다. 첫 번째로, 정적 멤버가 상수 정수형 (여기엔 char나 bool도 포함돼요)이거나 const enum일 때는 클래스 안에서 바로 초기화할 수 있습니다.

class Whatever
{
public:
    static const int s_value{ 4 }; // static const int는 클래스 안에서 바로 정의하고 초기화할 수 있습니다
};

또한 C++17부터는 inline이라는 마법의 키워드를 사용할 수 있습니다. inline 변수를 사용하면 상수인지 아닌지에 상관없이 클래스 안에서 곧바로 초기화할 수 있어서 아주 편리합니다. 최근에는 이 방법이 가장 권장됩니다.

class Whatever
{
public:
    static inline int s_value{ 4 }; // static inline 변수는 바로 정의하고 초기화할 수 있습니다
};

constexpr 멤버는 C++17부터 자동으로 inline 취급을 받기 때문에, 굳이 inline이라고 쓰지 않아도 클래스 내부에서 초기화가 가능합니다.

#include <string_view>

class Whatever
{
public:
    static constexpr double s_value{ 2.2 }; // 문제 없음!
    static constexpr std::string_view s_view{ "Hello" }; // constexpr 초기화를 지원하는 클래스에서도 잘 작동합니다
};

모범 사례 정적 멤버 변수는 inline이나 constexpr로 만들어서 클래스 내부에서 깔끔하게 초기화하는 것을 추천합니다.

정적 멤버 변수는 언제 쓸까요? (예제)

그렇다면 클래스 안에 정적 변수를 왜 쓸까요? 가장 대표적인 쓰임새는 클래스로 찍어내는 모든 객체들에게 고유한 ID 번호 를 부여할 때입니다.

#include <iostream>

class Something
{
private:
    static inline int s_idGenerator { 1 };
    int m_id {};

public:
    // id 생성기에서 다음 값을 가져옵니다
    Something() : m_id { s_idGenerator++ }
    {
    }

    int getID() const { return m_id; }
};

int main()
{
    Something first{};
    Something second{};
    Something third{};

    std::cout << first.getID() << '\n';
    std::cout << second.getID() << '\n';
    std::cout << third.getID() << '\n';
    return 0;
}

결과는 다음과 같습니다:

1
2
3

s_idGenerator는 모든 Something 객체가 공유하는 정적 변수입니다. 새로운 객체가 만들어질 때마다 생성자가 이 값을 객체의 개인 ID(m_id)로 저장하고, 다음 객체를 위해 공유 값인 s_idGenerator를 1 증가시킵니다. 이렇게 하면 새로 생겨나는 모든 객체들이 절대 겹치지 않는 자신만의 고유한 ID를 가질 수 있게 되죠!

정적 멤버 변수는 조회 테이블 을 만들 때도 매우 유용합니다. 복잡한 계산 값을 미리 배열에 저장해 두고 필요할 때마다 꺼내 쓴다고 가정해 보세요. 이 배열을 일반 멤버로 만들면 객체를 100개 만들 때 배열도 100개가 생겨서 메모리 낭비가 심해집니다. 하지만 정적(static) 멤버로 만들면, 객체가 몇 개든 상관없이 배열은 딱 1개만 존재해서 모든 객체가 공유하므로 메모리를 크게 아낄 수 있습니다.

오직 정적 멤버만 타입 추론(auto 와 CTAD)을 쓸 수 있습니다

C++에는 타입을 알아서 맞춰주는 편리한 기능인 auto나, 템플릿 타입을 유추해 주는 CTAD라는 기능이 있습니다. 초보자분들은 "아, 편한 기능이구나" 정도로만 아셔도 충분해요! 중요한 건, 이런 편리한 타입 추론 기능은 오직 정적 멤버에만 쓸 수 있고 일반(비정적) 멤버에는 쓸 수 없다는 점입니다.

왜 그런지 깊게 들어가면 많이 복잡해지지만, 간단히 말해 일반 멤버에 이 기능을 허용하면 컴퓨터가 너무 헷갈려 하는 상황이 발생하기 때문입니다. 반면 정적 멤버는 규칙이 단순해서 헷갈릴 일이 없거든요.

#include <utility> // std::pair<T, U>를 사용하기 위해 필요합니다

class Foo
{
private:
    auto m_x { 5 };           // 에러: 일반(비정적) 멤버는 auto를 쓸 수 없습니다
    std::pair m_v { 1, 2.3 }; // 에러: 일반 멤버는 CTAD를 쓸 수 없습니다

    static inline auto s_x { 5 };           // 성공: 정적 멤버는 auto를 쓸 수 있습니다
    static inline std::pair s_v { 1, 2.3 }; // 성공: 정적 멤버는 CTAD를 쓸 수 있습니다

public:
    Foo() {};
};

int main()
{
    Foo foo{};

    return 0;
}

15.7 — 정적 멤버 함수

이전 학습인 '15.6 - 정적(Static) 멤버 변수'에서, 정적 멤버 변수는 특정 '객체(붕어빵)'가 아니라 '클래스(붕어빵 틀)' 자체에 속한다는 걸 배웠어요. 만약 이 정적 변수가 공개(public)되어 있다면, 클래스 이름과 범위 지정 연산자(::)를 써서 바로 꺼내 쓸 수 있습니다.

#include <iostream>

class Something
{
public:
    static inline int s_value { 1 };
};

int main()
{
    std::cout << Something::s_value; // s_value는 public이므로 직접 접근할 수 있어요!
}

하지만 정적 멤버 변수가 비공개(private)라면 어떨까요? 다음 예시를 볼까요?

#include <iostream>

class Something
{
private: // 이제 private입니다!
    static inline int s_value { 1 };
};

int main()
{
    std::cout << Something::s_value; // 오류: s_value는 private이라서 클래스 밖에서 직접 접근할 수 없어요.
}

이런 경우에는 s_value가 private이기 때문에 main() 함수에서 직접 가져다 쓸 수 없어요. 보통 우리는 private 변수를 꺼내 올 때 public 함수를 사용하죠. 그래서 s_value를 꺼내기 위한 평범한 public 함수를 만들 수는 있겠지만, 그렇게 되면 그 함수를 쓰기 위해 굳이 객체(붕어빵) 를 하나 새로 만들어야 하는 번거로움이 생깁니다!

#include <iostream>

class Something
{
private:
    static inline int s_value { 1 };

public:
    int getValue() { return s_value; }
};

int main()
{
    Something s{};
    std::cout << s.getValue(); // 작동은 하지만, getValue()를 호출하려면 굳이 객체를 만들어야 해요.
}

우리는 더 똑똑한 방법을 쓸 수 있습니다.

정적 멤버 함수

변수에만 static을 붙일 수 있는 게 아니에요. 함수에도 똑같이 붙일 수 있답니다. 방금 본 예시에 정적 멤버 함수를 적용해 볼게요.

#include <iostream>

class Something
{
private:
    static inline int s_value { 1 };

public:
    static int getValue() { return s_value; } // 정적 멤버 함수
};

int main()
{
    std::cout << Something::getValue() << '\n';
}

정적 멤버 함수는 특정 객체(붕어빵)에 묶여 있지 않아요. 그래서 굳이 객체를 만들지 않고도 클래스 이름과 :: 기호만 써서 바로 호출할 수 있답니다 (예: Something::getValue()). 정적 변수와 마찬가지로 객체를 통해서 부를 수도 있지만, 헷갈릴 수 있어서 추천하지 않아요.

정적 멤버 함수에는 this 포인터가 없어요!

정적 멤버 함수에는 꼭 기억해야 할 두 가지 흥미로운 특징이 있어요.

첫째, 정적 멤버 함수는 특정 객체에 소속된 게 아니기 때문에 this 포인터 가 없습니다! 생각해보면 당연해요. this는 보통 '지금 이 작업을 하고 있는 그 객체'를 가리키는데, 정적 함수는 애초에 객체 위에서 돌아가는 게 아니니까 this가 필요 없죠.

둘째, 정적 멤버 함수는 다른 정적 멤버(변수나 함수)에는 자유롭게 접근할 수 있지만, 일반(non-static) 멤버 에는 접근할 수 없어요. 일반 멤버는 반드시 어떤 객체 안에 존재해야 하는데, 정적 함수는 작업할 객체 자체가 없기 때문이에요!

클래스 밖에서 정적 멤버 정의하기

정적 멤버 함수도 일반 멤버 함수처럼 클래스 바깥에서 그 내용을 정의할 수 있어요. 방법은 똑같습니다.

#include <iostream>

class IDGenerator
{
private:
    static inline int s_nextID { 1 };

public:
     static int getNextID(); // 정적 함수의 선언부입니다.
};

// 여기는 클래스 밖에서 정적 함수를 정의하는 부분입니다. 여기서 static 키워드는 쓰지 않아요!
int IDGenerator::getNextID() { return s_nextID++; }

int main()
{
    for (int count{ 0 }; count < 5; ++count)
        std::cout << "The next ID is: " << IDGenerator::getNextID() << '\n';

    return 0;
}

이 프로그램의 출력 결과는 다음과 같습니다:

The next ID is: 1
The next ID is: 2
The next ID is: 3
The next ID is: 4
The next ID is: 5

이 클래스 안의 모든 데이터와 함수가 static이기 때문에, 이 기능을 쓰기 위해 굳이 객체를 만들 필요가 없다는 점을 꼭 기억하세요! 이 클래스는 정적 멤버 변수로 다음 ID 값을 기억하고, 정적 멤버 함수로 그 값을 반환하면서 숫자를 1씩 올려줍니다.

15.2 학습에서 다루었듯이, 클래스 안에서 만든 함수는 자동으로 인라인(inline) 처리가 되지만, 클래스 밖에서 정의한 함수는 그렇지 않아요. 그래서 헤더 파일 안에 클래스 밖에서 정의한 정적 멤버 함수를 넣을 때는, 여러 파일에서 불러오더라도 에러(ODR 위반)가 나지 않게 꼭 inline 키워드를 붙여주는 게 좋습니다.

모든 멤버가 정적인 클래스를 만들 때 주의할 점

모든 멤버가 static인 클래스(일명 '순수 정적 클래스')를 만들 때는 조심해야 해요. 유용할 때도 있지만, 단점도 있거든요.

첫째, 모든 정적 멤버는 딱 한 번만 만들어지기 때문에, 여러 개의 독립적인 버전을 만들 수 없어요. 예를 들어, 서로 완전히 다르게 작동하는 2개의 IDGenerator 가 필요하더라도, 순수 정적 클래스로는 불가능하죠.

둘째, 전역(Global) 변수 학습에서 배웠듯이, 전역 변수는 누군가 어디서든 값을 바꿀 수 있어서 예상치 못한 에러를 낼 수 있기 때문에 위험합니다. 순수 정적 클래스도 똑같아요. 사실상 전역 변수나 전역 함수를 모아둔 것과 비슷해서 이런 부작용을 똑같이 겪을 수 있습니다.

그래서 무작정 모든 걸 static으로 만들기보다는, 평범한 일반 클래스를 하나 만들어서 그걸 전역(Global) 객체로 하나 생성하는 방식이 더 나을 수 있어요. 그러면 필요할 때 전역 객체를 쓰면서도, 언제든 독립적인 개별 객체를 여러 개 만들어서 쓸 수 있으니까요.

순수 정적 클래스 vs 네임스페이스(Namespace)

순수 정적 클래스는 네임스페이스와 아주 비슷해요. 둘 다 그 안에서 전역적으로 쓰이는 변수나 함수를 정의할 수 있죠. 하지만 가장 큰 차이점은 클래스는 접근 제어(private, public) 가 가능하고, 네임스페이스는 그게 안 된다는 거예요.

결론적으로, 외부에서 못 보게 숨겨야 할 데이터가 있거나 접근 제어가 필요하다면 정적 클래스 를 쓰고, 그게 아니라면 네임스페이스 를 쓰는 게 좋습니다.

C++에는 정적(Static) 생성자가 없어요

일반 변수들을 생성자로 초기화하는 것처럼, 정적 변수도 '정적 생성자'로 초기화하면 좋겠다고 생각할 수 있어요. 다른 언어들에는 이런 기능이 있지만, 안타깝게도 C++에는 없습니다.

대신 정적 변수는 정의하는 순간 바로 값을 넣어(초기화) 줄 수 있어요 (심지어 private이라도 말이죠!). 위의 IDGenerator 예제에서도 그렇게 했고, 아래 다른 예시도 확인해 보세요.

#include <iostream>

struct Chars
{
    char first{};
    char second{};
    char third{};
    char fourth{};
    char fifth{};
};

struct MyClass
{
    static inline Chars s_mychars { 'a', 'e', 'i', 'o', 'u' }; // 정의하는 시점에 정적 변수를 초기화합니다.
};

int main()
{
    std::cout << MyClass::s_mychars.third; // i 출력

    return 0;
}

만약 정적 멤버 변수를 초기화하는 데 코드를 실행해야 한다면 (예: 반복문 사용 등), 조금 복잡하지만 방법이 있습니다. 가장 무난한 방법은 값을 채워주는 함수를 따로 만들어서 객체를 반환하게 한 다음, 그 값을 복사해서 넣는 거예요.

#include <iostream>

struct Chars
{
    char first{};
    char second{};
    char third{};
    char fourth{};
    char fifth{};
};

class MyClass
{
private:
    static Chars generate()
    {
        Chars c{}; // 객체를 하나 만듭니다.
        c.first = 'a'; // 원하는 대로 값을 채워 넣습니다.
        c.second = 'e';
        c.third = 'i';
        c.fourth = 'o';
        c.fifth = 'u';

        return c; // 객체를 반환합니다.
    }

public:
    static inline Chars s_mychars { generate() }; // 반환된 객체의 데이터를 s_mychars에 복사합니다.
};

int main()
{
    std::cout << MyClass::s_mychars.third; // i 출력

    return 0;
}

15.8 — 프렌드(friend) 비멤버 함수

우리는 이전 장부터 계속해서 클래스의 데이터를 보호하는 '접근 제어(public, private)'의 장점에 대해 이야기해 왔습니다. 이 기능은 누가 클래스의 데이터에 접근할 수 있는지를 관리해 주죠. private 데이터는 클래스 내부에서만 건드릴 수 있고, public 데이터는 누구나 접근할 수 있습니다. [14.6 수업 - 접근 함수]에서는 데이터를 private으로 안전하게 숨겨두고, 외부 사람들은 public 함수를 통해서만 접근하게 만드는 방식이 왜 좋은지 배웠습니다.

하지만, 가끔은 이런 룰만으로는 상황을 해결하기 어렵거나 비효율적일 때가 있습니다.

예를 들어, 어떤 데이터를 전문적으로 관리하는 '저장소(storage)' 클래스가 있다고 해볼게요. 그런데 이 데이터를 화면에 멋지게 보여주고 싶어졌습니다. 화면 출력 기능은 옵션도 많고 꽤 복잡한 작업입니다.

물론 데이터 저장 기능과 화면 출력 기능을 하나의 클래스에 다 쑤셔 넣을 수도 있겠지만, 그러면 코드가 너무 복잡하고 지저분해지겠죠. 그래서 저장소 클래스는 '저장'만 하고, 화면 출력 클래스는 '출력'만 하도록 두 개를 분리하는 것이 좋습니다. 역할 분담이 확실해지니까요! 하지만 여기서 문제가 생깁니다. 출력 클래스가 저장소 클래스의 private 데이터에 접근할 수가 없어서, 화면에 데이터를 띄우는 제 역할을 할 수 없게 되어버립니다.

또 다른 경우로, 나중에 '연산자 오버로딩'이라는 것을 배울 때 자주 겪게 될 텐데, 문법적인 이유로 클래스 안에 속한 '멤버 함수'보다 밖에 있는 '비멤버(non-member) 함수'를 쓰는 것이 더 편할 때가 있습니다. 하지만 비멤버 함수 역시 클래스의 private 데이터에는 접근할 수 없다는 똑같은 문제에 부딪히게 됩니다.

만약 우리가 쓰려는 기능에 딱 맞는 public 함수가 이미 만들어져 있다면 정말 다행입니다. 그냥 그걸 쓰면 되니까요. 하지만 그런 함수가 아예 없다면 대체 어떻게 해야 할까요?

그렇다고 다른 클래스나 비멤버 함수가 일을 할 수 있도록 클래스에 새로운 public 함수를 무작정 추가하는 것도 좋은 생각은 아닙니다. 밖에서 함부로 건드리면 안 되는 민감한 정보이거나, 잘못 사용될 위험이 있는 데이터일 수 있으니까요.

우리에게 정말 필요한 것은, "딱 내가 원하는 상대에게만 예외적으로 접근 권한을 주는 방법" 입니다.

Friendship은 마법입니다

이 문제의 완벽한 해결책이 바로 '프렌드(friend)'입니다.

클래스 안에서 friend 키워드를 사용해 선언을 해주면, 컴파일러에게 "이 함수(또는 클래스)는 내 친구야!"라고 알려줄 수 있습니다. C++에서 프렌드(friend) 란 다른 클래스의 private이나 protected 데이터에 자유롭게 접근할 수 있는 특별한 권한을 받은 클래스나 함수를 말합니다. 이 방법을 쓰면, 클래스는 안전함을 유지하면서도 내가 콕 집은 상대에게만 모든 권한을 열어줄 수 있습니다.

핵심 포인트 우정(접근 권한)은 항상 '데이터를 가진 클래스'가 직접 허락해 주는 것입니다. 접근하고 싶은 쪽에서 마음대로 친구가 될 수는 없습니다. 덕분에 클래스는 여전히 "누가 내 데이터에 접근할 수 있는지"를 완벽하게 통제할 수 있죠.

예를 들어, 아까 말한 저장소 클래스가 출력 클래스를 '친구'로 받아준다면, 출력 클래스는 저장소 클래스의 모든 데이터에 마음껏 접근할 수 있게 됩니다. 코드는 깔끔하게 분리되어 있으면서도, 화면 출력이라는 본래 역할을 무사히 해낼 수 있는 것이죠.

참고로 friend 선언은 public이나 private 같은 접근 제어 구역의 영향을 받지 않습니다. 따라서 클래스 내부의 어디에 적어두든 상관없이 똑같이 작동합니다.

프렌드가 무엇인지 알았으니, 이제 비멤버 함수, 멤버 함수, 그리고 다른 클래스에 프렌드 권한을 주는 실제 예시들을 살펴보겠습니다. 이번 수업에서는 프렌드 비멤버 함수 에 대해 알아보고, 다음 [15.9 수업]에서 프렌드 클래스와 프렌드 멤버 함수를 다루겠습니다.

프렌드 비멤버 함수

프렌드 함수 란 마치 그 클래스의 진짜 멤버인 것처럼 private 및 protected 데이터에 접근할 수 있는 함수를 말합니다. 그 외의 나머지 특징은 일반 함수와 완전히 똑같습니다.

간단한 클래스가 비멤버 함수를 친구로 만드는 예제를 살펴보겠습니다.

#include <iostream>

class Accumulator
{
private:
    int m_value { 0 };

public:
    void add(int value) { m_value += value; }

    // 비멤버 함수인 void print(const Accumulator& accumulator)를 
    // Accumulator의 친구로 만들어주는 프렌드 선언입니다.
    friend void print(const Accumulator& accumulator);
};

void print(const Accumulator& accumulator)
{
    // print() 함수는 Accumulator의 친구이기 때문에
    // Accumulator의 private 멤버에 자유롭게 접근할 수 있습니다.
    std::cout << accumulator.m_value;
}

int main()
{
    Accumulator acc{};
    acc.add(5); // accumulator에 5를 더합니다.

    print(acc); // print() 비멤버 함수를 호출합니다.

    return 0;
}

이 예제에서 우리는 Accumulator 객체를 받아 작동하는 print() 라는 비멤버 함수를 만들었습니다. print()는 Accumulator 클래스에 속한 함수가 아니기 때문에 원래대로라면 private 변수인 m_value에 접근할 수 없습니다. 하지만 Accumulator 클래스 안에서 print(const Accumulator& accumulator) 를 친구로 허락해 주었기 때문에, 이제 당당하게 접근할 수 있습니다.

주의할 점은 print() 가 비멤버 함수라는 것입니다. 클래스에 속해 있지 않기 때문에, 어떤 객체의 값을 출력할지 알 수 있도록 반드시 Accumulator 객체를 괄호 안에 직접 넣어주어야 합니다.

클래스 안에서 프렌드 비멤버 함수 정의하기

멤버 함수를 클래스 안에서 작성할 수 있는 것처럼, 프렌드 비멤버 함수도 클래스 내부에서 곧바로 작성(정의)할 수 있습니다. 다음은 Accumulator 클래스 안에서 프렌드 비멤버 함수 print() 를 작성한 예제입니다.

#include <iostream>

class Accumulator
{
private:
    int m_value { 0 };

public:
    void add(int value) { m_value += value; }

    // 클래스 내부에서 정의된 프렌드 함수는 비멤버 함수로 취급됩니다.
    friend void print(const Accumulator& accumulator)
    {
        // print()는 Accumulator의 친구이기 때문에
        // Accumulator의 private 멤버에 접근할 수 있습니다.
        std::cout << accumulator.m_value;
    }
};

int main()
{
    Accumulator acc{};
    acc.add(5); // accumulator에 5를 더합니다.

    print(acc); // print() 비멤버 함수를 호출합니다.

    return 0;
}

함수가 Accumulator 클래스 안에 쏙 들어가 있으니까 마치 멤버 함수 같아 보이시죠? 하지만 속으시면 안 됩니다! friend 로 정의되었기 때문에, 이 함수는 여전히 비멤버 함수 로 취급됩니다 (마치 클래스 밖에 적어둔 것과 똑같이 동작합니다).

문법적으로 프렌드 비멤버 함수가 더 편한 경우

수업 처음에 "멤버 함수보다 비멤버 함수를 쓰는 게 더 편할 때가 있다"고 말씀드렸었죠. 그게 어떤 경우인지 예제로 확인해 봅시다.

#include <iostream>

class Value
{
private:
    int m_value{};

public:
    explicit Value(int v): m_value { v }  { }

    bool isEqualToMember(const Value& v) const;
    friend bool isEqualToNonmember(const Value& v1, const Value& v2);
};

bool Value::isEqualToMember(const Value& v) const
{
    return m_value == v.m_value;
}

bool isEqualToNonmember(const Value& v1, const Value& v2)
{
    return v1.m_value == v2.m_value;
}

int main()
{
    Value v1 { 5 };
    Value v2 { 6 };

    std::cout << v1.isEqualToMember(v2) << '\n';
    std::cout << isEqualToNonmember(v1, v2) << '\n';

    return 0;
}

이 예제에서는 두 Value 객체의 값이 똑같은지 확인하는 두 가지 함수를 만들었습니다. isEqualToMember()는 멤버 함수이고, isEqualToNonmember()는 비멤버 함수입니다. 코드가 어떻게 다른지 집중해서 봐주세요.

멤버 함수인 isEqualToMember()를 쓸 때는 기준이 되는 객체(v1)는 숨겨져 있고, 비교할 객체(v2)만 괄호 안에 넣습니다. 그래서 코드를 읽을 때 "앞의 m_value는 숨겨진 내 거고, 뒤의 v.m_value는 괄호로 들어온 쟤 거구나" 하고 머릿속으로 한 번 정리를 해야 합니다.

반면 비멤버 함수인 isEqualToNonmember()는 두 객체를 모두 괄호 안에 나란히 넣습니다. 함수 안에서도 v1.m_value 와 v2.m_value 처럼 누구의 값인지 명확하게 이름표가 붙어 있죠. 모양이 좌우 대칭이라 훨씬 읽기 편하고 직관적입니다.

물론 v1.isEqualToMember(v2) 라고 쓰는 게 더 좋다고 생각하실 수도 있습니다. 하지만 나중에 연산자 오버로딩을 배울 때, 왜 비멤버 방식이 중요한지 이 주제가 다시 등장할 것입니다.

여러 클래스의 친구가 되기

하나의 함수가 동시에 여러 클래스의 친구가 될 수도 있습니다. 다음 예제를 볼까요?

#include <iostream>

class Humidity; // Humidity 클래스에 대한 전방 선언(forward declaration)

class Temperature
{
private:
    int m_temp { 0 };

public:
    explicit Temperature(int temp) : m_temp { temp } { }

    // 이 줄이 에러 없이 작동하려면 위에서 전방 선언을 해두어야 합니다.
    friend void printWeather(const Temperature& temperature, const Humidity& humidity); 
};

class Humidity
{
private:
    int m_humidity { 0 };

public:
    explicit Humidity(int humidity) : m_humidity { humidity } {  }

    friend void printWeather(const Temperature& temperature, const Humidity& humidity);
};

void printWeather(const Temperature& temperature, const Humidity& humidity)
{
    std::cout << "온도는 " << temperature.m_temp <<
       " 이고 습도는 " << humidity.m_humidity << " 입니다.\n";
}

int main()
{
    Humidity hum { 10 };
    Temperature temp { 12 };

    printWeather(temp, hum);

    return 0;
}

이 예제에서 주목해야 할 점은 세 가지입니다.

1. printWeather() 함수는 온도와 습도를 똑같이 중요하게 다룹니다. 따라서 어느 한 클래스에 억지로 집어넣는 것보다, 바깥에 꺼내두는 비멤버 함수 방식이 훨씬 자연스럽습니다.
2. 이 함수는 온도 클래스와 습도 클래스 모두와 친구를 맺었기 때문에, 양쪽의 private 데이터에 자유롭게 접근할 수 있습니다.
3. 코드 맨 위에 있는 class Humidity; 라는 줄을 눈여겨보세요. 이것을 전방 선언(Forward declaration) 이라고 부릅니다. 컴파일러에게 "나중에 Humidity라는 클래스가 나올 거야"라고 미리 귀띔해 주는 역할을 합니다. 이 줄이 없다면, 컴파일러는 Temperature 클래스 안에서 Humidity를 만났을 때 "이게 대체 뭐야?" 하고 에러를 뱉어낼 것입니다.

프렌드는 데이터 숨기기(은닉) 원칙을 위반하는 거 아닌가요?

아닙니다. 앞서 말씀드렸듯 프렌드 권한은 데이터를 숨긴 클래스 측에서 "내 친구니까 접근해도 좋아"라고 스스로 허락한 것입니다. 프렌드를 클래스의 능력을 함께 쓰는 '확장팩' 정도로 생각해 보세요. 클래스가 예상하고 허락한 접근이므로 원칙 위반이 아닙니다.

프렌드를 적절히 활용하면, 억지로 코드를 합치지 않아도 되기 때문에 프로그램 설계가 깔끔해지고 유지보수가 훨씬 쉬워집니다. 멤버 함수보다 비멤버 함수를 쓰는 게 구조상 더 알맞을 때도 큰 도움이 되고요.

하지만 주의할 점도 있습니다. 프렌드는 클래스의 속사정(내부 구현)을 훤히 알고 직접 접근하기 때문에, 클래스 내부 코드가 바뀌면 프렌드 함수도 덩달아 수정해야 할 확률이 높습니다. 친구가 너무 많으면 하나를 고칠 때 줄줄이 고쳐야 하는 '도미노 현상'이 일어날 수 있죠.

권장 사항 프렌드 함수를 구현할 때도, 꼭 필요한 경우가 아니라면 직접 데이터에 손대기보다는 클래스에 이미 마련된 public 함수(인터페이스)를 사용하는 것이 좋습니다. 이렇게 하면 나중에 클래스 코드가 바뀌더라도 프렌드 함수까지 뜯어고치는 불상사를 막을 수 있습니다.

프렌드 함수보다는 일반(비프렌드) 함수를 선호하세요

[14.8 수업]에서 우리는 멤버 함수보다는 비멤버 함수를 쓰는 게 좋다고 배웠습니다. 똑같은 이유로, 프렌드 함수보다는 일반(비프렌드) 함수를 쓰는 것이 더 안전하고 좋습니다.

예를 들어, 아래 코드처럼 친구가 데이터에 '직접' 접근하게 놔두면 어떻게 될까요? 나중에 변수 이름(m_value)을 살짝 바꾸기만 해도 print() 함수까지 찾아가서 고쳐야 합니다.

#include <iostream>

class Accumulator
{
private:
    int m_value { 0 }; // 만약 이 이름을 바꾼다면...

public:
    void add(int value) { m_value += value; } // 여기도 수정해야 하고...

    friend void print(const Accumulator& accumulator);
};

void print(const Accumulator& accumulator)
{
    std::cout << accumulator.m_value; // 여기도 수정해야 합니다!
}

int main()
{
    Accumulator acc{};
    acc.add(5); // accumulator에 5를 더합니다.

    print(acc); // print() 비멤버 함수를 호출합니다.

    return 0;
}

이럴 때는 아래처럼 코드를 짜는 것이 훨씬 똑똑한 방법입니다.

#include <iostream>

class Accumulator
{
private:
    int m_value { 0 };

public:
    void add(int value) { m_value += value; }
    int value() const { return m_value; } // 안전하게 값을 읽어오는 접근 함수를 추가했습니다!
};

void print(const Accumulator& accumulator) // 이제 Accumulator의 친구가 아닙니다.
{
    std::cout << accumulator.value(); // 직접 접근하는 대신 접근 함수를 사용합니다.
}

int main()
{
    Accumulator acc{};
    acc.add(5); // accumulator에 5를 더합니다.

    print(acc); // print() 비멤버 함수를 호출합니다.

    return 0;
}

두 번째 예제에서는 print() 함수가 변수를 직접 건드리지 않고, value() 라는 접근 함수를 통해 안전하게 값을 가져옵니다. 이제 Accumulator 내부 구조가 어떻게 바뀌든 print() 함수는 신경 쓸 필요가 전혀 없습니다!

** 권장 사항 ** 가능하고 합리적인 상황이라면, 함수를 프렌드로 만들기보다는 일반 함수로 구현하는 것을 우선적으로 고려하세요.

다만, 뻔한 기능이라고 해서 기존 클래스에 public 함수를 무작정 자꾸 추가하는 것은 조심해야 합니다. 코드가 지저분해지고 복잡해질 수 있거든요. 위의 Accumulator 예제처럼 누적된 값을 가져오는 단순한 접근 함수를 하나 만드는 것은 아주 훌륭한 선택입니다. 하지만 상황이 너무 복잡해서 새로운 접근 함수를 끝도 없이 만들어야 한다면, 차라리 깔끔하게 프렌드를 쓰는 편이 낫습니다.

15.9 — 프렌드 클래스와 프렌드 멤버 함수

프렌드 클래스

프렌드 클래스(Friend class) 란 다른 클래스의 숨겨진 정보(private이나 protected 멤버)에 자유롭게 접근할 수 있는 특별한 클래스입니다. 진짜 친한 친구끼리 비밀을 공유하는 것과 같다고 생각하면 이해하기 쉬울 거예요!

예제를 한번 볼까요?

#include <iostream>

class Storage
{
private:
    int m_nValue {};
    double m_dValue {};

public:
    Storage(int nValue, double dValue)
       : m_nValue { nValue }, m_dValue { dValue }
    { }

    // Display 클래스를 Storage의 프렌드(친구)로 만듭니다.
    friend class Display;
};

class Display
{
private:
    bool m_displayIntFirst {};

public:
    Display(bool displayIntFirst)
         : m_displayIntFirst { displayIntFirst }
    {
    }

    // Display가 Storage의 프렌드이기 때문에, Display는 Storage의 숨겨진(private) 멤버에 접근할 수 있습니다.
    void displayStorage(const Storage& storage)
    {
        if (m_displayIntFirst)
            std::cout << storage.m_nValue << ' ' << storage.m_dValue << '\n';
        else // double 값을 먼저 출력합니다.
            std::cout << storage.m_dValue << ' ' << storage.m_nValue << '\n';
    }

    void setDisplayIntFirst(bool b)
    {
         m_displayIntFirst = b;
    }
};

int main()
{
    Storage storage { 5, 6.7 };
    Display display { false };

    display.displayStorage(storage);

    display.setDisplayIntFirst(true);
    display.displayStorage(storage);

    return 0;
}

Display 클래스가 Storage의 친구(프렌드)이기 때문에, Display는 자기가 가진 Storage 객체의 숨겨진 정보에 얼마든지 접근할 수 있습니다. 이 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

6.7 5 5 6.7

프렌드 클래스에 대해 몇 가지 더 알아두면 좋은 점이 있어요.

첫째, Display가 Storage의 친구라고 해도, Storage 객체의 *this 포인터(자기 자신을 가리키는 포인터)에는 접근할 수 없어요. (*this는 사실 함수 매개변수처럼 숨겨져 전달되는 것이기 때문이죠.)

둘째, 프로그래밍 세계에서 우정은 일방통행 일 수 있습니다! Display가 Storage의 친구라고 해서, 반대로 Storage도 자동으로 Display의 친구가 되는 건 아니에요. 서로 친구가 되려면 양쪽 모두 서로를 프렌드로 선언해야 합니다. (글쓴이의 말: 현실의 짝사랑 같아서 조금 슬프게 들렸다면 미안해요!)

셋째, 우정은 건너뛰지 않습니다. A가 B의 친구이고, B가 C의 친구라고 해서 A와 C가 자동으로 친구가 되는 건 아니에요.

심화 내용: 우정은 상속되지도 않습니다. A가 B를 친구로 만들었다고 해서, B의 자식 클래스들까지 자동으로 A의 친구가 되지는 않아요.

프렌드 클래스를 선언하는 것은 컴파일러에게 "이런 클래스가 나중에 나올 거야"라고 미리 알려주는 전방 선언(forward declaration) 역할도 같이 합니다. 그래서 따로 미리 선언해둘 필요가 없어요. 위 예제에서 friend class Display;라고 쓴 것은 "Display를 내 친구로 할게"라는 뜻인 동시에 "Display라는 클래스가 존재해"라고 미리 알려주는 역할을 완벽하게 해냅니다.

프렌드 멤버 함수

클래스 전체를 통째로 친구로 만드는 대신, 특정 함수 딱 하나만 친구로 만들 수도 있습니다. 일반 함수를 친구로 만들 때와 방법은 비슷하지만, 대신 그 멤버 함수의 이름을 정확히 적어주면 됩니다.

하지만 막상 해보면 생각보다 조금 까다로울 수 있어요. 이전 예제를 조금 바꿔서 Display::displayStorage 함수 딱 하나만 프렌드 멤버 함수로 만들어 볼게요. 아마 처음에는 아래처럼 시도해 볼 겁니다.

#include <iostream>

class Display; // Display 클래스에 대한 전방 선언 (미리 알려줌)

class Storage
{
private:
    int m_nValue {};
    double m_dValue {};

public:
    Storage(int nValue, double dValue)
        : m_nValue { nValue }, m_dValue { dValue }
    {
    }

    // Display::displayStorage 멤버 함수를 Storage 클래스의 프렌드로 만듭니다.
    friend void Display::displayStorage(const Storage& storage); // 에러: Storage는 아직 Display 클래스의 전체 모습을 보지 못했습니다.
};

class Display
{
private:
    bool m_displayIntFirst {};

public:
    Display(bool displayIntFirst)
        : m_displayIntFirst { displayIntFirst }
    {
    }

    void displayStorage(const Storage& storage)
    {
        if (m_displayIntFirst)
            std::cout << storage.m_nValue << ' ' << storage.m_dValue << '\n';
        else // double 값을 먼저 출력합니다.
            std::cout << storage.m_dValue << ' ' << storage.m_nValue << '\n';
    }
};

int main()
{
    Storage storage { 5, 6.7 };
    Display display { false };
    display.displayStorage(storage);

    return 0;
}