template-deduction

Let's consider those definitions: /*** full type information with typeid ***/ template <class> class Type{}; template <class T> std::string typeStr() { return typeid(Type<T>).name(); } /*** function template for parameter deduction ***/ template <class T> void func(const T &a) { std::cout << "Deduced type for T is: " << typeStr<T>() << std::endl; std::cout << "\targument type is: " << typeStr<decltype(a)>() << std::endl; } with pointers to const If the following statements are executed: const int i=5, *ip=&i; func(ip); The output is: Deduced type for T is: 4TypeI**PKi**E So T is actually

Is it possible to deduce template value (not type) for a c++17 function? The function foo: template<int I> int foo() { return (I); } Can be called via: foo<5>(); And will return 5. Template types can be deduced through the type of a function argument. Is it possible to do the same in some way for the template value? For example: template<int I = x> int bar(const int x) { return (I); } This obviously wont work (because for one x is required before its declaration), but might there be some C++17 trick which would allow for this? I'd like to use this as a way of setting a constant expression

I understand that, given an expression initializing a forwarding/universal reference,lvalues are deduced to be of type T& and rvalues of type T (and not T&& ). Thus,to allow only rvalues, one need to write template<class T, enable_if<not_<is_lvalue_reference<T> >,OtherConds... > = yes> void foo(T&& x) {} and not, template<class T, enable_if<is_rvalue_reference<T>,OtherConds... > = yes> void foo(T&& x) {} My question is , why for forwarding references, rvalues are deduced to be of type T and not T&& ? I guess, if they are deduced as T&& then also same referencing collapsing rule works as T&& &&

This question is about functions that take arrays of statically known size. Take for example the following minimal program: #include <iostream> template<size_t N> void arrfun_a(int a[N]) { for(size_t i = 0; i < N; ++i) std::cout << a[i]++ << " "; } int main() { int a[] = { 1, 2, 3, 4, 5 }; arrfun_a<5>(a); std::cout << std::endl; arrfun_a<5>(a); return 0; } Which, when run, prints the expected result: 2 3 4 5 6 3 4 5 6 7 However, when I tried to have my compiler (VS 2010) deduce the 5 , it could not deduce template argument for 'int [n]' from 'int [5]' . A bit of research resulted in the

#include <utility> template<class T1, class T2> struct mypair : std::pair<T1, T2> { using std::pair<T1, T2>::pair; }; int main() { (void)std::pair(2, 3); // It works (void)mypair(2, 3); // It doesn't work } Is the above well formed? Is it possible deduce the class template arguments in the second case if the constructors are being inherited? Are the constructors of std::pair participating in the creation of implicit deduction guides for mypair ? My compiler is g++ 7.2.0. I think this is a gcc bug (or at least a minor core language wording defect). Inherited constructors do count as

I wonder why std::function is only aware of two-argument functions. I've written some code which is working well, but there are a number of limitations. Any feedback welcome. In particular, I suspect I'm reinventing the wheel. My code is on ideone and I will refer to it. For example, I can describe the type of main with: function_type_deducer(main).describe_me(); // Output: I return i and I take 2 arguments. They are of type: i PPc (where 'i' means 'int' and 'PPc' means pointer-to-pointer-to-char) Standard std::function doesn't work with functions with more than two args (see the last two