Calling method of specialized template base class in sub-class

[TheKamis]

class IFoo
{
virtual void Bar() = 0;
};

class FooAbstract
{
virtual void Bar() {}
};

template<class T>
class FooTemplate
{
public:
virtual void Bar();
T _param;
};

template<class T>
FooTemplate<T>::Bar()
{
cout << "FooTemplate<T>::Bar() " << _param << endl;
}

class FooDerived : public FooTemplate<int>
{
public:
virtual void Bar();

// additional methods
};

FooDerived::Bar()
{
cout << "FooDerived::Bar() " << _param << endl;
this->FooTemplate<int>::template Bar<int>(); // error
}

How to call the Bar() method from FooTemplate in FooDerived::Bar()?

[JLBorges]

template < typename T > struct B { template < typename U > void bar() {} } ;

template < typename T > struct D : B<T>
{
    template < typename U > void bar()
    {
        // ...
        B<T>::template bar<U>() ;
        // ...
    }
};

[TheKamis]

Unfortunately, this is not the same case. In my case the base of FooDerived is a specialized template class.

In fact I made a mistake in the description code. In real case I did not overwrite the Base() method in FooTemplate. As a result FooDerived couldn't call Bar() from its base. And the base in that case was FooAbstract::Base(), which was unaccessible. Why?

When I overwrote Base in FooTemplate the code started to work fine. But still, even if I didn't overwrite the Base() method in FooTemplate it should be called from the closest base of a base of a base... that was implemented. But wasn't...

[JLBorges]

What difference does that make?

template < typename T > struct B { template < typename U > void bar() {} } ;

template <> struct B<int> { template < typename U > void bar() ; } ;

struct D : B<int>
{
    template < typename U > void bar()
    {
        // ...
        B<int>::bar<U>() ;
        B<int>::template bar<U>() ;
        // ...
    }
};

template < typename U > void B<int>::bar() {}

[vlad from moscow]

template <class T>
struct A
{
	virtual void f() { std::cout << "A<T>::f()\n"; }
};

struct B : A<int>
{
	void f() { A<int>::f(); std::cout << "B::f()\n"; }
};

[AbstractionAnon]

Line 33 is missing a void type.

Simply qualify the call to Bar by the base class (what you used on line 25):

void FooDerived::Bar()
{   cout << "FooDerived::Bar() " << _param << endl;
    FooTemplate<int>::Bar(); 
}