For a simple solution, use OpenStruct: require ‘erb’ require ‘ostruct’ namespace = OpenStruct.new(name: ‘Joan’, last: ‘Maragall’) template=”Name: <%= name %> <%= last %>” result = ERB.new(template).result(namespace.instance_eval { binding }) #=> Name: Joan Maragall The code above is simple enough but has (at least) two problems: 1) Since it relies on OpenStruct, an access to a … Read more
constexpr functions Functions have an advantage that free variables do not have (until C++14 that is): they can easily be templated without some class boilerplate. That means you can have your pi with a precision depending on a template argument: template<typename T> constexpr T pi(); template<> constexpr float pi() { return 3.14f; } template<> constexpr … Read more
As stated C++14 explicitly says that the order of template argument substitution is well-defined; more specifically it will be guaranteed to proceed in “lexical order and halt whenever a substitution causes the deduction to fail. Compared to C++11 it will be much easier to write SFINAE-code that consists of one rule depending on another in … Read more
Since the specialization has to agree with the base template on the return type, you can make it so by adding a “return type trait”, a struct you can specialize and draw the true return type from: // in the normal case, just the identity template<class T> struct item_return{ typedef T type; }; template<class T> … Read more
Expression SFINAE is explained quite well in the paper you linked, I think. It’s SFINAE on expressions. If the expression inside decltype isn’t valid, well, kick the function from the VIP lounge of overloads. You can find the normative wording at the end of this answer. A note on VC++: They didn’t implement it completely. … Read more
The way I see it is that templates and inheritance are literally orthogonal concepts: Inheritance is “vertical” and goes down, from the abstract to the more and more concrete. A shape, a triange, an equilateral triangle. Templates on the other hand are “horizontal” and define parallel instances of code that knowns nothing of each other. … Read more
What you also can try is explicit instantiation: template class vector<int>; // class template int& vector<int>::operator[](int); // member template int convert<int,double>(double); // function
To me C++ templates are a compile-time version of duck typing. The compiler will compile e.g. Class and as long as your Duck has all needed types it will instantiate a class. If something is not correct(e.g. copy constructor missing) the compilation fails. The counterpart in real ducktyping is a failure when you call a … Read more
With regards to your first question – about the type int(char, float) – this is a valid C++ type and is the type of a function that takes in a char and a float and returns an int. Note that this is the type of the actual function, not a function pointer, which would be … Read more
You can’t specialize a member function without explicitly specializing the containing class. What you can do however is forward calls to a member function of a partially specialized type: template<class T, class Tag> struct helper { static void f(T); }; template<class T> struct helper<T, tag1> { static void f(T) {} }; template<class T> struct C … Read more