Short answer: Whenever referring to a nested name that is a dependent name, i.e. nested inside a template instance with unknown parameter. Long answer: There are three tiers of entities in C++: values, types, and templates. All of those can have names, and the name alone doesn’t tell you which tier of entity it is. … Read more
Those script tags are a common way to implement templating functionality (like in PHP) but on the client side. By setting the type to “text/template”, it’s not a script that the browser can understand, and so the browser will simply ignore it. This allows you to put anything in there, which can then be extracted … Read more
As skaffman suggested, JSP 2.0 Tag Files are the bee’s knees. Let’s take your simple example. Put the following in WEB-INF/tags/wrapper.tag <%@tag description=”Simple Wrapper Tag” pageEncoding=”UTF-8″%> <html><body> <jsp:doBody/> </body></html> Now in your example.jsp page: <%@page contentType=”text/html” pageEncoding=”UTF-8″%> <%@taglib prefix=”t” tagdir=”/WEB-INF/tags” %> <t:wrapper> <h1>Welcome</h1> </t:wrapper> That does exactly what you think it does. So, lets expand … Read more
That is non-deducible context. That is why the template argument cannot be deduced by the compiler. Just imagine if you might have specialized TMap as follows: template <> struct TMap<SomeType> { typedef std::map <double, double> Type; }; How would the compiler deduce the type SomeType, given that TMap<SomeType>::Type is std::map<double, double>? It cannot. It’s not … Read more
No, that won’t work as intended; you will still get copies. I’m pretty surprised by this, as I’d thought that initializer_list existed to keep an array of temporaries until they were move‘d. begin and end for initializer_list return const T *, so the result of move in your code is T const && — an … Read more
C++11 added alias declarations, which are generalization of typedef, allowing templates: template <size_t N> using Vector = Matrix<N, 1>; The type Vector<3> is equivalent to Matrix<3, 1>. In C++03, the closest approximation was: template <size_t N> struct Vector { typedef Matrix<N, 1> type; }; Here, the type Vector<3>::type is equivalent to Matrix<3, 1>.
The issue is on the nature of lambdas. They are function objects with a fixed set of properties according to the standard, but they are not a function. The standard determines that lambdas can be converted into std::function<> with the exact types of arguments and, if they have no state, function pointers. But that does … Read more
If you define a template class that you only want to work for a couple of explicit types. Put the template declaration in the header file just like a normal class. Put the template definition in a source file just like a normal class. Then, at the end of the source file, explicitly instantiate only … Read more
1. Primary Class Template When you write has_member<A>::value, the compiler looks up the name has_member and finds the primary class template, that is, this declaration: template< class , class = void > struct has_member; (In the OP, that’s written as a definition.) The template argument list <A> is compared to the template parameter list of … Read more
Templated classes and functions are not instantiated until they are used, typically in a separate .cpp file (e.g. the program source). When the template is used, the compiler needs the full code for that function to be able to build the correct function with the appropriate type. However, in this case the code for that … Read more