effective modern c++ 1장 항목 1입니다.

1. CHAPTER 1
EFFECTIVE MODERN C++
김지환
mastrayer@naver.com

2. CHAPTER 1. 형식 연역
DEDUCING TYPES
형식 연역 = 타입 추론(type deduction)
현대적인 C++에서는 auto, decltype, 템플릿 호출 지점에서 형식
연역이 일어난다.

3. CHAPTER 1. 형식 연역
ITEM 1 : 템플릿 형식 연역 규칙을 숙지하라
이 코드에서 컴파일러는 expr을 이용해
두가지 타입(T, param)을 추론함.
이 두 형식이 다를 경우가 많은데
const, &같은 수식어들이 붙기 때문.
타입이 추론되는 경우는 3가지가 있다.
template<typename T>
void f(const T& param);
int expr = 0;
f(expr);
// T : int
// ParamType : const int&

4. CHAPTER 1. 형식 연역
ITEM 1 : 템플릿 형식 연역 규칙을 숙지하라
1. ParamType이 참조 타입이지만 보편 참조는 아닌 경우
만일 expr이 참조 형식이면 참조 부분을 무시
expr의 타입을 ParamType에 대해 패턴 매칭으로 대응시켜 T의
타입을 결정

5. CHAPTER 1. 형식 연역
ITEM 1 : 템플릿 형식 연역 규칙을 숙지하라
template<typename T>
void f(T& param);
int x = 27;
const int cx = x;
const int& rx = x;
f(x); // T: int , param: int&
f(cx); // T: const int , param: const int&
f(rx); // T: const int , param: const int&
1. f(cx)를 보면, 객체의 const성은 T에 대해 추론된 형식의 일부가 된다.
2. f(rx)를 보면, rx는 참조 타입이지만 추론 과정에서 참조성이 무시되기 때문에 T는 비참조 타입으로 추론된다.

6. CHAPTER 1. 형식 연역
ITEM 1 : 템플릿 형식 연역 규칙을 숙지하라
template<typename T>
void f(const T& param);
int x = 27;
const int cx = x;
const int& rx = x;
f(x); // T: int , param: const int&
f(cx); // T: int , param: const int&
f(rx); // T: int , param: const int&
1. 이제는 param이 const에 대한 참조로 간주되므로, const가 T의 일부로 추론될 필요가 없다.
2. 그래서 f(cx)를 보면 T는 int로 추론되었다.
3. 마찬가지로 f(rx)도 T는 int로 추론되고 rx의 참조성은 무시된다.

7. CHAPTER 1. 형식 연역
ITEM 1 : 템플릿 형식 연역 규칙을 숙지하라
2. ParamType이 보편 참조
expr이 lvalue면 T와 param 모두 lvalue 참조로 추론된다.
expr이 rvalue면 앞서 나온, 1번 경우의 룰이 적용된다.

8. CHAPTER 1. 형식 연역
ITEM 1 : 템플릿 형식 연역 규칙을 숙지하라
template<typename T>
void f(T&& param);
int x = 27;
const int cx = x;
const int& rx = x;
f(x); // x: lvalue , T: int& , param: int&
f(cx); // cx: lvalue , T: const int& , param: const int&
f(rx); // rx: lvalue , T: const int& , param: const int&
f(27); // 27: rvalue , T: int , param: int&&
1. param의 선언은 rvalue 참조와 같은 모습이지만, expr이 lvalue이면 rvalue 참조와는 전혀 다른 방식으로 추론한다.
2. 참조 타입으로 추론되는 템플릿 T는 expr이 lvalue일 때가 유일하다.
3. expr이 lvalue일 때, param의 선언은 rvalue참조같은 모습이지만 추론된 타입은 lvalue 참조이다.

9. CHAPTER 1. 형식 연역
ITEM 1 : 템플릿 형식 연역 규칙을 숙지하라
3. ParamType이 포인터도, 참조도 아님
인수가 함수에 pass-by-value되는 상황이기 때문에
param은 새로운 객체가 된다. 그래서
‣ expr의 타입이 참조면 참조 부분은 무시함.
‣ expr의 참조성을 무시하고 expr이 const면 const도 무시함.
‣ expr이 volatile이면 volatile도 무시함.

10. CHAPTER 1. 형식 연역
ITEM 1 : 템플릿 형식 연역 규칙을 숙지하라
template<typename T>
void f(T param);
const int cx = x;
const int& rx = x;
const char* const ptr
= “Fun With pointers”; // ptr은 const 객체를 가리키는 const 포인터
f(x); // T: int , param: int
f(cx); // T: int , param: int
f(rx); // T: int , param: int
f(ptr); // param: const char* (const char * const 형식의 인수 전달)
1. param은 받는 인수들의 복사본이기 때문에 const가 무시당하는 것은 당연한 결과이다.
2. 그러나 const가 pass-by-value 매개변수에 대해서만 무시당한다.
const에 대한 참조나 포인터인 매개변수는 타입 추론 과정에서 const성이 보존된다.
3. f(ptr)을 보면, param에는 포인터를 구성하는 비트들이 복사되며 그 과정에서 ptr의 const성은 무시된다.
즉, 추론 과정에서 ptr이 가리키는 것의 const는 보존되나, ptr 자체의 const는 새 포인터 param을 생성하는 도중에
사라진다.

11. CHAPTER 1. 형식 연역
ITEM 1 : 템플릿 형식 연역 규칙을 숙지하라
4. 그 외 틈새 상황들. (대부분의 경우는 위의 3가지임)
A. 배열 인수
B. 함수 인수

12. CHAPTER 1. 형식 연역
ITEM 1 : 템플릿 형식 연역 규칙을 숙지하라
A. 배열 인수
배열과 포인터를 구분하지 않고 사용할 수 있는 경우가 있지만,
배열 형식은 포인터 형식과 다르다.
문제는 배열이 배열의 첫 원소를 가리키는 포인터로 붕괴(decay)
한다는 점이다.

13. CHAPTER 1. 형식 연역
ITEM 1 : 템플릿 형식 연역 규칙을 숙지하라
template<typename T>
void f(T param);
void f2(T& param);
void myFunc1(int param[]);
void myFunc2(int* param);
const char name[] = "J. P. Briggs"; // name: const char[13]
const char * ptrToName = name; // array decays into a pointer
f(name);
1. name( const char[13] )과 ptrToName( const char* )는 같지 않지만 배열의 붕괴때문에 잘 컴파일된다.
2. 배열 형식의 함수 매개변수는 없다. myFunc1에서 배열 선언은 myFunc2처럼 포인터 선언으로 취급된다.
3. 그래서 f(name)을 호출하면 name은 배열이지만 T는 const char* 로 추론된다.
4. 하지만 f2처럼 참조로 선언하고 f2(name)을 실행한다면 T는 실제 배열로 추론된다. 그래서 T는 const char[13]으
로, f2의 param은 const char (&)[13]으로 추론된다.

14. CHAPTER 1. 형식 연역
ITEM 1 : 템플릿 형식 연역 규칙을 숙지하라
B. 함수 인수
함수 타입도 함수 포인터로 붕괴할 수 있다. 앞의 배열 인수에서 설
명했던 것들이 함수 인수에도 적용된다.

15. CHAPTER 1. 형식 연역
ITEM 1 : 템플릿 형식 연역 규칙을 숙지하라
template<typename T>
void f1(T param); // pass-by-value
template<typename T>
void f2(T& param); // pass-by-reference
void someFunc(int, double);
f1(someFunc); // param: function pointer - void (*)(int, double)
f2(someFunc); // param: function reference - void (&)(int, double)