enable-if

I already know that you can enable (or not) a class's method using std::enable_if for exemple: template<size_t D, size_t E> class Field { ... size_t offset(const std::array<float,D>& p) const { ... } template<typename TT = size_t> typename std::enable_if<D!=E, TT>::type offset(const std::array<float,E>& p) const { return offset(_projection(p)); } ... }; This helps not being able to call function that are invalid in a specific case as well as removing overloading errors ... which, to me, is very nice ! I'd like to go further and make some of my class's members being present only if the are

C++14 will have functions whose return type can be deduced based on the return value. auto function(){ return "hello world"; } Can I apply this behaviour to functions that use enable_if for the SFINAE by return type idiom? For example, let's consider the following two functons: #include <type_traits> #include <iostream> //This function is chosen when an integral type is passed in template<class T > auto function(T t) -> typename std::enable_if<std::is_integral<T>::value>::type { std::cout << "integral" << std::endl; return; } //This function is chosen when a floating point type is passed in

This question combines several pieces of code and is a bit complicated, but I tried slimming it down as much as possible. I am trying to use std::enable_if to conditionally invoke the correct constructor as a result of ambiguous function signatures when a lambda expression is used as input, but the parameters of said lambda expression can be implicitly convertible to one another. This is an attempt to build upon the following question: Here , but is sufficiently different and focuses on std::enable_if to merit another question. I am also providing the Live Example that works with the problem

I'm trying to understand how enable_if works and I understand almost everything except scenario #3 from https://en.cppreference.com/w/cpp/types/enable_if template<class T> void destroy(T* t, typename std::enable_if<std::is_trivially_destructible<T>::value>::type* = 0) { std::cout << "destroying trivially destructible T\n"; } if the expression in enable_if is true then partial template specialization is chosen, so if it is chosen: why in enable_if is only condition without indicating second template parameter ? What type is "type*" then ? void* ? if so, why ? Why is it pointer ? why in enable

I'm writing a template class, and I want to allow an additional method to exist only for a certain template type. Currently the method exists for all template types, but causes a compilation error for all other types. Complicating this is that it's an overloaded operator(). Not sure if what I want to do is actually possible here. Here's what I have now: template<typename T, typename BASE> class MyClass : public BASE { public: typename T& operator() (const Utility1<BASE>& foo); typename T const& operator() (const Utility2<BASE>& foo) const; }; I want the T& version always available, but the T