The template subsystem has some special constructs built into the for/endfor block that allows you to access the current index of the loop without having to call enumerate. {% for j in a %} {{ forloop.counter0 }}, {{ j }} {% endfor %} While this snippet solves your immediate problem, if you’re expecting to have … Read more
Something like that will do nicely: template<bool bonus = false> void MyFunction() { foo(); bar(); if (bonus) { doBonusStuff(); } foobar(); } Call it via: MyFunction<true>(); MyFunction<false>(); MyFunction(); // Call myFunction with the false template by default The “ugly” template can be all avoided by adding some nice wrappers to the functions: void MyFunctionAlone() { … Read more
For builtin types, argument dependent lookup (ADL) is not performed, therefore, an ignore symbol must be “imported” into the current namespace. You can, for example, do this; from most preferred to least preferred (i.e. to most intrusive and name polluting): foobar::ignore (…) using foobar::ignore; ignore(…); using namespace foobar; ignore(…); The error message comes up like … Read more
(In this post I will omit std::chrono:: qualifications for clarity. I trust you know where they go.) The reason your code example fails to compile is that there is a mismatch between the return type of system_clock::now() and the type of variable you are trying to assign this to (time_point<system_clock, nanoseconds>). The documented return value … Read more
Here is a solution simpler than Johannes Schaub – litb’s one. It requires C++11. #include <type_traits> template <typename T, typename = int> struct HasX : std::false_type { }; template <typename T> struct HasX <T, decltype((void) T::x, 0)> : std::true_type { }; Update: A quick example and the explanation on how this works. For these types: … Read more
Templates are compiled (at least) twice: Without Instantiation the template code itself is checked for syntax. Eg: Any syntax errors such as ; etc. At the time of instantiation(when the exact type is known), the template code is checked again to ensure all calls are valid for that particular type. Eg: The template might in … Read more
template <> void foo<int>(int& t); declares a specialization of the template, with potentially different body. template void foo<int>(int& t); causes an explicit instantiation of the template, but doesn’t introduce a specialization. It just forces the instantiation of the template for a specific type.
Yes. It is called an “alias template,” and it’s a new feature in C++11. template<typename T> using MyVector = std::vector<T, MyCustomAllocator<T>>; Usage would then be exactly as you expect: MyVector<int> x; // same as: std::vector<int, MyCustomAllocator<int>> GCC has supported it since 4.7, Clang has it since 3.0, and MSVC has it in 2013 SP4.
This is one of those frequently asked questions that have different approaches that are similar but not really the same. The three approaches differ in who you are declaring to be a friend of your function –and then on how you implement it. The extrovert Declare all instantiations of the template as friends. This is … Read more
Deduction refers to the process of determining the type of a template parameter from a given argument. It applies to function templates, auto, and a few other cases (e.g. partial specialization). For example, consider: template <typename T> void f(std::vector<T>); Now if you say f(x), where you declared std::vector<int> x;, then T is deduced as int, … Read more