dependent-name

What is wrong with the following piece of code? template<typename X> struct A { template<int N> int foo() const { return N; } }; template<typename X> struct B { int bar(const A<X>& v) { return v.foo<13>(); } }; #include <iostream> using std::cout; using std::endl; int main() { A<double> a; B<double> b; cout << b.bar(a) << endl; return 0; } Inside the function B::bar the compiler complains: error: invalid operands of types ‘’ and ‘int’ to binary ‘operator<’ If A is not a template, everything compiles fine. Change return v.foo<13>(); to return v.template foo<13>(); because foo is a dependent

Does anyone know why using-declarations don't seem to work for importing type names from dependent base classes? They work for member variables and functions, but at least in GCC 4.3, they seem to be ignored for types. template <class T> struct Base { typedef T value_type; }; template <class T> struct Derived : Base<T> { // Version 1: error on conforming compilers value_type get(); // Version 2: OK, but unwieldy for repeated references typename Base<T>::value_type get(); // Version 3: OK, but unwieldy for many types or deep inheritance typedef typename Base<T>::value_type value_type; value

Consider the following snippet: struct Base { }; struct Derived : Base { }; void f(Base &) { std::cout << "f(Base&)\n"; } template <class T = int> void g() { Derived d; f(T{} ? d : d); // 1 } void f(Derived &) { std::cout << "f(Derived&)\n"; } int main() { g(); } In this case, I reckon that the function call to f at // 1 should be looked up in phase one, since its argument's type is unambigously Derived& , and thus be resolved to f(Base&) which is the only one in scope. Clang 3.8.0 agrees with me , but GCC 6.1.0 doesn't , and defers the lookup of f until phase two, where f(Derived&) is picked

As we know, the code below is ill-formed because the member x is in a dependent base class. However, changing x to this->x on the indicated line would fix the error. template <typename T> struct B { int x; }; template <typename T> struct C : B<T> { void f() { int y = x; // Error! } }; int main() { C<int> c; c.f(); } I would like an explanation of how this behaviour is specified in the standard. According to [temp.dep]/3: In the definition of a class or class template, if a base class depends on a template-parameter, the base class scope is not examined during unqualified name lookup either at

Possible Duplicate: Where and why do I have to put the “template” and “typename” keywords? Here's the code: template<typename T> class base { public: virtual ~base(); template<typename F> void foo() { std::cout << "base::foo<F>()" << std::endl; } }; template<typename T> class derived : public base<T> { public: void bar() { this->foo<int>(); // Compile error } }; And, when running: derived<bool> d; d.bar(); I get the following errors: error: expected primary-expression before ‘int’ error: expected ‘;’ before ‘int’ I'm aware of non-dependent names and 2-phase look-ups . But, when the function