icon
14장 : 현대 C++ 기능

auto 키워드와 타입 추론

독자 여러분, 지금까지 C++의 기본 문법, 객체 지향, 템플릿, STL, 예외 처리 등 핵심적인 요소들을 폭넓게 학습했습니다.

이제부터는 C++11 이후 도입되어 C++ 프로그래밍을 더욱 간결하고 효율적으로 만들어주는 현대 C++ 기능들에 대해 알아보겠습니다.

이 기능들은 코딩 스타일과 생산성에 큰 변화를 가져왔습니다.

이번 장에서는 현대 C++의 가장 대표적인 기능 중 하나인 auto 키워드와 타입 추론(Type Deduction) 에 대해 자세히 살펴보겠습니다.

auto는 코드의 가독성을 높이고, 복잡한 타입 이름을 직접 명시할 필요를 없애주어 개발 생산성을 크게 향상시킵니다.

auto 키워드의 등장 배경

과거 C++98/03에서는 변수를 선언할 때 항상 해당 변수의 타입을 명시해야 했습니다.

이는 때로는 매우 길고 복잡한 타입 이름을 작성해야 하는 불편함을 초래했습니다.

C++98/03에서의 복잡한 타입 선언 예시
std::vector<std::pair<std::string, int>> my_map;
// ...
std::vector<std::pair<std::string, int>>::iterator it = my_map.begin(); // 매우 김!

이러한 문제점을 해결하기 위해 C++11에서 auto 키워드가 재도입되었습니다. (과거 C++98에서도 auto는 있었지만, 저장 기간 지정자로 사용되었고 거의 쓰이지 않아 C++11에서 의미가 변경되었습니다.)

auto 키워드를 사용하면 컴파일러가 초기화 식을 분석하여 변수의 타입을 자동으로 추론합니다.

개발자는 명시적으로 타입을 작성할 필요가 없어집니다.

auto 키워드의 기본 사용법

auto는 변수 선언 시 사용하며, 반드시 초기화 식과 함께 사용되어야 합니다.

초기화 식을 통해 컴파일러가 타입을 추론하기 때문입니다.

auto 기본 형식
auto 변수이름 = 초기화_식;
auto를 사용한 간단한 타입 추론 예시
#include <iostream>
#include <string>
#include <vector>

int main() {
    auto i = 10;            // int로 추론됨
    auto d = 3.14;          // double로 추론됨
    auto s = "Hello";       // const char*로 추론됨
    auto name = std::string("Alice"); // std::string으로 추론됨
    auto b = true;          // bool로 추론됨

    std::cout << "i: " << i << ", type: " << typeid(i).name() << std::endl;
    std::cout << "d: " << d << ", type: " << typeid(d).name() << std::endl;
    std::cout << "s: " << s << ", type: " << typeid(s).name() << std::endl;
    std::cout << "name: " << name << ", type: " << typeid(name).name() << std::endl;
    std::cout << "b: " << b << ", type: " << typeid(b).name() << std::endl;

    std::vector<int> numbers = {1, 2, 3};
    auto it = numbers.begin(); // std::vector<int>::iterator 로 추론됨
    std::cout << "*it: " << *it << ", type: " << typeid(it).name() << std::endl;

    auto& ref_i = i; // int& (참조)로 추론됨
    std::cout << "ref_i: " << ref_i << ", type: " << typeid(ref_i).name() << std::endl;

    const auto const_i = 20; // const int 로 추론됨
    std::cout << "const_i: " << const_i << ", type: " << typeid(const_i).name() << std::endl;

    return 0;
}

typeid(변수).name()은 변수의 런타임 타입 이름을 출력하는 데 사용됩니다.

컴파일러에 따라 출력되는 이름이 다를 수 있습니다 (예: int는 i, double은 d, std::string은 Ss 등으로 축약될 수 있음).

중요한 것은 컴파일러가 적절한 타입을 추론한다는 것입니다.

auto 타입 추론 규칙 (Decay Rule)

auto는 초기화 식으로부터 타입을 추론할 때, 배열이나 함수는 포인터로 '붕괴(decay)'되고, const나 volatile 같은 CV(Const/Volatile) 한정자는 기본적으로 제거됩니다.

또한 참조는 참조되는 타입으로 붕괴됩니다. 이는 함수 인자 전달 시의 타입 추론 규칙과 유사합니다.

auto 타입 추론 규칙 예시
#include <iostream>
#include <vector>
#include <typeinfo> // typeid를 위해

int main() {
    int arr[] = {1, 2, 3};
    auto a1 = arr; // int* 로 추론됨 (배열은 포인터로 붕괴)
    std::cout << "a1 type: " << typeid(a1).name() << std::endl;

    const int c_val = 100;
    auto a2 = c_val; // int 로 추론됨 (const 한정자 제거)
    std::cout << "a2 type: " << typeid(a2).name() << std::endl;

    int& ref_val = arr[0];
    auto a3 = ref_val; // int 로 추론됨 (참조는 참조되는 타입으로 붕괴)
    std::cout << "a3 type: " << typeid(a3).name() << std::endl;

    // 만약 const나 참조를 유지하고 싶다면, 명시적으로 auto& 또는 const auto&를 사용해야 합니다.
    const int c_val_2 = 200;
    const auto& a4 = c_val_2; // const int& 로 추론됨 (const와 참조 유지)
    std::cout << "a4 type: " << typeid(a4).name() << std::endl;

    return 0;
}

CV 한정자 및 참조 유지 방법

  • auto&: 참조를 유지합니다. const가 원본에 있다면 const도 유지됩니다.
    • int x = 10; auto& ref_x = x; // int&
    • const int cx = 20; auto& ref_cx = cx; // const int&
  • const auto&: const 참조를 유지합니다.
    • int x = 10; const auto& cref_x = x; // const int&
  • auto&& (Universal Reference / Forwarding Reference): C++11의 rvalue 참조와 결합되어 완벽 전달(Perfect Forwarding)에 사용됩니다. 초기화 식의 값 범주(lvalue/rvalue)에 따라 lvalue reference 또는 rvalue reference로 추론됩니다. (고급 개념)
    • int x = 10; auto&& val_x = x; // int&
    • auto&& val_r = 100; // int&&

auto의 활용 사례

auto는 코드의 가독성을 높이고 반복적인 타입 선언을 줄여주므로, 현대 C++에서 매우 광범위하게 사용됩니다.

  1. STL 반복자 선언: 가장 흔하게 사용되는 곳입니다. 복잡한 반복자 타입을 매번 작성할 필요가 없어집니다.

    STL 반복자에서 auto 사용 예시
    #include <vector>
#include <map>
#include <iostream>

int main() {
    std::vector<int> numbers = {10, 20, 30, 40, 50};
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    std::map<std::string, int> scores = {{"Alice", 90}, {"Bob", 85}};
    for (auto it = scores.begin(); it != scores.end(); ++it) {
        std::cout << it->first << ": " << it->second << std::endl;
    }
    // C++17 이후 구조적 바인딩과 함께 더욱 간결하게 사용 가능
    for (const auto& [name, score] : scores) { // for (auto& [name, score] : scores) {
        std::cout << name << " -> " << score << std::endl;
    }
    return 0;
}

  2. 람다 표현식 타입: 람다 표현식은 고유한 익명 타입을 가지므로, 람다를 변수에 저장할 때 auto가 필수적입니다.

    람다 표현식에서 auto 사용 예시
    #include <functional> // std::function을 위해 (타입 강제시)

int main() {
    auto add = [](int a, int b) { return a + b; };
    std::cout << "Sum: " << add(5, 3) << std::endl; // 출력: 8

    // std::function으로 타입을 명시할 수도 있지만, auto가 더 간결합니다.
    // std::function<int(int, int)> sub = [](int a, int b) { return a - b; };
    // std::cout << "Difference: " << sub(5, 3) << std::endl; // 출력: 2
    return 0;
}

  3. 복잡한 함수 반환 값: 반환 타입이 길거나 명확하지 않을 때 함수 반환 값을 저장하는 데 유용합니다.

    복잡한 함수 반환 값에서 auto 사용 예시
    // 함수 반환 타입 추론 (C++14)
auto create_complex_object() {
    return std::make_pair(std::string("key"), std::vector<double>{1.1, 2.2});
}

int main() {
    auto complex_obj = create_complex_object();
    std::cout << "Complex object: " << complex_obj.first << ", " << complex_obj.second[0] << std::endl;
    return 0;
}

auto 사용 시 고려사항 및 주의점

auto는 매우 유용하지만, 무분별하게 사용하면 오히려 코드의 가독성을 해치거나 잠재적인 오류를 유발할 수 있습니다.

  1. 명확성 유지:

    • 타입이 간단하고 명확한 경우에는 auto 대신 명시적인 타입을 사용하는 것이 가독성을 높일 수 있습니다.
    명확한 타입 사용 예시
    int count = 0; // auto count = 0; 보다 명확
double price = 19.99; // auto price = 19.99; 보다 명확
    • 특히 숫자 리터럴의 경우, int인지 long인지 float인지 double인지 혼동을 줄 수 있습니다.
      • auto val = 1; // int
      • auto val = 1.0; // double
      • auto val = 1.0f; // float
      • auto val = 1LL; // long long

  2. 타입 붕괴(Decay) 이해: auto가 const, 참조, 배열 등을 어떻게 처리하는지 정확히 이해해야 합니다. 의도치 않게 복사본이 생성되거나 const 한정자가 제거될 수 있습니다. 필요하다면 auto&, const auto&를 사용해야 합니다.

  3. 초기화 필수: auto 변수는 반드시 초기화되어야 합니다. 그렇지 않으면 컴파일 오류가 발생합니다.

    auto 초기화 필수 예시
    // auto x; // 오류! 초기화되지 않음
// auto y = {1, 2, 3}; // C++11에서는 std::initializer_list<int>, C++14에서는 추론 규칙 달라짐
//                     // C++17 이후는 std::initializer_list가 아니면 추론 안됨

  4. 성능 영향 없음: auto는 컴파일 시점에 타입을 결정하므로, 런타임 성능에 어떠한 영향도 주지 않습니다. 이는 단순한 문법적 편의 기능입니다.

예외 던지기

Previous Page

람다 표현식

Next Page