No, you (currently) cannot. The standard way of doing this is by creating “make_like” function (such as make_pair, make_optional …): template<typename F, typename… Args> A<std::decay_t<F>> make_A (F &&f, Args&&… args) { return {std::forward<F>(f), std::forward<Args>(args)…}; } C++17 will introduce template argument deduction for class which will allow you to do exactly what you want (see also … Read more
Name the return type? template <typename T=std::vector<int>> T test(){ T ret; ret.push_back(5); ret.push_back(9); return ret; } Please don’t make me constrain this with enable_if.
They wanted a way to get the type of declaration of an identifier. They also wanted a way to get the type of an expression, including information about if it is a temporary or not. decltype(x) gives the declared type of the identifier x. If you pass decltype something that is not an identifier, it … Read more
To make long story short: a braced initializer expression {} has no type by itself auto has to infer type information int{3} obviously means “create an int var with value taken from initializer list”, thus its type is just int and can be used in any wider context (int i = int{3} will work and … Read more
To remove a reference: #include <type_traits> static_assert(std::is_same<int, std::remove_reference<int&>::type>::value, “wat”); In your case: template <typename T> auto doSomething(const T& foo) -> typename std::remove_reference<decltype(foo.bar())>::type { return foo.bar(); } Just to be clear, note that as written returning a reference is just fine: #include <type_traits> struct f { int& bar() const { static int i = 0; return … Read more
Here is at least one case: struct foo { template<class T> operator T() const { std::cout << sizeof(T) << “\n”; return {}; } }; if you do foo f; int x = f; double y = f;, type information will flow “backwards” to figure out what T is in operator T. You can use this … Read more