항목 6: auto가 원치 않은 타입으로 추론될 때는 명시적 타입의 초기치를 사용하라

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

3
Widget w;
4
bool highPriority = features(w)[5];  // bool 복사
5
auto highPriority2 = features(w)[5]; // bool이 아님!
6

7
// auto가 추론한 타입은?
8
// std::vector<bool>::reference (프록시 클래스!)

1
auto highPriority = features(w)[5];  // 프록시 객체
2

3
// features(w)는 임시 객체
4
// [5]는 임시 객체의 5번째 비트를 가리키는 프록시 반환
5
// 문장이 끝나면 임시 객체 소멸
6
// highPriority는 소멸된 메모리를 참조!
7

8
if (highPriority) { }  // 정의되지 않은 동작!

1
// 이름 있는 객체
2
std::string s = "hello";  // s는 이름이 있음, 계속 사용 가능
3

4
// 임시 객체
5
"world"                    // 문자열 리터럴 (임시)
6
std::string("temp")        // 임시 string 객체
7
getVector()                // 함수 반환값 (대부분 임시)
8
a + b                      // 연산 결과 (임시)

1
// 한 문장이 끝나면 임시 객체는 소멸
2
std::string s = std::string("hello") + " world";
3
//              ^^^^^^^^^^^^^^^^^^^^^ 임시 객체
4
//              문장 끝(;)에서 소멸
5

6
// 위험한 경우
7
const char* ptr = std::string("danger").c_str();
8
//                ^^^^^^^^^^^^^^^^^^^^^ 임시 객체
9
// 문장이 끝나면 임시 객체 소멸 → ptr은 댕글링 포인터!

1
// 댕글링 포인터 예시
2
int* createDangling() {
3
    int local = 42;
4
    return &local;  // 지역 변수의 주소 반환
5
}                   // 함수 끝 → local 소멸
6

7
int* ptr = createDangling();  // ptr은 소멸된 메모리를 가리킴
8
*ptr = 100;  // 정의되지 않은 동작! 프로그램 크래시 가능

1
// 일반 vector
2
std::vector<int> v1 {1, 2, 3};
3
v1[0];  // int& 반환
4

5
// vector<bool>은 특수화
6
std::vector<bool> v2 {true, false, true};
7
v2[0];  // std::vector<bool>::reference 반환 (프록시!)
8
// 이유: 메모리 절약을 위해 비트로 저장

1
Matrix sum = m1 + m2 + m3 + m4;  // 정상 작동
2

3
auto sum = m1 + m2 + m3 + m4;    // Sum<Sum<Sum<Matrix>>> 같은 타입!
4
// 표현식 템플릿 (프록시)

1
// 문제 있는 코드
2
auto highPriority = features(w)[5];  // 프록시 타입
3

4
// 해결책 1: 명시적 타입
5
bool highPriority = features(w)[5];  // 프록시 → bool 변환
6

7
// 해결책 2: static_cast
8
auto highPriority = static_cast<bool>(features(w)[5]);

1
// 프록시를 실제 타입으로 변환하는 일반 공식
2
auto variable = static_cast<ActualType>(expression_returning_proxy);
3

4
// 예시들
5
auto isReady = static_cast<bool>(features(w)[5]);
6
auto matrix = static_cast<Matrix>(m1 + m2 + m3);
7
auto value = static_cast<double>(proxy_returning_double());

1
// std::vector<bool>::operator[] 문서
2
reference operator[](size_type pos);  // reference는 프록시!
3
// 일반 vector는 T& 반환

1
template<typename T>
2
class TD;
3

4
auto result = container[0];
5
TD<decltype(result)> td;  // 컴파일 에러로 타입 확인

1
class Features {
2
    std::vector<bool> data;
3
public:
4
    bool isHighPriority() const {
5
        return static_cast<bool>(data[5]);  // 명시적 변환
6
    }
7

8
    // 또는 프록시를 피하는 방법
9
    bool operator[](size_t index) const {
10
        return data[index];  // 반환 타입이 bool이므로 자동 변환
11
    }
12
};

1
// Eigen 라이브러리 예제
2
MatrixXd m1, m2, m3;
3

4
// 잘못된 방법
5
auto result = m1 + m2 + m3;  // 표현식 템플릿 타입
6

7
// 올바른 방법들
8
MatrixXd result = m1 + m2 + m3;  // 명시적 타입
9
auto result = MatrixXd(m1 + m2 + m3);  // 명시적 생성
10
auto result = static_cast<MatrixXd>(m1 + m2 + m3);  // cast
11
auto result = (m1 + m2 + m3).eval();  // Eigen의 eval() 메서드

1
// 1. 템플릿으로 타입 안전성 확보
2
template<typename T>
3
T safe_convert(T value) { return value; }
4

5
// 2. 컴파일 타임 체크 활용
6
static_assert(sizeof(int) == 4, "int must be 32-bit");
7

8
// 3. C 스타일 캐스트 (불가피한 경우만)
9
volatile uint32_t* reg = (volatile uint32_t*)0x40000000;  // 레지스터 접근

1
// 불필요한 cast (피하세요)
2
auto x = static_cast<int>(42);  // 그냥 auto x = 42;
3

4
// 의미 있는 cast (OK)
5
auto x = static_cast<int>(3.14);  // 의도적인 소수점 제거
6
auto flag = static_cast<bool>(vec_bool[0]);  // 프록시 타입 해결

1
// 1. 타입 출력
2
std::cout << typeid(decltype(suspicious_var)).name() << '\n';
3

4
// 2. 개념(concept) 체크 (C++20)
5
static_assert(std::same_as<decltype(var), bool>);  // 실패하면 프록시
6

7
// 3. 크기 확인
8
std::cout << sizeof(suspicious_var) << '\n';
9
// bool은 1바이트, 프록시는 보통 더 큼

1
// 프록시 타입 의심될 때
2
auto suspicious = some_expression;     // 위험할 수 있음
3
auto safe = static_cast<ExpectedType>(some_expression);  // 안전
4

5
// 특히 이런 경우 조심
6
auto flag = flags[0];           // vector<bool>이면 위험
7
auto flag = bool(flags[0]);     // 안전