sfinae

问题 How can I have this effect without the arbitrary typedefs? #include <type_traits> #include <iostream> typedef int Primary; typedef float Secondary; template<Class C, std::enable_if<std::is_same<Class, Primary>::value || std::is_same<Class, Secondary>::value> = 0> class Entity { public: template<std::enable_if<std::is_same<Class, Secondary>::value>::type = 0> void onlyLegalForSecondaryEntities() { std::cout << "Works" << std::endl; } }; int main() { Entity<Secondary> e; e

问题 I was trying to wrap my head around this question here because it was written in such a way that it was hiding what it was actually doing. So I rewrote it as such: template<typename CLASS> struct has_begin { // NOTE: sig_matches() must come before fn_exists() as it is used for its // type. Also, no function bodies are needed as they are never called. // This matching sig results in a return type of true_type template<typename A_CLASS> static auto sig_matches(void(A_CLASS::*)()) -> std::true

问题 I was trying to understand how SFINAE works and I was experimenting with this code #include <type_traits> struct One { using x = int; }; struct Two { using y = int; }; template <typename T, std::void_t<typename T::x>* = nullptr> void func() {} template <typename T, std::void_t<typename T::y>* = nullptr> void func() {} /*template <typename T, std::enable_if_t<std::is_same_v<typename T::x, typename T::x>>* = nullptr> void func() {} template <typename T, std::enable_if_t<std::is_same_v<typename

问题 Using SFINAE, i can detect wether a given class has a certain member function. But what if i want to test for inherited member functions? The following does not work in VC8 and GCC4 (i.e. detects that A has a member function foo() , but not that B inherits one): #include <iostream> template<typename T, typename Sig> struct has_foo { template <typename U, U> struct type_check; template <typename V> static char (& chk(type_check<Sig, &V::foo>*))[1]; template <typename > static char (& chk(...))

问题 I was trying to port an open sourced project from linux to window, there are some code that compiles perfectly in linux using either g++ or clang++, but I cannot compile it under MSVC 2015, could anyone tell me how to fix it or how to get around it? I appreciate very much for your help!!! Here is the code (I have simplified it so you can focus on the key stuff) template <typename T, class IsMatch = void> class vc_hashkey { public: static constexpr bool holds_value() { return false; } };

问题 In the latest working draft (page 572) of the C++ standard the converting constructor of std::variant is annotated with: template <class T> constexpr variant(T&& t) noexcept(see below ); Let Tj be a type that is determined as follows: build an imaginary function FUN (Ti) for each alternative type Ti. The overload FUN (Tj) selected by overload resolution for the expression FUN (std::forward<T>(t)) defines the alternative Tj which is the type of the contained value after construction. Effects:

问题 I currently have a function: template<typename T> bool func(T &t, int x) { // do stuff... } However I would like to have three different function bodies: T being an enum T being unsigned char Everything else I have tried this already but didn't get far. What are the correct function declarations for these three cases to work? The closest I have been able to come up with is Case 1 being: template<typename T> typename std::enable_if< std::is_enum<T>::value, bool >::type func( T &t, int x) and

问题 I currently have a function: template<typename T> bool func(T &t, int x) { // do stuff... } However I would like to have three different function bodies: T being an enum T being unsigned char Everything else I have tried this already but didn't get far. What are the correct function declarations for these three cases to work? The closest I have been able to come up with is Case 1 being: template<typename T> typename std::enable_if< std::is_enum<T>::value, bool >::type func( T &t, int x) and

问题 The base components of my hobby library has to work with C++98 and C++11 compilers. To learn and to enjoy myself I created the C++98 implementations of several type support functionality (like enable_if , conditional , is_same , is_integral etc. ...) in order to use them when there is no C++11 support. However while I was implementing is_constructible I got stuck. Is there any kind of template magic (some kind of SFINAE) with which I can implement it without C++11 support ( declval )? Of

问题 I can not get my head around the following problem. I don't even really know how I could approach it. Consider this code: struct fragment_shader { std::string mPath; }; struct vertex_shader { std::string mPath; }; template <typename T> T shader(std::string path) { return T{ path }; } To create the different structs, I can write the following: auto fragmentShader = shader<vertex_shader>("some_shader.frag"); auto vertexShader = shader<fragment_shader>("some_shader.vert"); I am wondering, if it