컴파일 타임에 함수의 반환 타입을 알아내는 방법

템플릿을 이용하여 컴파일 타임에 어떤 함수(std::function이나 람다와 같은 것들 모두 포함)의 반환 타입을 알아내고 싶으면, std::invoke_result 를 쓰면 됩니다. 그런데, 이 invoke_result는 어떤 원리로 작동하는 것일까요? 이 글에서는 std::invoke_result가 어떤 원리로 작동하는지 알아보도록 하겠습니다. 이 글을 읽으며 한 가지 주의해야 할 점은, 이 글을 작성하면서 <type_traits>(std::invoke_result의 정의가 들어있는 헤더) 헤더를 참고하지 않았기 때문에, 이 글에서 설명한 방법과 실제 std::invoke_result의 구현 방법이 다를 수 있다는 것입니다.

0. std::invoke_result

   std::invoke_result는 C++17에서 추가되었는데, 기본적인 사용 예제를 보고 넘어가도록 합시다.
   
   std::invoke_result 예제 코드 보기
   
   
   

   1. #include <type_traits> // std::invoke_result를 사용하려면 이 헤더를 포함하세요.
   2. #include <functional>
   3.  
   4.  
   5. // std::invoke_result의 첫 번째 템플릿 인자로 호출 가능 객체의 타입을 넘겨줍니다.
   6. // 두 번재 인자부터, 호출 가능 객체가 받아들이는 인자들의 타입들을 넘겨줍니다.
   7. // 그러면 std::invoke_result 내부에 using 선언된 type이 곧 반환 타입이 됩니다.
   8.  
   9. typename std::invoke_result<int(double), double>::type A = 0; // A의 타입은 int
   10.  
   11.  
   12.  
   13. // std::invoke_result는 함수 외에도 함수자나 람다에도 적용할 수 있습니다.
   14.  
   15. // 함수자의 경우
   16. typename std::invoke_result<std::function<bool()>>::type B = false; // B의 타입은 bool
   17.  
   18. // 람다의 경우
   19. auto lambda = [](int, int)->char { return '0'; };
   20. typename std::invoke_result<decltype(lambda), int, int>::type C = '0'; // C의 타입은 char
   21.  
   22.  
   23.  
   24. // 멤버 함수 포인터에 대해서도 쓸 수 있습니다.
   25. // 멤버 함수 포인터에 대해서는, 대상 객체의 타입을 두 번째 템플릿 인자로 넘겨주고,
   26. // 세 번째 인자부터 멤버 함수가 받아들이는 인자들의 타입들을 넘겨줍니다.
   27.  
   28. struct SomeClass {};
   29.  
   30. typename std::invoke_result<
   31. double(SomeClass::*)(int), SomeClass, int
   32. >::type D = 0.0; // D의 타입은 double
   33.  
   34.  
   35.  
   36. // std::invoke_result도 type_traits 헤더의 다른 녀석들 처럼
   37. // 더 사용하기 간편한 별칭 템플릿을 지원합니다.
   38. std::invoke_result_t<int(char, double), char, double> E = 0; // E의 타입은 int

   
   
   std::invoke_result 예제 코드 접기
   
   
   

1. 함수 역할을 하는 객체의 타입들

   함수 역할을 하는 객체의 타입들은 여러가지가 있습니다.
   
   
   1. 함수 타입
      함수 포인터가 아니라는 점을 주의하시기 바랍니다. 다음 예제 코드를 보세요.
      
      함수 타입 예제 코드 보기
      
      
      

      1. #include <iostream>
      2. #include <type_traits>
      3.  
      4. int main()
      5. {
      6. using FuncType = int(char, double); // 이것은 함수 타입입니다.
      7. // 함수 포인터 타입이 아닙니다.
      9. using FuncPtrType = int(*)(char, double); // 이것은 함수 포인터 타입입니다.
      10.  
      11.  
      12. // std::is_same<Type1, Type2>::value 는 Type1과 Type2가
      13. // 같은 타입이면 true, 다른 타입이면 false가 됩니다.
      14.  
      15. // 함수 타입과 함수 포인터 타입은 서로 다릅니다.
      16. std::cout
      17. << std::is_same<FuncType, FuncPtrType>::value // 출력값: 0(false)
      18. << std::endl;
      19.  
      20. // 함수 타입에 '*'를 붙여 포인터로 만들면 함수 포인터 타입과 같아집니다.
      21. std::cout
      22. << std::is_same<FuncType*, FuncPtrType>::value // 출력값: 1(true)
      23. << std::endl;
      24.  
      25. return 0;
      26. }

      
      
      함수 타입 예제 코드 접기
      
      
      예제 코드에서 볼 수 있듯, 함수 타입은 "반환타입(인자타입들)" 로 표현될 수 있습니다. 함수 타입을 함수 포인터 타입과 구분하는 이유는 "3. 함수(객체)의 타입만 알고 있는 경우" 에서 설명드리도록 하겠습니다.
   2. 함수 포인터 타입
      함수 포인터 타입은 "반환타입(*)(인자타입들)"로 표현될 수 있습니다.
   3. 함수 참조 타입
      함수 참조 타입은 "반환타입(&)(인자타입들)"로 표현될 수 있습니다.
   4. 함수 객체 타입
      operator () 연산자를 오버로딩한 클래스들을 말합니다.
   5. 표준 함수 객체 타입
      std::function 클래스 템플릿을 말합니다. 사실 이것은 바로 위의 함수 객체 타입의 일종이라고 볼 수 있습니다.
   6. 람다
      람다의 타입을 알아내려면 그 타입의 클로저가 하나 필요합니다. 람다의 타입은 "decltype(클로저)"로 표현될 수 있습니다. 람다와 클로저에 대한 자세한 설명은 Effective Modern C++의 6장을 참고하세요.
   7. 멤버 함수 포인터 타입
      멤버 함수 포인터 타입은 "반환타입(SomeType::*)(인자타입들) 한정자들" 로 표현될 수 있습니다.
   
   이 모든 것들의 반환 타입을 컴파일 타임에 알아낼 수 있는 템플릿 ReturnType(std::invoke_result와 같은 일을 함)을 구현하면서 어떤 원리로 작동하는지 알아보도록 하겠습니다.

2. decltype

   decltype은 어떤 객체(또는 변수)의 식별자로부터 그 객체의 타입을 컴파일 타임에 알아내는 역할을 합니다(decltype에 대한 자세한 설명은 Effective Modern C++의 항목 3을 참고하세요).
   
   그리고 decltype은 sizeof와 같은 어떤 특성을 가지고 있습니다. 무슨 특성인가 하면 decltype/sizeof 다음에 오는 괄호 안에 들어 있는 표현식은 런타임에 실행되지 않으면서, 컴파일 타임에 그 결과를 반환해 준다는 특성입니다(이 특성을 이용한 사례를 Modern C++ Design의 2.7 섹션에서 확인할 수 있습니다).
   
   이 특성을 활용하여 함수를 (런타임에) 호출하지 않으면서, 함수 반환값의 타입을 알아 낼 수 있습니다. 다음 예제를 보세요.
   
   decltype 예제 코드 보기
   
   
   

   1. int Function()
   2. {
   3. ...
   4. }
   5.  
   6. int main()
   7. {
   8. decltype(Function()) value = 0; // value의 타입은 int
   10. return 0;
   11. }
   12.  
   13. // 위 예제에서 Function() 이라는 표현식이 있지만 decltype 다음에 오는
   14. // 괄호 안에 위치해서, 런타임에는 Function 함수가 전혀 실행되지 않습니다.
   15.  
   16. // 그리고 decltype은 Function 함수의 반환 타입을 컴파일 타임에 정확히 파악해 줍니다.

   
   
   decltype 예제 코드 접기
   
   
   이처럼 인자를 받지 않는 함수(객체)를 가지고 있는 경우에는, decltype만 쓰면 쉽게 그 함수(객체)의 반환 타입을 알아낼 수 있습니다. 이것을 기반으로 조금씩 살을 붙여봅시다.

3. 함수(객체)의 타입만 알고 있는 경우

   바로 위에서 우리는 decltype(함수호출 표현식)을 사용하면 해당 표현식에 사용된 함수의 반환 타입을 구할 수 있다는 사실을 알았습니다. 하지만 함수(객체)를 가지고 있는 것이 아니라 함수(객체)의 타입만 가지고 있는 경우라면 어떨까요? 함수 객체의 타입만 가지고는 호출 표현식을 만들 수 없습니다. 즉, 우리가 아는 함수 객체의 타입으로부터 함수 객체를 만들어 내야 비로소 함수 호출 문장을 작성할 수 있습니다(std::less<int>()(A, B) 와 같이 기본생성자를 위한 괄호가 인자 목록과 타입 식별자 사이에 들어간다는 점을 생각해 보세요).
   
   문제는 모든 함수 객체 타입이 기본 생성자를 지원하지 않는다는 것입니다. 대표적인 예로 함수의 참조자를 들 수 있습니다(생각해 보면 당연합니다. 참조자의 기본 생성자라뇨... 아무것도 참조하지 않는 참조자를 어디다 쓴단 말입니까?). 물론 사용자가 정의한, operator ()를 오버로딩한 클래스에 기본 생성자가 없을 수도 있습니다. 이 외에도 있겠지만 굳이 전부를 언급하지는 않겠습니다.
   
   이러한 문제를 해결하는 예시를 Modern C++ Design의 2.7 섹션에서도 찾을 수 있습니다. 바로 "2. decltype"에서 언급한 decltype의 특성을 활용하는 것입니다. 다음 예제를 보세요.
   
   함수(객체)의 타입만 알고 있는 경우 예제 코드 보기
   
   
   

   1. template <typename T>
   2. T MakeT();
   3.  
   4. int main()
   5. {
   6. decltype(MakeT<int(&)()>()()) A = 0; // A의 타입은 int
   8. return 0;
   9. }
   10.  
   11. // 여기에 사용된 MakeT 함수 템플릿은 심지어 정의가 없어도 됩니다.
   12. // 왜냐하면 decltype 다음에 위치한 괄호 안의 호출문은,
   13. // 런타임에서는 무시(호출되지 않음)되기 때문입니다.
   14.  
   15. // MakeT 함수 템플릿에 템플릿 인자 타입을 넘겨주고 호출하게 되면,
   16. // 템플릿 인자로 넘겨받은 타입의 객체를 생성하여 반환하는 척(!)을 하게 됩니다.
   17.  
   18. // 따라서 MakeT 함수 템플릿에 함수 참조자 타입을 템플릿 인자로 넘겨주고
   19. // 호출하면, MakeT 함수 템플릿은 넘겨받은 함수 참조자 타입의
   20. // 객체를 반환하는 척(!)을 하게 됩니다.
   21.  
   22. // 이제 반환된 함수 참조자 타입의 객체를 호출하면,
   23. // 함수 참조자 객체가 값을 반환하는 척(!)을 합니다.
   24.  
   25. // 마지막으로 decltype이 이 값의 타입을 알려주게 되는 것이죠.
   26.  
   27. // 이 모든 과정이 컴파일 타임에 이루어지며, 다시 말하지만
   28. // 런타임에는 이런 과정들이 이루어지지 않습니다.

   
   
   함수(객체)의 타입만 알고 있는 경우 예제 코드 접기
   
   
   아직 한 가지 문제가 남아 있습니다. "1. 함수 역할을 하는 객체의 타입들"에서 함수 타입과 함수 포인터 타입이 다르다는 점을 강조했다는 사실을 기억하십니까? 다른 모든 타입들은 MakeT와 같은 함수 템플릿을 활용하는 방법이 통하지만 함수 타입에 대해서는 이 방법이 통하지 않습니다(나중에 보게 되겠지만, 멤버 함수 포인터에 대해서도 통하지 않습니다. 멤버 함수를 호출하는 문법 자체가 일반 함수를 호출하는 문법과 다르기 때문이죠).
   
   따라서 우리가 궁극적으로 만들고자 하는 ReturnType 클래스 템플릿은, 템플릿 인자로 함수 타입을 받는 경우에 대해 특수화 버전을 만들어 줘야 합니다.

4. 함수(객체)가 여러 개의 인자를 받아들이는 경우

   지금까지는 인자를 하나도 받지 않는 함수(객체)가 반환하는 값의 타입만을 구해 보았습니다. 이번에는 여러 개의, 다양한 타입의 인자를 받아들이는 함수(객체)에 대한 반환 타입을 구해 봅시다.
   
   함수를 호출하려면, 호출하려는 함수가 받아들이는 인자의 타입에 맞는 값(객체)를 넘겨줄 필요가 있습니다. 여기서도 "3. 함수(객체)의 타입만 알고 있는 경우"에서와 같이 모든 종류의 객체를, 인자를 받아들이지 않는 기본 생성자로만 생성할 수 없다는 문제에 직면하게 됩니다. 따라서 해결방법도 비슷합니다. "3. 함수(객체)의 타입만 알고 있는 경우" 에서 만들었던 MakeT 함수 템플릿을 재활용 하는 것입니다. 다음 예제 코드를 보세요.
   
   함수(객체)가 여러 개의 인자를 받아들이는 경우 예제 코드 보기
   
   
   

   1. template <typename T>
   2. T MakeT();
   3.  
   4. int main()
   5. {
   6. decltype(
   7. MakeT<int(&)(char, double)>()(
   8. MakeT<char>(),
   9. MakeT<double>()
   10. )
   11. ) A = 0; // A의 타입은 int
   13. return 0;
   14. }
   15.  
   16. // 앞의 예제와 마찬가지로 넘겨줄 인자들을 MakeT 함수 템플릿으로
   17. // 만들어낸 척(!) 을 합니다.

   
   
   함수(객체)가 여러 개의 인자를 받아들이는 경우 예제 코드 접기
   
   
   이렇게 여러 개의 인자를 받아들이는 경우, 인자들의 타입도 모두 알고 있어야 합니다. 이 때문에, std::invoke_result(우리가 만들어볼 ReturnType 클래스 템플릿도 마찬가지 입니다)는 함수 객체 타입 외에도 인자들의 타입을 별도로 받아들이는 것이죠.

5. 지금까지 알아본 것들을 하나의 클래스 템플릿으로 만들기

   지금까지 알아낸 것들을 하나의 클래스 템플릿 ReturnType으로 만들어 봅시다. 다음 예제 코드를 보세요.
   
   ReturnType 예제 코드 보기
   
   
   

   1. // 함수(객체)가 받아들이는 인자의 개수와 종류에는 제한이 없습니다.
   2. // 이런 상황에서는 가변 인자 템플릿을 사용할 수 있습니다.
   4. template <typename FuncType, typename... Args>
   5. class ReturnType
   6. {
   7. template <typename T>
   8. static T MakeT();
   10. public:
   11. using Type = decltype(MakeT<FuncType>()(MakeT<Args>()...));
   12. };
   14. // 거창하게 설명한 것과 다르게 그 결과물은 매우 간단합니다.
   15.  
   16.  
   17. // 물론 별칭 템플릿을 이용하여 좀 더 편의성을 높일 수도 있습니다.
   18. // 다음을 보세요.
   19.  
   20. template <typename... T>
   21. using ReturnType_t = typename ReturnType<T...>::Type;
   22.  
   23.  
   24. // 이제 1번처럼 쓰는 대신 2번처럼 쓸 수 있습니다.
   25.  
   26. // 1
   27. typename ReturnType<int(*)(char), char>::Type A = 0; // A 는 int
   28.  
   29. // 2
   30. ReturnType_t<int(*)(char), char> B = 0; // B 도 int

   
   
   ReturnType 예제 코드 접기
   
   
   하지만 아직 문제가 남아 있습니다. "3. 함수(객체)의 타입만 알고 있는 경우"의 마지막에 살짝 언급했던 것을 기억하십니까? MakeT 함수 템플릿을 함수 타입(함수 포인터 타입이 아님에 주의)에 적용할 수 없다는 것입니다. 그래서, 함수 타입을 위한 ReturnType의 특수화 버전을 만들어 줘야 합니다. 다음 예제를 보세요.
   
   함수 타입에 대한 ReturnType의 특수화 버전 예제 코드 보기
   
   
   

   1. ... // 이전과 같습니다.
   2.  
   3.  
   4. // 함수 타입에 대해 ReturnType을 특수화 해줍니다.
   5. template <typename R, typename... Args>
   6. class ReturnType<R(Args...), Args...>
   7. {
   8. public:
   9. using Type = R;
   10. };
   11.  
   12. // noexcept 속성을 갖는 함수 타입에 대해서도 특수화 해줍니다.
   13. template <typename R, typename... Args>
   14. class ReturnType<R(Args...) noexcept, Args...>
   15. {
   16. public:
   17. using Type = R;
   18. };

   
   
   함수 타입에 대한 ReturnType의 특수화 버전 예제 코드 접기
   
   
   

6. 멤버 함수 포인터에 대한 ReturnType의 특수화

   이제 멤버 함수 포인터를 생각해 보도록 합시다. 기존의 함수(객체)들은 호출할 때, 넘겨줄 인자들을 담는 괄호만 붙여줘서 호출을 할 수 있습니다. 하지만, 멤버 함수 포인터는 대상 객체가 필요합니다. 따라서 이 경우도 템플릿 특수화 버전을 만들어 줘야 합니다. 다음 예제를 보세요.
   
   예제 코드 보기
   
   
   

   1. ... // 이전과 같습니다.
   2.  
   3.  
   4. // 멤버 함수 포인터 타입에 대해 ReturnType을 특수화 해줍니다.
   5. template <typename R, typename C, typename... Args>
   6. class ReturnType<R(C::*)(Args...), C, Args...>
   7. {
   8. public:
   9. using Type = R;
   10. };

   
   
   예제 코드 접기
   
   
   그런데 여기서 한 가지 문제가 더 생깁니다. 바로 멤버 함수에는 한정사가 있다는 것입니다. const, volatile 뿐이라면 조금 낫겠지만, C++11부터 추가된 참조 한정사 &, &&와 noexcept 까지 고려하면 경우의 수가 매우 많아집니다. 그래서, 이 글을 쓸 때 표준 라이브러리 헤더를 열어보지 않으려고 했었는데, 결국 표준 라이브러리 헤더 파일을 열어서 이 문제를 어떻게 해결했는지 찾아봤습니다. 결론부터 말씀드리자면, 매크로 함수를 이용하여 해결을 했습니다. 표준 라이브러리에는 호출 규약 등에도 적용하여 좀 더 복잡하게 되어 있었는데 여기서는 간단하게 const, volatile과 참조 한정사, 그리고 noexcept 들에만 적용시켜 보겠습니다. 다음 예제를 보세요.
   
   멤버 함수의 한정사 해결 예제 코드 보기
   
   
   

   1. #define _MEMBER_CV(FUNC, REF_OPT, NOEXCEPT_OPT)\
   2. FUNC(, REF_OPT, NOEXCEPT_OPT)\
   3. FUNC(const, REF_OPT, NOEXCEPT_OPT)\
   4. FUNC(volatile, REF_OPT, NOEXCEPT_OPT)\
   5. FUNC(const volatile, REF_OPT, NOEXCEPT_OPT)
   6.  
   7. #define _MEMBER_CV_REF(FUNC, NOEXCEPT_OPT)\
   8. _MEMBER_CV(FUNC, , NOEXCEPT_OPT)\
   9. _MEMBER_CV(FUNC, &, NOEXCEPT_OPT)\
   10. _MEMBER_CV(FUNC, &&, NOEXCEPT_OPT)
   11.  
   12. #define _MEMBER_CV_REF_NOEXCEPT(FUNC)\
   13. _MEMBER_CV_REF(FUNC, )\
   14. _MEMBER_CV_REF(FUNC, noexcept)
   15.  
   16.  
   17. ... // 이전과 같습니다.
   18.  
   19.  
   20. // 다음을 잘 보세요.
   21. #define _MEMFUNPTR(CV_OPT, REF_OPT, NOEXCEPT_OPT)\
   22. template <typename R, typename C, typename... Args>\
   23. class ReturnType<R(C::*)(Args...) CV_OPT REF_OPT NOEXCEPT_OPT, C, Args...>\
   24. {\
   25. public:\
   26. using Type = R;\
   27. };
   28.  
   29. _MEMBER_CV_REF_NOEXCEPT(_MEMFUNPTR)
   30. #undef _MEMFUNPTR
   31.  
   32.  
   33. // 이 매크로 함수들이 풀어지면서 결국 CV 한정사, 참조 한정사, noexcept 여부에
   34. // 대한 모든 조합의 멤버 함수 포인터를 특수화 시켜 줍니다.

   
   
   멤버 함수의 한정사 해결 예제 코드 접기
   
   
   

7. 마무리

   이제 위에서 보았던 예제들을 하나로 통합해 보겠습니다.
   
   ReturnType 예제 코드 보기
   
   
   

   1. //-----------------------------------------------------------------------------
   2. // ReturnType 예제
   3.  
   4. #define _MEMBER_CV(FUNC, REF_OPT, NOEXCEPT_OPT)\
   5. FUNC(, REF_OPT, NOEXCEPT_OPT)\
   6. FUNC(const, REF_OPT, NOEXCEPT_OPT)\
   7. FUNC(volatile, REF_OPT, NOEXCEPT_OPT)\
   8. FUNC(const volatile, REF_OPT, NOEXCEPT_OPT)
   9.  
   10. #define _MEMBER_CV_REF(FUNC, NOEXCEPT_OPT)\
   11. _MEMBER_CV(FUNC, , NOEXCEPT_OPT)\
   12. _MEMBER_CV(FUNC, &, NOEXCEPT_OPT)\
   13. _MEMBER_CV(FUNC, &&, NOEXCEPT_OPT)
   14.  
   15. #define _MEMBER_CV_REF_NOEXCEPT(FUNC)\
   16. _MEMBER_CV_REF(FUNC, )\
   17. _MEMBER_CV_REF(FUNC, noexcept)
   18.  
   19.  
   20. template <typename FuncType, typename... Args>
   21. class ReturnType
   22. {
   23. template <typename T>
   24. static T MakeT();
   25.  
   26. public:
   27. using Type = decltype(MakeT<FuncType>()(MakeT<Args>()...));
   28. };
   29.  
   30. template <typename R, typename... Args>
   31. class ReturnType<R(Args...), Args...>
   32. {
   33. public:
   34. using Type = R;
   35. };
   36.  
   37. template <typename R, typename... Args>
   38. class ReturnType<R(Args...) noexcept, Args...>
   39. {
   40. public:
   41. using Type = R;
   42. };
   43.  
   44. #define _MEMFUNPTR(CV_OPT, REF_OPT, NOEXCEPT_OPT)\
   45. template <typename R, typename C, typename... Args>\
   46. class ReturnType<R(C::*)(Args...) CV_OPT REF_OPT NOEXCEPT_OPT, C, Args...>\
   47. {\
   48. public:\
   49. using Type = R;\
   50. };
   51.  
   52. _MEMBER_CV_REF_NOEXCEPT(_MEMFUNPTR)
   53. #undef _MEMFUNPTR
   54.  
   55.  
   56. template <typename... T>
   57. using ReturnType_t = typename ReturnType<T...>::Type;
   58.  
   59.  
   60.  
   61. //-----------------------------------------------------------------------------
   62. // 실제로 사용한 예를 봅시다.
   63.  
   64.  
   65. #include <iostream>
   66. #include <functional>
   67.  
   68.  
   69. // 함수 타입
   70. using FuncType = char(int);
   71.  
   72. // 함수 포인터 타입
   73. using FuncPtrType = char(*)(int);
   74.  
   75. // 함수 참조자 타입
   76. using FuncRefType = char(&)(int);
   77.  
   78. // operator () 연산자를 오버로딩한 클래스
   79. struct Less
   80. {
   81. bool operator ()(int lhs, int rhs) const {
   82. return lhs < rhs;
   83. }
   84. };
   85.  
   86. // 표준 함수자 클래스
   87. using StdFunc = std::function<double(const int&, const char*)>;
   88.  
   89. // 람다
   90. auto lambda = [](char&&, int&)->int { return 0; };
   91.  
   92. class SomeClass {};
   93.  
   94. // 멤버 함수 포인터, 어떤 한정사가 와도 된다.
   95. using MemFuncPtrType = float(SomeClass::*)(void*) const &;
   96.  
   97.  
   98. // 타입 출력 함수
   99. template <typename T>
   100. void PrintType()
   101. {
   102. std::cout << "Other type" << std::endl;
   103. }
   104.  
   105. template <>
   106. void PrintType<bool>()
   107. {
   108. std::cout << "bool type" << std::endl;
   109. }
   110.  
   111. template <>
   112. void PrintType<char>()
   113. {
   114. std::cout << "char type" << std::endl;
   115. }
   116.  
   117. template <>
   118. void PrintType<int>()
   119. {
   120. std::cout << "int type" << std::endl;
   121. }
   122.  
   123. template <>
   124. void PrintType<float>()
   125. {
   126. std::cout << "float type" << std::endl;
   127. }
   128.  
   129. template <>
   130. void PrintType<double>()
   131. {
   132. std::cout << "double type" << std::endl;
   133. }
   134.  
   135.  
   136. int main()
   137. {
   138. // 함수 타입
   139. PrintType<ReturnType_t<FuncType, int>>();
   140.  
   141. // 함수 포인터 타입
   142. PrintType<ReturnType_t<FuncPtrType, int>>();
   143.  
   144. // 함수 참조 타입
   145. PrintType<ReturnType_t<FuncRefType, int>>();
   146.  
   147. // operator () 연산자를 오버로딩한 클래스
   148. PrintType<ReturnType_t<Less, int, int>>();
   149.  
   150. // 표준 함수자 클래스
   151. PrintType<ReturnType_t<StdFunc, const int&, const char*>>();
   152.  
   153. // lambda
   154. PrintType<ReturnType_t<decltype(lambda), char&&, int&>>();
   155.  
   156. // 멤버 함수 포인터
   157. PrintType<ReturnType_t<MemFuncPtrType, SomeClass, void*>>();
   158.  
   159. return 0;
   160. }
   161.  
   162.  
   163. // ※ 실행 결과
   164. //  char type
   165. //  char type
   166. //  char type
   167. //  bool type
   168. //  double type
   169. //  int type
   170. //  float type
   171.  

   
   
   ReturnType 예제 코드 접기
   
   
   눈치채신 분들도 있겠지만 사실, 함수 타입, 함수 포인터 타입, 함수 참조자 타입, 그리고 멤버 함수 타입에 대해서는 인자들의 타입 목록을 넘겨주지 않도록 구현하는 것도 가능합니다. 다음 예제를 보세요.
   
   예제 코드 보기
   
   
   

   1. ... // 이전과 같습니다.
   4. // 함수 타입에 대한 특수화 버전
   5. template <typename R, typename... Args>
   6. class ReturnType<R(Args...)/*, Args...*/> // 인자들의 타입 목록을
   7. { // 넘겨주지 않습니다.
   8. public:
   9. using Type = R;
   10. };
   12. // noexcept 함수 타입에 대한 특수화 버전
   13. template <typename R, typename... Args>
   14. class ReturnType<R(Args...) noexcept/*, Args...*/> // noexcept 버전도 마찬가지
   15. {
   16. public:
   17. using Type = R;
   18. };
   19.  
   20. // 함수 포인터 타입에 대한 특수화 버전
   21. template <typename R, typename... Args>
   22. class ReturnType<R(*)(Args...)> // 함수 포인터 타입에 대해서도
   23. { // 특수화를 합니다.
   24. public:
   25. using Type = R;
   26. };
   28. // noexcept 함수 포인터 타입에 대한 특수화 버전
   29. template <typename R, typename... Args>
   30. class ReturnType<R(*)(Args...) noexcept> // noexcept 버전도 마찬가지
   31. {
   32. public:
   33. using Type = R;
   34. };
   36. // 함수 참조자 타입에 대한 특수화 버전
   37. template <typename R, typename... Args>
   38. class ReturnType<R(&)(Args...)> // 함수 참조자 타입에 대해서도
   39. { // 특수화를 합니다.
   40. public:
   41. using Type = R;
   42. };
   44. // noexcept 함수 참조자 타입에 대한 특수화 버전
   45. template <typename R, typename... Args>
   46. class ReturnType<R(&)(Args...) noexcept> // noexcept 버전도 마찬가지
   47. {
   48. public:
   49. using Type = R;
   50. };
   52. // 멤버 함수 포인터에 대한 특수화 버전에서도,
   53. // 대상 타입과, 인자들의 타입 목록을 넘겨주지 않습니다.
   54. #define _MEMFUNPTR(CV_OPT, REF_OPT, NOEXCEPT_OPT)\
   55. template <typename R, typename C, typename... Args>\
   56. class ReturnType<R(C::*)(Args...) CV_OPT REF_OPT NOEXCEPT_OPT/*, C, Args...*/>\
   57. {\
   58. public:\
   59. using Type = R;\
   60. };
   62. _MEMBER_CV_REF_NOEXCEPT(_MEMFUNPTR)
   63. #undef _MEMFUNPTR
   66. template <typename... T>
   67. using ReturnType_t = typename ReturnType<T...>::Type;
   71. ... // 이전과 같습니다.
   73.  
   74. int main()
   75. {
   76. // 함수 타입
   77. PrintType<ReturnType_t<FuncType/*, int*/>>(); // 인자들의 타입 목록을
   78. // 넘겨주지 않습니다.
   80. // 함수 포인터 타입
   81. PrintType<ReturnType_t<FuncPtrType/*, int*/>>(); // 인자들의 타입 목록을
   82. // 넘겨주지 않습니다.
   84. // 함수 참조 타입
   85. PrintType<ReturnType_t<FuncRefType/*, int*/>>(); // 인자들의 타입 목록을
   86. // 넘겨주지 않습니다.
   88. // operator () 연산자를 오버로딩한 클래스
   89. PrintType<ReturnType_t<Less, int, int>>();
   91. // 표준 함수자 클래스
   92. PrintType<ReturnType_t<StdFunc, const int&, const char*>>();
   94. // lambda
   95. PrintType<ReturnType_t<decltype(lambda), char&&, int&>>();
   97. // 멤버 함수 포인터 // 인자들의 타입 목록을 넘겨주지 않습니다.
   98. PrintType<ReturnType_t<MemFuncPtrType/*, SomeClass, void* */>>();
   100. return 0;
   101. }
   104. // ※ 실행 결과
   105. //  char type
   106. //  char type
   107. //  char type
   108. //  bool type
   109. //  double type
   110. //  int type
   111. //  float type

   
   
   예제 코드 접기
   
   
   이렇게 만들 수도 있는데 왜 std::invoke_result는 항상 인자들의 타입을 넘겨주게 만들었을까요? 아마도 인터페이스의 일관성을 유지하기 위해서일 것입니다. 람다나 operator ()을 오버로딩한 클래스 등과 같은 경우에는 인자들의 타입 목록을 생략할 수 있는 방법이 없기 때문이죠. 만약 함수 (포인터/참조자) 타입과 멤버 함수 포인터 타입만 특별 취급을 하게 된다면, 나중에 소스 코드에서 함수 타입을 사용하다가 그것을 람다로 바꾸었을 때 소스 코드의 많은 부분을 고치는 노동을 해야 할 수도 있습니다. 또한 템플릿 함수에 함수 객체를 넘겨줄때, 함수 (포인터/참조자) 타입에 대해서는 항상 특수화 코드를 짜 주어야 하는 번거로움도 생길 수 있겠죠. 이렇게 인터페이스에 일관성이 없으면 득보다 실이 많다고 판단되었기에, std::invoke_result는 약간의 불편을 감수하더라도 인터페이스가 일관성을 가지도록 만들었을 것입니다.