34

The following code fails as expected, because no overload of get is found. Using std::getwould solve the problem.

#include <array>

int main()
{
    std::array<int, 2> ar{2,3};
    auto r = get<0>(ar);//fails, get was not declared in this scope
}

However, introducing a templated version of get, even though it's not matching the function call, somehow makes the compiler use the std::get version:

#include <array>

template <typename T>
void get(){};

int main()
{
    std::array<int, 2> ar{2,3};

    auto r = get<0>(ar);//returns 2
}

I can't find any part of the standard that explains this. Is this a bug in all 3 compilers I tested (probably not), or am I missing something?

This behaviour was tested in

  • MSVC 15.9.2
  • Clang 8.0.0
  • GCC 9.0.0 (still an experimental version)

EDIT: I am aware of ADL. But if ADL makes the second code work, why does it not in the first part?

LcdDrm
  • 1,009
  • 7
  • 14
  • It is found by ADL. Seems that ADL is prevented without providing that declaration, . – felix Nov 20 '18 at 13:11
  • 1
    I was suspecting ADL. However, it does not explain why ADL doesn't work without the fake-template – LcdDrm Nov 20 '18 at 13:13
  • Alternatively, just don't give your functions names that are already within the standard library. – jfh Nov 20 '18 at 16:26
  • 1
    @jfh Bad advice. Don’t try to work around something that namespaces already fix for you. – Konrad Rudolph Nov 20 '18 at 16:51
  • @KonradRudolph For most cases yes of course use a namespace (preferably not the global one), but I expect functions and classes named after standard counterparts to do the same thing and perform the exact same way (if it ain't broke...). I would use a fully qualified name for a function, and honestly fail someone's code review if they used a mirrored name and didn't explain clearly why. Granted this has no bearing on the original question which is why this is a comment. – jfh Nov 20 '18 at 17:03
  • @jfh We discovered this during a coding exercise. The goal was to create a `get` method for `std::vector`. This was supposed to enable operations on tuples, arrays and vectors with the same syntax. I get your point though. Could be problematic if I'm not aware that a method of the same name exists in the stl. – LcdDrm Nov 21 '18 at 08:16
  • 1
    @LcdDrm As an exercise for myself I wrote the above functionality that you describe. I can share it with you if you like. – jfh Nov 24 '18 at 23:09
  • @jfh Thanks, but I got it working. I was just wondering about that strange ADL behaviour – LcdDrm Nov 26 '18 at 08:06
  • Not quite a duplicate, since this explores the “workaround”, but there is [more discussion](https://stackoverflow.com/q/2953684/8586227). – Davis Herring Oct 26 '21 at 21:23

2 Answers2

20

ADL is not used when explicit template arguments are involved unless you introduce a template function declaration at the call point. You're using an unqualified form of get using a non-type template argument 0, so you need to introduce a template function declaration or use the qualified version of get as std::get<0>(ar).

In standardese [temp.arg.explicit]/8: (emphasis mine)

[ Note: For simple function names, argument dependent lookup (6.4.2) applies even when the function name is not visible within the scope of the call. This is because the call still has the syntactic form of a function call (6.4.1). But when a function template with explicit template arguments is used, the call does not have the correct syntactic form unless there is a function template with that name visible at the point of the call. If no such name is visible, the call is not syntactically well-formed and argument-dependent lookup does not apply. If some such name is visible, argument dependent lookup applies and additional function templates may be found in other namespaces.

EDIT:

As @Yakk - Adam Nevraumont has pointed out in the comment, without the presence of the template function declaration, the expression get<0>(ar) will be parsed as (get<0)>(ar), i.e as a serie of comparison expressions instead of a function call.

Jans
  • 11,064
  • 3
  • 37
  • 45
  • Well that makes sense. Although in GCC 9.0.0, a `void get();` is enough to make ADL work again. If I interpret that snipped of the standard correctly, this is a compiler bug? – LcdDrm Nov 20 '18 at 13:34
  • That version of GCC is still under development, its too early to say that – Jans Nov 20 '18 at 13:46
  • 5
    Good answer, but I'd mention what `get<0>(ar)` is parsed as without the template: `(get<0)>(ar)`. This makes it more clear why the existence of the template `get` makes a difference. – Yakk - Adam Nevraumont Nov 20 '18 at 15:47
6

Note that this changed in C++20 as a result of P0846R0. An unqualified name followed by a < token for which ordinary unqualified lookup either finds one or more functions or finds nothing is now assumed to name a template and the < is parsed accordingly.

T.C.
  • 133,968
  • 17
  • 288
  • 421