항목 5: 명시적 타입 선언보다는 auto를 선호하라

1
int x1;         // 초기화 안 됨! 쓰레기값
2
auto x2;        // 에러! auto는 초기화 필수
3
auto x3 = 0;    // OK

1
std::unordered_map<std::string, std::vector<Customer>>::iterator iter
2
    = customerMap.begin();
3

4
// 눈 아프죠?

1
auto iter = customerMap.begin();
2

3
// 깔끔!

1
std::vector<int> v;
2
unsigned sz = v.size();  // 문제! size()는 std::size_t 반환
3
                         // 32비트: unsigned = size_t (OK)
4
                         // 64비트: unsigned ≠ size_t (위험!)

1
auto sz = v.size();  // 항상 올바른 타입!

1
std::unordered_map<std::string, int> m;
2

3
// 나쁜 예 - 숨은 복사 발생!
4
for (const std::pair<std::string, int>& p : m) {
5
    // 실제 타입은 std::pair<const std::string, int>
6
    // const가 빠져서 임시 객체 생성됨!
7
}
8

9
// 좋은 예 - auto 사용
10
for (const auto& p : m) {
11
    // 정확한 타입으로 추론, 복사 없음
12
}

1
// 람다는 타입을 쓸 수 없음
2
auto derefUPLess = [](const std::unique_ptr<Widget>& p1,
3
                     const std::unique_ptr<Widget>& p2) {
4
    return *p1 < *p2;
5
};
6

7
// std::function은 가능하지만...
8
std::function<bool(const std::unique_ptr<Widget>&,
9
                   const std::unique_ptr<Widget>&)>
10
    derefUPLess2 = [](const auto& p1, const auto& p2) {
11
        return *p1 < *p2;
12
    };
13
// 더 느리고, 메모리도 더 씀!

1
// 원래 코드
2
int makeValue();
3
int val = makeValue();
4

5
// 나중에 long으로 변경
6
long makeValue();
7
int val = makeValue();  // 타입 불일치! 수정 필요
8

9
// auto를 썼다면?
10
auto val = makeValue();  // 자동으로 long이 됨!

1
// 복잡한 타입
2
template<typename It>
3
void dwim(It b, It e) {
4
    while (b != e) {
5
        // 현재 요소 타입을 직접 쓰기 어려움
6
        typename std::iterator_traits<It>::value_type
7
            currValue = *b;  // 복잡함
8

9
        // auto로 간단히!
10
        auto currValue = *b;  // 간단함
11
    }
12
}

1
// 인덱스 타입 실수 방지
2
std::vector<int> v = {1, 2, 3};
3

4
// 위험: int는 음수 가능, size()는 unsigned
5
for (int i = 0; i < v.size(); ++i) { }
6

7
// 안전: 정확한 타입
8
for (auto i = 0u; i < v.size(); ++i) { }
9

10
// 더 나은 방법: range-for
11
for (auto& elem : v) { }

1
std::vector<bool> features(const Widget& w);
2

3
auto highPriority = features(w)[5];  // bool이 아님!
4
// std::vector<bool>::reference 타입 (프록시)
5

6
bool highPriority = features(w)[5];  // 명시적 변환

1
auto result = calculate();  // calculate()가 뭘 반환하지?
2

3
// 때로는 명시적이 나음
4
Money result = calculate();  // 아, 돈을 반환하는구나

1
// std::function vs auto 람다
2
auto lambda1 = [](int x) { return x * 2; };
3
std::function<int(int)> lambda2 = [](int x) { return x * 2; };
4

5
// 크기 차이
6
sizeof(lambda1);  // 1 (캡처 없는 람다)
7
sizeof(lambda2);  // 32~64 바이트 (구현에 따라)
8

9
// 호출 속도
10
lambda1(5);  // 인라인 가능
11
lambda2(5);  // 간접 호출

1
// 이전 방식
2
std::unordered_map<std::string, int>::const_iterator iter = m.cbegin();
3

4
// 현대적 방식
5
auto iter = m.cbegin();
6

7
// 둘 다 같은 일을 하지만, 어느 게 읽기 쉬운가요?