modèle Fonction problème bizzare

Question

// UsingDirective.cpp : Defines the entry point for the console application. 
    // 

    #include "stdafx.h" 
    #include <iostream> 
    using namespace std; 

    #pragma once 

    #include <type_traits> 

    #pragma region CheckForFailureSignalPolicy 
    template<class Exception> 
    struct ThrowOnFailure; 

    template<class Exception> 
    struct NullOnFailure; 

    template<template<class>class FailureSignalPolicy> 
    struct IsThrowOnFailure; 





    template<> 
    struct IsThrowOnFailure<ThrowOnFailure> 
    { 
     enum {value = 1}; 
    }; 

    template<> 
    struct IsThrowOnFailure<NullOnFailure> 
    { 
     enum {value = 0}; 
    }; 



    #pragma endregion 

     template<int v> 
    struct Int2Type 
    {}; 

    template<template<class> class FailurePolicy,class ExceptionType > 
    struct IReportFailure 
    { 
     enum {isThrowing = IsThrowOnFailure<FailurePolicy>::value}; 
    #pragma region empty 
     static auto reportFailure()-> typename std::conditional<isThrowing,void,std::nullptr_t>::type 
     { 
     return rprt_help(Int2Type<isThrowing>()); 
     } 

     static void rprt_help(Int2Type<true>) 
     { 
     throw ExceptionType(); 
     } 

     static std::nullptr_t rprt_help(Int2Type<false>) 
     { 
     return nullptr; 
     } 
    #pragma endregion 
//****************************************** 
     template<class Argument> 
     static auto reportFailure(const Argument& arg)-> typename std::conditional<isThrowing,void,std::nullptr_t>::type 
     { 
     return rprt_help(const Argument& arg,Int2Type<isThrowing>()); 
     } 

     template<class Argument> 
     static void rprt_help(const Argument& arg,Int2Type<true>) 
     { 
     throw ExceptionType(arg); 
     } 
     template<class Argument> 
     static std::nullptr_t rprt_help(const Argument& arg,Int2Type<false>) 
     { 
     return nullptr; 
     } 
    #pragma region ExceptionType 
     static auto reportFailure(const ExceptionType& ex)-> typename std::conditional<isThrowing,void,std::nullptr_t>::type 
     { 
     return rprt_help(const ExceptionType& ex,Int2Type<isThrowing>()); 
     } 

     static void rprt_help(const ExceptionType& ex,Int2Type<true>) 
     { 
     throw ExceptionType(ex); 
     } 

     static std::nullptr_t rprt_help(const ExceptionType& ex,Int2Type<false>) 
     { 
     return nullptr; 
     } 
    #pragma endregion 




    }; 

    template<template<class> class FailurePolicy, class ExceptionType> 
    struct FailureSignalPolicy 
    { 
     enum {isThrowing = IsThrowOnFailure<FailurePolicy>::value}; 


     static auto 
     signalFailure() -> typename std::conditional<IsThrowOnFailure<FailurePolicy>::value,void,std::nullptr_t>::type 

     { 
     return IReportFailure<FailurePolicy,ExceptionType>::reportFailure(); 
     } 

     static auto 
     signalFailure(const ExceptionType& ex) -> typename std::conditional<IsThrowOnFailure<FailurePolicy>::value,void,std::nullptr_t>::type 

     { 
     return IReportFailure<FailurePolicy,ExceptionType>::reportFailure(ex); 
     } 
///******************************************* 
     template<class Argument> 
     static auto 
     signalFailure(const Argument& arg) -> typename std::conditional<IsThrowOnFailure<FailurePolicy>::value,void,std::nullptr_t>::type 

     { 
     return IReportFailure<FailurePolicy,ExceptionType>::reportFailure(arg); 
     } 
    }; 

    template<class ExceptionType> 
    struct ThrowOnFailure : private FailureSignalPolicy<ThrowOnFailure,ExceptionType> 
    { 
     using FailureSignalPolicy< ::ThrowOnFailure,ExceptionType>::signalFailure; 
    }; 

    template<class ExceptionType> 
    struct NullOnFailure : private FailureSignalPolicy<NullOnFailure,ExceptionType> 
    { 
     using FailureSignalPolicy< ::NullOnFailure,ExceptionType>::signalFailure; 
    }; 


    int _tmain(int argc, _TCHAR* argv[]) 
    { 
    try 
    { 
    /*ThrowOnFailure<int>::signalFailure(); 
    NullOnFailure<int>::signalFailure();*/ 
    ThrowOnFailure<std::out_of_range>::signalFailure(1); 
    } 
    catch(...) 
    { 
    } 
    return 0; 
    } 

Essayer de compiler ce que je reçois des erreurs bizzare:
erreur 1 erreur C2143: erreur de syntaxe: manquant ')' avant 'const'
Erreur 2 Erreur C2661: « IReportFailure :: rprt_help »: fonction ne prend en surcharge 0 arguments
erreur 3 erreur C2059: erreur de syntaxe: ')

FNC problématique est marqué avec un code * ** *

Answer 1

Le corps de IReportFailure::reportFailure doit être remplacé par:

return rprt_help(arg, Int2Type<isThrowing>());