result-of

#include <iostream> #include <type_traits> double f(int i) { return i+0.1; } struct F { public: double operator ()(int i) { return i+0.1; } }; int main(int, char**) { std::result_of<F(int)>::type x; // ok // std::result_of<f(int)>::type x; // error: template argument 1 is invalid x = 0.1; std::cerr << x << std::endl; } Please explain why std::result_of<f(int)>::type x; is invalid... cppreference says "( std::result_of ) Deduces the return type of a function call expression at compile type.". what's the problem? std::result_of<T> requires T to be a type --but not just any type. T must be a

#include<iostream> #include<thread> using namespace std; void f1(double& ret) { ret=5.; } int main() { double ret=0.; thread t1(f1, ret); t1.join(); cout << "ret=" << ret << endl; } The above code fails compilation with the following error message : g++ -std=c++14 -O2 -Wall -pedantic -pthread main.cpp && ./a.out In file included from /usr/local/include/c++/5.3.0/thread:39:0, from main.cpp:2: /usr/local/include/c++/5.3.0/functional: In instantiation of 'struct std::_Bind_simple<void (*(double))(double&)>': /usr/local/include/c++/5.3.0/thread:137:59: required from 'std::thread::thread(_Callable&

I saw std::result_of is being deprecated in C++17. What is the reason for std::result_of deprecated in C++17? Also I would like to know the difference between std::result_of and std::invoke_result . T.C. already provided the obvious link, but perhaps the most horrific reason bears repeating: result_of involved forming the type F(Arg1, Arg2, ...) not for a function of those types returning F but for a function of type F accepting those types. (After all, the return type is the result of, well, result_of , not the input!) Aside from the adjustments associated with forming the function type, the

In this answer I define a template based on the type's is_arithmetic property: template<typename T> enable_if_t<is_arithmetic<T>::value, string> stringify(T t){ return to_string(t); } template<typename T> enable_if_t<!is_arithmetic<T>::value, string> stringify(T t){ return static_cast<ostringstream&>(ostringstream() << t).str(); } dyp suggests that rather than the is_arithmetic property of the type, that whether to_string is defined for the type be the template selection criteria. This is clearly desirable, but I don't know a way to say: If std::to_string is not defined then use the