enable-if

I'm trying to make a call to a templated function like this : typedef std::tuple<int, double, bool> InstrumentTuple; Cache cache; InstrumentTuple tuple = cache.get<InstrumentTuple>(); I know I could "simply" pass the types of the tuple. This is what I do know but it is quite cumbersome since I make a lot of calls to this function and since the tuples are quite long: InstrumentTuple tuple = c.get<int, double, bool>(); // syntax I'd like to avoid So I tried multiple implementations of the get method, but with no success : Enabling via a template parameter #include <tuple> class Cache { private:

I try to use std::enable_if with an unused and unnamed type parameter, in order to not distort the return type. However, the following code does not compile. #include <iostream> template <typename T, typename = std::enable_if_t<!std::is_integral<T>::value>> T foo() { std::cout << "non-integral" << std::endl; return T(); } template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>> T foo() { std::cout << "integral" << std::endl; return T(); } int main() { foo<float>(); foo<int>(); } The compiler says: 7:3: error: redefinition of 'template<class T, class> T foo()' 4:3: note:

I want to use SFINAE to enable a particular template if the user passes a function pointer as a parameter. I have googled around but found nothing - I also tried looking at the <type_traits> documentation but couldn't find anything that resembled a is_function_ptr<T> . By function pointer, I mean global function pointers, like TReturn(*)(TArgs...) . Below is a type trait determining if something is a function pointer and a couple of test cases. Note, that to test if something is a function pointer, you need to test if std::is_pointer<P>::value is true and if std::is_function<T>::value is true

I'd like to pass templated functions around as if they were generic lambdas, however this does not work. #include <iostream> #include <vector> #include <tuple> #include <string> #include <utility> // for_each with std::tuple // (from https://stackoverflow.com/a/6894436/1583122) template<std::size_t I = 0, typename FuncT, typename... Tp> inline typename std::enable_if<I == sizeof...(Tp), void>::type for_each(std::tuple<Tp...> &, FuncT) {} template<std::size_t I = 0, typename FuncT, typename... Tp> inline typename std::enable_if<I < sizeof...(Tp), void>::type for_each(std::tuple<Tp...>& t, FuncT

Herb Sutter's Back to the Basics! Essentials of Modern C++ presentation at CppCon discussed different options for passing parameters and compared their performance vs. ease of writing/teaching. The 'advanced' option (providing the best performance in all the cases tested, but too difficult for most developers to write) was perfect forwarding, with the example given (PDF, pg. 28) : class employee { std::string name_; public: template <class String, class = std::enable_if_t<!std::is_same<std::decay_t<String>, std::string>::value>> void set_name(String &&name) noexcept( std::is_nothrow_assignable

Consider the following code : template<bool AddMembers> class MyClass { public: void myFunction(); template<class = typename std::enable_if<AddMembers>::type> void addedFunction(); protected: double myVariable; /* SOMETHING */ addedVariable; }; In this code, the template parameter AddMembers allow to add a function to the class when it's true . To do that, we use an std::enable_if . My question is : is the same possible (maybe with a trick) for data members variable ? (in a such way that MyClass<false> will have 1 data member ( myVariable ) and MyClass<true> will have 2 data members (