sfinae

问题 I want to write a wrapper over std::ostream in this style: #include <iostream> struct OstreamWrapper { OstreamWrapper(std::ostream &out) : out(out) {} template< typename T > decltype(auto) operator<<(T &&arg) { return out << std::move< T >(arg); } std::ostream &out; }; int main() { OstreamWrapper wrap(std::cout); wrap << "Hello, world!"; // This works wrap << std::endl; // This does not work return 0; } The problem with this approach is that it does not work (for example) with std::endl ,

问题 In the following code I'm trying to call a functor with whatever it takes as its parameters, "whatever" being a limited set of options (the two here are not the only ones in my code). #include <memory> #include <iostream> template<class T> struct call_with_pointer { // last resort: T* template<class Callable> static auto call(Callable &callable, const std::shared_ptr<T> &param) -> decltype(callable(param.get())) { return callable(param.get()); } }; template<class T> struct call_with_shared :

问题 I have a simple wrapper class for a GTK GUI like this: template <class T> class LabeledEntry { string name; T var; Gtk::HBox hbox; Gtk::Label label; Gtk::Entry entry; public: LabeledEntry( string _name, T _var, Gtk::VBox* vbox): name( _name ), var(_var) { label.set_text( name.c_str() ); ostringstream os; os << var ; entry.set_text( os.str().c_str() ); hbox.add( label ); hbox.add( entry ); vbox->add( hbox); } T Get() { string valString( entry.get_text()); istringstream is( valString); is >>

问题 I've got the following code: #include <utility> #include <iostream> #include <queue> #include <functional> #include <stdio.h> #include <future> class Runner { public: virtual void run() = 0; virtual ~Runner() { } }; class Command: public Runner { public: Command() { std::cout << "constructor" << std::endl; } virtual void run() { } }; #define EXTEND(T, F) , typename = typename std::enable_if<std::is_base_of<F, typename std::decay<T>::type>::value, typename std::decay<T>::type>::type #define

问题 I need to initialize a static bool inside of a template class and I tried to do it like this. The only difference I can see is that I have a constraint on type parameter T but this causes a compilation error, why? How can I solve this? Code is the following: template<class T, class = typename enable_if<is_any_integral<T>::value>::type> class fraction { static bool auto_reduce; // ... }; template<class T, class = typename enable_if<is_any_integral<T>::value>::type> bool fraction<T>::auto

问题 Consider the following code: // -------------------------------------------------------------------------- // // Preprocessor #include <array> #include <vector> #include <utility> #include <iostream> #include <type_traits> // -------------------------------------------------------------------------- // // -------------------------------------------------------------------------- // // Calls a function without arguments if it can be called template < class F, class... Args, class = decltype

问题 I want to create a variadic perfect-forwarding make_shared<T> wrapper, but one which is SFINAEd on whether the constructor of T takes any non-const reference/pointer arguments. The idea is to have two wrappers, called construct and construct_nonconst , where when constructing a Foo(int& r) or Foo(int* r) , one is obliged to use the latter. The purpose of this is so that when developers write classes whose constructors require non-const parameters, they can do so, but it clearly shows up at

问题 This question already has answers here : Selecting a member function using different enable_if conditions (5 answers) Closed 3 years ago . I have a class template Bird with a Boolean template parameter can_fly . Depending on that value, I want to enable a member function with the signature void fly(); . This is my code: #include <type_traits> template<bool can_fly> class Bird { public: template<typename void_t = typename std::enable_if<can_fly>::type> void_t fly() { /* ... */ } }; int main()

问题 Can someone explain the following behaviour (I'm using Visual Studio 2010). header: #pragma once #include <boost\utility\enable_if.hpp> using boost::enable_if_c; enum WeekDay {MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY}; template<WeekDay DAY> typename enable_if_c< DAY==SUNDAY, bool >::type goToWork() {return false;} template<WeekDay DAY> typename enable_if_c< DAY!=SUNDAY, bool >::type goToWork() {return true;} source: bool b = goToWork<MONDAY>(); compiler this gives error

问题 I have run into an interesting challenge that I have been trying to solve for hours, but after much research and many failed attempts, I find myself asking this question. I would like to write 3 overloaded functions that each take one of the following types: const char* , const char(&)[N] and string literal (e.g. "BOO") . I understand that a string literal is simply a char array, but please bear with me while I explain my approach. The two functions below are able to differentiate between the