Search Results

struct decreasing_integer_range; template<typename Int, Int... … static_assert(N == 2, ""); } template<std::size_t N> void test(std::integer_sequence<int, -3, -2, -1, 0, 1>) { static_assert(N == 3, ""); } template<std::size_t N> void test(std::integer_sequence …

The code is rather tiny so there isn't much to say, but I still have a couple of remarks: Since you're using C++17, you can take advantage of variable templates to simplify your static assertions a …

Step, bool IsIncreasing > struct integer_range_impl; template< typename Integer, Integer... … <std::size_t, Begin, End, Step>; Here is an example of how this template integer range can be used: #include <array> #include <iostream> #include <iterator> #include <numeric> template<typename T, …

Most of the time we use it mostly because it is terser and convenient as well as reducing the refactoring cost when we need to modify the template parameters of the class. …

Using it should allow you to always be safe but also to be safe when possible: template < typename Tp, int M, int N> void zero( cv::Matx<Tp, M, N>& m ) { std::fill(std::begin(m.val), std::end(m.val) … If you don't use a C++11 standard library, you can implement it as follows instead: template < typename Tp, int M, int N> void zero( cv::Matx<Tp, M, N>& m ) { std::fill(m.val, m.val + M*N, 0); } For …

>::type; Here is the template utility I wrote to detect whether a template has a specialization for a given type, for SFINAE purpose: template< template<typename...> class, typename, typename … =void > struct is_specialized: std::false_type {}; template< template<typename...> class Template, typename T > struct is_specialized<Template, T, std::void_t<decltype(Template<T>{})>>: …

The intersect function First of all, I do believe that intersect should only be a free function that takes any number of mathematical objects and returns whether these objects intersect at some point …

I did manage to improve some things since the question was posted. So here is what I discovered, that could somehow improve the implementation and the usability of the Vector(T): First of all, there …

This one review will be a little bit tricky: I was trying to implement a template Vector struct in C11. …

Since you have access to a C++11 compiler, you should use the standard type trait std::is_enum in the default version of your template instead of just writing is_enum = false. … Also, it should be constexpr: template<typename T> struct enum_properties { static constexpr bool is_enum = std::is_enum<T>::value; // ... }; Now, you don't have any mean to know whether T is …

Therefore, you function declaration should be along these lines: template< typename T, typename InputIt, typename OutputIt, typename Distance, typename Compare = typename Comp<T, Distance … :size_t n, Distance dist, Compare comp = Compare()); That said, the standard library algorithms also tend to return the first iterator of the output range, so the declaration would become: template …

instead if not providing the body triggers some warnings so that you don't have to repeat the return type: static constexpr auto check(T *) -> typename std::is_same<decltype(std::declval<caller>().template …

You don't have to always pollute the template parameters list when using the indices trick. … It will make it easier for users to understand the signature: template<typename It, typename Fun, std::size_t... …

In other words, make DenseBase take a Derived template parameter which corresponds to the type of the derived class: template <typename T, std::size_t M, std::size_t N, typename Derived> class DenseBase … { // ... } Then make the derived classes feed their own type to this template parameter: template <typename Parent, typename T, std::size_t N> class Rowview : public DenseBase<T, 1, N, Rowview< …

arguments whose types have been deduced, I would have passed args by universal reference (now officially called forwarding reference) and used std::forward to forward the results to the following functions: template … and quite long to explain how it works exactly - you can find a great explanation in the answer linked above -, but the main point is that using this particular recipe implements perfect forwarding: template …