具有不完整返回类型和无法解释的模板的变通方法

Question

I have to post quite a bit of code in order to explain my situation. The question, however, is simple (see also at the very bottom of my post, and the last code segment):

In SubscriptProxy::is , why does it compile when calling this->get_element<Something>(parentElement); but does not compile when calling XYZ::get_element<Something>(parentElement); ?

---

File Element.hpp

class Element{};

File HelperFunctions.hpp :

#include "Element.hpp"

namespace XYZ {
    class Something;

    template<typename T>
    T get_element(Element* e) {
    }

    template<>
    Something get_element(Element* e);
}

File HelperFunctions.cpp :

#include "HelperFunctions.hpp"
#include "Something.hpp"

namespace XYZ {
    template<>
    Something get_element(Element* e) {
       // Convert Element to Something somehow
       return Something{};
    }
}

File SubscriptProxy.hpp :

#include "HelperFunctions.hpp"

namespace XYZ {
    class Something;

    template<typename C, typename D, typename E>
    class SubscriptProxy {
        C m_parent;
        E m_index; 

        template<typename T>
        T get_element(Element* e) const {
            return XYZ::get_element<T>(e); // call helper function
        }

        template<typename T>
        bool is(int index, Element*& e) const noexcept {
            Element* parentElement;
            if (!m_parent.template is<Something>(m_index, parentElement)) {
                return false;
            }
            auto d = this->get_element<Something>(parentElement);
            return d.template is<T>(index, e);
        }
    };
}

And then we have Something.hpp and Something.cpp , of course. It contains an operator which returns an instance of SubscriptProxy :

#include "SubscriptProxy.hpp"
#include "HelperFunctions.hpp"

namespace XYZ {
    class Something {
        SubscriptProxy<Something, Something, int> operator[] (int index) const noexcept;
    };
}

File Something.cpp :

#include "Something.hpp"

namespace XYZ {
SubscriptProxy<Something, Something, int> Something::operator[] (int index) const noexcept {
    return SubscriptProxy<Something, Something, int>{};
}

---

This compiles and works fine.

However, if I change the implementation of the SubscriptProxy::is method to the following:

        template<typename T>
        bool is(int index, Element*& e) const noexcept {
            Element* parentElement;
            if (!m_parent.template is<Something>(m_index, parentElement)) {
                return false;
            }
            auto d = XYZ::get_element<Something>(parentElement);
            return d.template is<T>(index, e);
        }

...it fails to compile with the error message: Calling 'get_element' with incomplete return type 'Something'.

Why?

Answer 1

There are two-phase name lookup to check errors with template:

• one for any template argument, so compiler only check non dependant code.
• one at the instantiation (so all parameters are fixed).

auto d = XYZ::get_element<Something>(parentElement); is now longer template dependent, so compiler may provide error for this.

with this->get_element , it depends of this which is template.