항목 2: auto의 타입 추론 규칙을 이해하라

개요

좋은 소식! auto 타입 추론은 템플릿 타입 추론과 거의 같습니다. 항목 1을 이해했다면 이미 대부분을 아는 셈이죠. 하지만 한 가지 특별한 예외가 있습니다.

auto = 템플릿 타입 추론 (거의)

auto를 사용하면 컴파일러가 템플릿처럼 타입을 추론합니다:

1
auto x = 27;        // int
2
const auto cx = x;  // const int
3
const auto& rx = x; // const int&
4

5
// 이건 마치 이런 템플릿과 같습니다:
6
template<typename T>
7
void func_for_x(T param);   // auto x = 27과 같은 추론
8

9
template<typename T>
10
void func_for_cx(const T param);  // const auto cx = x와 같은 추론
11

12
template<typename T>
13
void func_for_rx(const T& param); // const auto& rx = x와 같은 추론

auto와 템플릿의 세 가지 경우

항목 1에서 배운 세 가지 경우가 그대로 적용됩니다:

경우 1: auto에 참조나 포인터가 있을 때

1
int x = 27;
2
const int cx = x;
3
const int& rx = x;
4

5
auto& v1 = x;   // int&
6
auto& v2 = cx;  // const int&
7
auto& v3 = rx;  // const int& (rx의 참조성은 무시)
8

9
const auto& v4 = x;  // const int&
10

11
auto* v5 = &x;  // int*
12
auto* v6 = &cx; // const int*

경우 2: auto&& (보편 참조)

1
auto&& uref1 = x;   // x는 lvalue → int&
2
auto&& uref2 = cx;  // cx는 lvalue → const int&
3
auto&& uref3 = 27;  // 27은 rvalue → int&&

경우 3: auto만 (값 복사)

1
auto v1 = x;   // int (const 무시)
2
auto v2 = cx;  // int (const 무시)
3
auto v3 = rx;  // int (참조와 const 모두 무시)

특별한 예외: 중괄호 초기화

여기가 템플릿과 다른 유일한 부분입니다!

1
// C++11/14에서
2
auto x1 = 27;      // int
3
auto x2(27);       // int
4
auto x3 = {27};    // std::initializer_list<int> (!)
5
auto x4{27};       // std::initializer_list<int> (!)
6

7
// C++17부터
8
auto x3 = {27};    // std::initializer_list<int>
9
auto x4{27};       // int (바뀜!)

템플릿은 중괄호를 추론할 수 없습니다:

1
template<typename T>
2
void f(T param);
3

4
f({11, 23, 9});    // 에러! T를 추론할 수 없음
5

6
// 하지만 auto는 가능
7
auto x = {11, 23, 9};  // std::initializer_list<int>

실제 사용 시 주의사항:

1
// 실수하기 쉬운 경우
2
std::vector<int> v;
3
auto resetV = [&v](const auto& newValue) {
4
    v = newValue;  // newValue가 뭘까요?
5
};
6

7
resetV({1, 2, 3});  // 에러! auto는 중괄호 추론 불가
8

9
// 해결책: std::initializer_list를 명시
10
auto resetV = [&v](std::initializer_list<int> newValue) {
11
    v = newValue;
12
};

함수 반환 타입에서의 auto

C++14부터 함수 반환 타입에 auto를 쓸 수 있지만, 여기서는 템플릿 타입 추론을 사용합니다:

1
auto createInitList() {
2
    return {1, 2, 3};  // 에러! 중괄호 추론 불가
3
}
4

5
// 해결책: 명시적 타입
6
std::initializer_list<int> createInitList() {
7
    return {1, 2, 3};  // OK
8
}
9

10
// 또는 일반 컨테이너 사용
11
auto createVector() {
12
    return std::vector<int>{1, 2, 3};  // OK
13
}

람다에서의 auto

C++14 람다 매개변수에서도 마찬가지:

1
// C++14
2
auto lambda = [](const auto& x) { /* ... */ };
3

4
// 이건 템플릿과 같음
5
class Lambda {
6
    template<typename T>
7
    void operator()(const T& x) const { /* ... */ }
8
};
9

10
// 따라서
11
lambda({1, 2, 3});  // 에러! 중괄호 추론 불가

정리하면

auto 타입 추론 = 템플릿 타입 추론 단 하나의 예외: 중괄호 초기화는 std::initializer_list로 추론

1
// 요약
2
auto x = 27;       // int (템플릿과 같음)
3
auto y = {27};     // std::initializer_list<int> (auto만의 특별 규칙!)
4

5
template<typename T>
6
void f(T param);
7
f(27);             // T는 int
8
f({27});           // 에러! (템플릿은 중괄호 추론 불가)

실전 팁

중괄호 초기화 조심하기

1
auto x = {1};   // std::initializer_list<int> - 의도한 건가요?
2
int x = {1};    // int - 아마 이걸 원했을 듯

C++17 변경사항 인지

1
auto x{1};      // C++11/14: std::initializer_list<int>
2
                // C++17: int

함수 반환/람다는 템플릿 규칙

1
auto f() { return {1, 2, 3}; }  // 에러!
2
// 템플릿 타입 추론이므로 중괄호 불가

auto는 편리하지만 중괄호 초기화의 함정을 조심하세요!

개요