How to avoid writing `this->template` at every call site when referencing base class template methods?

Question

I'm porting some code from MSVC to GCC and stuck on this problem.

I have a derived class template (Derived) that calls base class template's (Base) methods. If this is non-template method, I can simply say using Base::regular_function, but for template methods this trick does not work anymore and I have to explicitly write this->template template_function() at every call site. Is there a way to avoid this?

Base class template:

template<class T>
class Base
{
public:
    template<class U>
    U * template_function() const { return nullptr; }
    int * regular_function() const { return nullptr; }
};

Derived class template:

template<class T>
class Derived : Base<T>
{
    using base_t = Base<T>;

public:
    using base_t::regular_function;
    using base_t::template_function;

    void foo()
    {
        // OK, works because of "using" above
        auto * regular_ptr = regular_function();

        // Does not work :(
        auto * ptr1 = template_function<int>();

        // Want to avoid
        auto * ptr2 = this->template template_function<int>();
    }
};

It's possible to avoid this by introducing helper function, but I want to avoid writing it in every derived class, too.

template<class U>
U * template_function() const
{
    return base_t::template template_function<U>();
}

https://godbolt.org/z/Mxc14WE8b

UPD: the question is not about why and when should I use template and typename keywords, but about practical advices to reduce the amount of code I need to rewrite. None of the other questions consider this usage.

Can't be avoided in some cases. See [Where and why do I have to put the "template" and "typename" keywords?](https://stackoverflow.com/questions/610245/where-and-why-do-i-have-to-put-the-template-and-typename-keywords) — Some programmer dude, May 22 '22 at 16:33
None of these examples account for my use case, nor they tell practical advices. — Genjutsu, May 22 '22 at 16:41
There is no advice, other than "you have to write the `template` keyword". No way around it in this version of C++. — n. 1.8e9-where's-my-share m., May 22 '22 at 16:46
Did you read **The "template" keyword** section of the accepted answer? It doesn't only have an exact copy (except the function name) of what you want to avoid, but also explain why it's needed. — Some programmer dude, May 22 '22 at 16:47
@Someprogrammerdude On the third re-read I finally got it. Thanks for pointing out! — Genjutsu, May 22 '22 at 16:51
It's a lot of text to go through, and admittedly not very easy. Good thing you were persistent. :) — Some programmer dude, May 22 '22 at 16:56
On the second thought you can avoid writing it every time if you wrap your function template in another template defined in your derived class, and call that. Not pretty but that's what you can do. — n. 1.8e9-where's-my-share m., May 22 '22 at 18:11
@n.1.8e9-where's-my-sharem. yes, I've considered this in the question. I've ended up with this solution. — Genjutsu, May 22 '22 at 18:56

How to avoid writing `this->template` at every call site when referencing base class template methods?

0 Answers0