MSVC is happy with this code but GCC isn't so keen

Question

This code compiles in MSVC (19.00.23918) but GCC doesn't like it unless I use this-> access to member operator when I call Detach_Internal().

Is GCC catching a potential bug here that MSVC isn't? As a general rule is it a better idea to use this-> at all times when referencing functions in base classes?

Note GCC will compile it with -fpermissive.

#include <memory>

namespace Events
{
    template<typename T>
    class EventBase
    {
    protected:

        void Detach_Internal(std::weak_ptr<void> const & p)
        {

        }
    };

    template<typename T>
    class Event : public EventBase<T>
    {
    public:

        void Detach(std::weak_ptr<void> const & p)
        {
            Detach_Internal(p);
        }
    };
}


int main(void)
{
    auto event = std::make_unique<Events::Event<void()>>();    
}

33:30: error: there are no arguments to 'Detach_Internal' that depend on a template parameter, so a declaration of 'Detach_Internal' must be available [-fpermissive]

Answer 1

Is GCC catching a potential bug here that VS isn't? As a general rule is it a better idea to use this-> at all times when referencing functions in base classes?

GCC is correct. You should add this-> when referring names in dependent base class (i.e. EventBase<T>, which depends on template parameter T).

Otherwise as a nondependent name, Detach_Internal won't be looked up in dependent base class EventBase<T>.

To solve the issue you can make the name Detach_Internal dependent, then it will be looked up at the time of instantiation, at that time the exact base class template specialization is fixed. e.g.

this->Detach_Internal(p);

EventBase<T>::Detach_Internal(p);

using EventBase<T>::Detach_Internal;
Detach_Internal(p);