Wie kann ich (zur Kompilierzeit) feststellen, ob ein Typname ein Funktionszeiger Typname ist?

Question

Betrachten Sie die folgende Wrapper um Runtime Dynamic Linking Mechanismus Win32:

#include <boost/noncopyable.hpp> 
#include <windows.h> 
#include "Exception.hpp" 

namespace WindowsApi 
{ 
    class RuntimeDynamicLinker : boost::noncopyable 
    { 
     HMODULE hMod_; 
    public: 
     RuntimeDynamicLinker(const wchar_t * moduleName) 
     { 
      hMod_ = LoadLibraryW(moduleName); 
      if (hMod_ == 0) 
      { 
       Exception::Throw(GetLastError()); 
      } 
     } 
     template <typename T> 
     T GetFunction(const char* functionName) 
     { 
      FARPROC result = GetProcAddress(hMod_, functionName); 
      if (result == 0) 
      { 
       Exception::Throw(GetLastError()); 
      } 
      return reinterpret_cast<T>(result); 
     } 
     ~RuntimeDynamicLinker() 
     { 
      FreeLibrary(hMod_); 
     } 
    }; 
} 

Und ein Beispiel Client:

typedef NTSTATUS (NTAPI * NtQueryInformationProcess_t)(
    IN HANDLE, 
    IN PROCESS_INFORMATION_CLASS, 
    OUT PVOID, 
    IN ULONG, 
    OUT PULONG); 
RuntimeDynamicLinker ntdll(L"ntdll.dll"); 
NtQueryInformationProcess_t NtQueryInformationProcess = 
    ntdll.GetFunction<NtQueryInformationProcess_t>("NtQueryInformationProcess"); 

Grundsätzlich würde Ich mag eine Fehlermeldung hinzufügen, wenn jemand zu verwenden GetFunction versucht, wo T ist alles andere als eine Funktion Zeigertyp (weil die reinterpret_cast ich hier gezwungen bin, könnte sonst Benutzerfehler verstecken).

Graben durch Boost Typ Eigenschaften, ich habe festgestellt, dass es eine bestehende is_function Vorlage gibt. is_function akzeptiert jedoch Verweise auf Funktionen, was in meinem Fall ein Benutzerfehler wäre (Funktion Zeiger nur). Wie kann ich RuntimeDynamicLinker::GetFunction<T>() ändern, um eine verständliche Compiler-Fehlermeldung zu erzeugen, wenn T kein Funktionszeigertyp ist?

(Randbemerkung: Ich habe nie irgendeine Art von TMP getan, also keine Angst, über Dinge zu gehen, die „Basis“, um regelmäßige Nutzer von TMP) sind

Answer 1

Greifen Sie is_pointer<T>::value && is_function<remove_pointer<T>::type>::value in einem static_assert/BOOST_STATIC_ASSERT nutzen könnten.

Answer 2

Ich glaube, Sie einen Trait verwenden könnten Klasse.

template <typename T> 
class IsFunctionPointer 
{ 
public: 
    bool isFunctionPointer(){return false;}; 
} 

typedef void (*MyFunctionPointer)(); 

template <> 
class IsFunctionPointer<MyFunctionPointer> 
{ 
public: 
    bool isFunctionPointer(){return true;}; 
} 

Dies ist die Grundidee einer Trait class.

EDIT: ich werde ein paar Artikel Link für die Einführung von Merkmalen. personnally nahm es für mich einige Zeit, bevor sie :-)

http://accu.org/index.php/journals/442

Answer 3

können Sie boost::enable_if verwenden wie so:

template <typename T> 
T GetFunction(const char* functionName, 
    typename boost::enable_if_c<boost::is_pointer<T>::value 
     && boost::is_function<typename boost::remove_pointer<T>::type>::value>::type* = 0) 
{ 
    .... 
} 

Dies wird nur ein Template-Parameter ermöglichen, dass ein Zeiger ist und auch eine Funktion. Alles andere wird zur Kompilierzeit nicht an die Funktion gebunden.

so dass:

GetFunction<int(*)()>("foo"); // compiles properly 
GetFunction<int()>("foo"); // fails to compile