[모던 C++] 코드가 간결해지는 문법 4가지 — auto, decltype, nullptr, range-based for

C++를 "모던"하게 만든 4가지 문법

모던 C++는 단순히 문법 몇개가 추가된 버전이 아니다. 언어의 철학이 "더 안전하고 더 간결하며, 예측 가능한 코드"로 바뀐 전환점이었다. 그 변화의 중심에는 코드의 복잡함을 줄이고, 컴파일러가 더 많은 일들을 대신 할 수 있도록 하는 타입 추론과 반복 구조 단순화가 있다.

C++ 98/03시절에는 다음과 같은 불편함이 있었다.

• 복잡한 타입 선언
  • 예) std::vector<std::pair<int, std::string>>::iterator it;
• null포인터의 모호함
  • 예) NULL또는 0을 혼용
• 반목문에서의 반복자 관리 실수
  • 예) begin(), end()를 직접 제어

이런 문제를 해결하기 위해 도입된 것이 바로 다음의 네 가지 문법이다.

이 네 가지 문법이 바로 모던 C++의 핵심 철학을 압축적으로 보여준다고 할 수 있다. 이제부터는 각 문법이 어떻게 코드를 바꾸고 어떤 상황에서 유용한지를 하나씩 살펴볼 것이다.

타입 추론 - auto / decltype

auto와 decltype는 둘 다 타입을 추론할 때 사용하는 키워드 이지만, 그 의도와 동작 방식은 조금 다르다.

• auto: 값(Value)을 기준으로 타입을 추론한다. 즉, "이 변수에는 어떤 값이 들어왔는가?"를 보고 타입을 결정한다
• decltype: 표현식(expression)을 기준으로 타입을 추론한다. 즉 "이 식의 타입은 무엇인가"를 그대로 가져온다.

조금 햇갈릴 수도 있는데, 아래 예제를 보면 확실히 알 수 있게 된다.

auto 예제

#include <iostream>
#include <vector>

int main()
{
  auto a = 10; //int 
  auto b = 3.14; //double
  auto c "text"; // std::string
  std::vector<int> v  = {1, 2, 3};

  for(auto n : v) //int
  {
    std::cout << n << " "; // 출력: 1 2 3
  }
  
}

(위 예제의 For문은 추후 설명할 Range-Based for 루프이다.) auto는 위와 같이 새로운 변수를 선언할 때 타입을 자동으로 추론하게 된다.

auto는 코드의 가독성을 높이고, 복잡한 STL 타입 선언을 단순화할 수 있다. 다만 주의할점은, 참조를 의도할 때는 auto& 또는 const auto&를 사용해야 한다. 포인터 타입은 auto키워드가 자동으로 추론해주기 때문에 auto *를 반드시 써줄 필요는 없다. 다만, 포인터임을 명확히 표현하기 위해 의도적으로 auto *를 쓰는 것도 가능하다.

decltype 예제

int x = 10;
decltype(x) y = x;   // y는 int
decltype((x)) z = x; // z는 int&  (괄호로 인해 참조 타입)

decltype는 auto와는 다르게 이미 존재하는 변수나 표현식의 타입을 재활용 할 때 주로 사용한다. 위 예시는 auto와의 차이점을 가장 쉽게 표현하기 위해 가져온 예시이며, 실제로는 위 예시처럼 사용하는 경우는 거의 없다. 실무에서 사용할 때는 템플릿이나 커스텀 딜리터 등에서 주로 사용하는 편이다.

#include <memory>
#include <cstdio>
#include <iostream>

int main()
{
    // FILE*를 unique_ptr로 관리, fclose를 커스텀 딜리터로 지정
    // fclose 함수의 타입을 decltype로 추론함.
    std::unique_ptr<FILE, decltype(&fclose)> file(fopen("test.txt", "r"), &fclose);

    // decltype를 사용하지 않았을 경우
    // std::unique_ptr<FILE, int(*)(FILE*)> file(fopen("test.txt", "r"), &fclose);


    if (file)
    {
        char buffer[100];
        if (fgets(buffer, sizeof(buffer), file.get()))
        {
            std::cout << buffer << std::endl;
        }
    } // 스코프 종료 시 fclose 자동 호출
}

위 예제는FILE * (파일 포인터)를 unique_ptr로 생성하고, 커스텀 소멸자의 타입에 fclose함수의 타입을 decltype(&fclose)로 넣어준 예제이다. 커스텀 딜리터 같은 상황에서는 “삭제하려는 대상의 타입에 맞는 함수 포인터 타입”을 넣어주어야 하는데 이 때 decltype이 아주 유용하게 사용된다,

스마트 포인터의 커스텀 딜리터에 대해서는 아래 포스팅을 참고하면 된다.

[모던 C++ 기초] RAII와 스마트 포인터

C++에서 자원 관리는 안전성과 직결된다. 본 글에서는 RAII 개념과 스마트 포인터(unique_ptr, shared_ptr, weak_ptr)를 다루며, 예제 코드와 함께 자원을 안전하게 관리하는 모던 C++ 방식을 소개한다.

Gibeom KimGibeom Kim

안전한 Null 포인터 - nullptr

c++ 11 이전에는 포인터가 아무것도 가리키지 않음(null)을 표현하기 위해 0 또는 NULL을 사용했다. 하지만 이 방식은 정수와 포인터 간의 모호성 떄문에 종종 예기지 못한 동작을 일으켰다.

NULL과 0의 문제

#include <iostream>

void foo(int n)
{
    std::cout << "정수: " << n << "\n";
}

void foo(char *p)
{
    if (p == NULL) // 또는 nullptr
    {
        std::cout << "문자열 포인터가 null입니다.\n";
        return;
    }

    std::cout << "char*: " << p << "\n";
}

int main()
{
    foo(0);     // ⚠️ int 버전 호출
    foo(NULL);  // ⚠️ 구현에 따라 int 버전으로 해석될 수도 있음
}

NULL은 사실상 매크로로 정의된 0이기 때문에, 포인터 대신 정수로 인식되어 잘못된 오버로드가 선택되는 경우가 있었다. 위 예시 코드에서도 사실 문자열 출력하는 함수를 호출하려고 했는데, 정수를 출력하는 함수가 함께 정의되어있으면 foo(NULL)의 경우 정수가 출력되는 함수를 탈 수 있는 것이다.

nullptr의 등장

C++11에서는 이러한 혼동을 없에기 위해 전용 null 포인터 상수인 nullptr을 도입했다. nullptr은 std::nullptr이라는 독자 타입을 가지면서 정수형과는 전혀 다른 타입으로 취급된다.

예를 들어서 위 예제 코드에서 정확히 char * 함수 버전에 null pointr을 호출하고 싶으면 다음과 같이 사용하면 된다.

#include <iostream>

void foo(int n)
{
    std::cout << "정수: " << n << "\n";
}

void foo(char *p)
{
    if (p == NULL) // 또는 nullptr
    {
        std::cout << "문자열 포인터가 null입니다.\n";
        return;
    }

    std::cout << "char*: " << p << "\n";
}

int main()
{
    foo(nullptr); //char* 버전 호출
}

위 예제 코드 처럼, nullptr을 사용하면 “이건 포인터용 null이다”를 컴파일러가 명확히 구분할 수 있다.

비교와 초기화

nullptr은 모든 포인터 타입과 비교 가능하며, 포인터를 안전하게 초기화하거나 리셋할 때 사용할 수 있다.

int* p = new int(10);
delete p;
p = nullptr; // ✅ 안전하게 초기화

만약 스마트포인터를 사용한다면 reset()을 호출하거나 스코프 종료 시 자동으로 내부 포인터가 nullptr로 바뀌기 떄문에 더 안전하게 사용할 수 있다.

std::unique_ptr<int> up = std::make_unique<int>(42);
up.reset(); // 내부 delete 수행 + nullptr 설정

if (up == nullptr)
{
    std::cout << "unique_ptr safely released\n";
}

요약

더 간결해진 반복문 - Range-Based for

C++ 11 이전에는 컨테이너를 순회할 떄 반드시 반복자(Iterator)나 인덱스(index)를 직접 사용해야 했다. 이 두 가지 방식 모두 코드가 길어지고, 실수할 확률이 컸다. 예를 들어서 다음과 같다.

std::vector<int> v = {1, 2, 3, 4, 5};

// 인덱스 기반
for (auto i = 0; i < v.size(); ++i)
{
    std::cout << v[i] << " ";
}

// 반복자 기반
for (auto it = v.begin(); it != v.end(); ++it)
{
    std::cout << *it << " ";
}

Range-Based For문

이러한 단점을 보완하기 위해서 C++11부터는 Range-Based For (범위 기반 반복문)을 지원한다. 기본 문법은 다음과 같다.

for (auto 변수 : 컨테이너)
{
    // 요소에 접근
}

위와 같이 사용하면 컴파일러가 내부적으로 begin(), end()를 자동으로 호출하여 컨테이너나 배열의 모둔 요소를 순회하게 된다.

기본 순회 (복사)

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> nums = {1, 2, 3, 4, 5};

    for (auto n : nums)
    {
        std::cout << n << " ";
    }
}

컴파일러는 내부적으로 다음 코드와 유사하게 변환한다.

for (auto it = nums.begin(); it != nums.end(); ++it)
{
    auto n = *it;
}

즉, 반복자를 명시하지 않아도 컴파일러가 자동으로 처리를 해 준다.

참조값 순회

기본 auto n은 복사본을 다루므로 원본 데이터는 변하지 않는다. 원본을 수정하려면 참조 (auto &) 를 사용하면 된다.

for (auto& n : nums)
{
    n *= 2;
}

읽기 전용 순회

값을 읽기만 하고 수정하지 않을 때는 const auto&를 사용하는 것이 일반적이다. 이 방식은 불필요한 복사 비용을 피하고, 컨테이너의 원소를 참조로 읽기 전용 접근한다. 다만, 요소 크기가 작은 기본형(int, double 등) 의 경우엔 복사 비용이 거의 없기 때문에 굳이 참조를 쓸 필요 없이 단순히 const auto로 순회해도 충분하다.

for (const auto& n : big_objects)   // 큰 구조체나 문자열 → 참조 효율적
{
    std::cout << n << "\n";
}

for (const auto n : numbers)        // int, float → 복사해도 부담 없음
{
    std::cout << n << " ";
}

코드를 읽는 사람들에게 내부적으로 상태 변화가 없다는것을 명확히 할 수 있다는 점도 크게 작용하기 때문에 읽기 전용인 경우 const 또는 const & 를 사용하는것이 좋다.

구조적 바인딩 (C++17 이후)

c++ 17 부터는 std::pair 또는 std::map처럼 복합 데이터를 한 번에 분해해서 순회할 수가 있다. 사용 방법은 다음과 같다.

#include <map>
#include <string>
#include <iostream>

int main()
{
    std::map<std::string, int> scores = {{"Alice", 90}, {"Bob", 80}, {"Eve", 95}};

    for (auto [name, score] : scores)
    {
        std::cout << name << ": " << score << "\n";
    }
}

정리

마무리

C++11 이후 도입된 이 네 가지 문법(auto, decltype, nullptr, range-based for)은 단순히 “코드를 줄이기 위한 편의 문법”이 아니다. 이들은 C++의 패러다임이 변화했다는 상징적인 기능들이다 — 즉, “개발자가 모든 것을 직접 제어하던 시대”에서 “컴파일러와 언어가 개발자를 도와주는 시대”로의 전환점이다.

이 네 가지 기능이 가져온 가장 큰 변화는, “C++ 코드를 읽기 쉬운 언어로 만들었다”는 점이다.

물론, 여전히 C++은 강력하지만 복잡한 언어다. 그러나 이런 문법들을 잘 활용하면, 보다 직관적이고 안전한 현대적 코드 스타일을 만들 수 있다.