In C++11… Let’s take a look at the specification of the constructor template of std::function (which takes any Callable): [func.wrap.func.con]/7-10 template<class F> function(F f); template <class F, class A> function(allocator_arg_t, const A& a, F f); 7 Requires: F shall be CopyConstructible. f shall be Callable (20.10.11.2) for argument types ArgTypes and return type R. The … Read more
You might want to overload operator ++ for your enum if you really want to iterate its values: Foo& operator++( Foo& f ) { using UT = std::underlying_type< Foo >::type; f = static_cast< Foo >( static_cast< UT >( f ) + 1 ); return f; } and use for (Foo foo = Foo::First; foo <= … Read more
should std::common_type use std::decay? Yes, see Library Working Group Defect #2141. Short version (long version, see link above): declval<A>() returns a A&& common_type is specified via declval, n3337: template <class T, class U> struct common_type<T, U> { typedef decltype(true ? declval<T>() : declval<U>()) type; }; common_type<int, int>::type therefore yields int&&, which is unexpected proposed resolution … Read more
Your code is being accepted without any warnings because the original C++11 restriction is considered a defect in the standard, which allows implementations to fix the behavior. See CWG DR975, DR1048 and N3638. 975. Restrictions on return type deduction for lambdas [Moved to DR status at the April, 2013 meeting as part of paper N3638.] … Read more
http://smellegantcode.wordpress.com/2011/10/31/linq-to-c-or-something-much-better/ But you can use this, that works well. #include <boost/range/adaptors.hpp> #include <boost/range/algorithm.hpp> #include <vector> #include <functional> int main() { std::vector<int> v{ 1,5,4,2,8,5,3,7,9 }; std::function<int(int)> func = [](int i) { return -i; }; std::cout << *boost::min_element(v | boost::adaptors::transformed( func)) << std::endl; return 0; } http://liveworkspace.org/code/b78b3f7d05049515ac207e0c12054c70 #define BOOST_RESULT_OF_USE_DECLTYPE works fine in VS2012 for example.
Unfortunately, as you noticed, expanding a parameter pack is only valid in certain contexts where the parser expects a comma-separated list of entries – contexts where the comma is just a syntactic separator, not the comma operator. This is arguably a deficiency in the current text. An ugly workaround: func((some(p), 0)…); Do note that the … Read more
The short answer is that the C++11 specification requires your A to be CopyConstructible to be used with std::function. The long answer is this requirement exists because std::function erases the type of your functor within the constructor. To do this, std::function must access certain members of your functor via virtual functions. These include the call … Read more
Firstly, the implicit object parameter is treated as a normal parameter as per 13.3.1.4: For non-static member functions, the type of the implicit object parameter is — “lvalue reference to cv X” for functions declared without a ref-qualifier or with the & ref-qualifier — “rvalue reference to cv X” for functions declared with the && … Read more
With help of a compile-time integer list: #include <cstdlib> template <size_t… n> struct ct_integers_list { template <size_t m> struct push_back { typedef ct_integers_list<n…, m> type; }; }; template <size_t max> struct ct_iota_1 { typedef typename ct_iota_1<max-1>::type::template push_back<max>::type type; }; template <> struct ct_iota_1<0> { typedef ct_integers_list<> type; }; We could construct the tail simply by … Read more
With help of a compile-time integer list: #include <cstdlib> template <size_t… n> struct ct_integers_list { template <size_t m> struct push_back { typedef ct_integers_list<n…, m> type; }; }; template <size_t max> struct ct_iota_1 { typedef typename ct_iota_1<max-1>::type::template push_back<max>::type type; }; template <> struct ct_iota_1<0> { typedef ct_integers_list<> type; }; We could construct the tail simply by … Read more