Argument dependent name lookup and typedef

Question

I would not have expected this code to compile, but it does. My understanding is that func(d) it looks in the global namespace for a function called "func" but also in the namespace of any passed in parameters (Argument dependent lookup)

But in this case the parameter is in the global namespace. So why does it find "func" in the ns namespace? Are there special rules saying that if the parameter type is a typedef then it uses the namespace of the underlying type rather than the namespace of the actual parameter?

This appears to be true but I can't find anything supporting this... Is it the expected behavour?

namespace ns { struct data {}; void func(ns::data item) {} }; // Create an alias "datatype" in the global namespace for ns::data typedef ns::data datatype; int main() { datatype d; func(d); }

typedef is meant for the human, not the compiler. It's an alias. The compiler knows what a typedef'd type really is. — Dialecticus
– Dialecticus, Commented Nov 2, 2012 at 10:02
@Dialecticus the interesting thing is that func(d) is allowed, rather than demanding ns::func(d). The namespace appears to have "leaked". (incidentally, the same code compiles for me under gcc 4.4.5 and VS2012) — Rook
– Rook, Commented Nov 2, 2012 at 10:04
@Rook that's by the standard. OP knows about that, and is asking about a case with typedef. — Dialecticus
– Dialecticus, Commented Nov 2, 2012 at 10:06
@Rook that is what the argument dependent lookup is supposed to do. — juanchopanza
– juanchopanza, Commented Nov 2, 2012 at 10:06

Lara Bailey · Accepted Answer · 2012-11-02 10:01:46Z

The parameter d is local to main. datatype is just an alias for the type ns::data so d has type ns::data.

ns::data is a [direct] member of the ns namespace so this functions in the ns namespace will be considered for ADL.

David Rodríguez - dribeas · Accepted Answer · 2012-11-05 15:14:07Z

The other answers already provide the reason, if not the rationale:

A typedef is an alias to a type, and it will be resolved by the compiler to the actual type. Argument dependent lookup is done based on the underlying type, not the typedef.

The rationale for this design decision is actually the reason why ADL is in the language. ADL was added to the language to support operator overloading. In any other use case, the user can explicitly state the namespace of the functions, but in the case of operator overloading that would lead to convoluted code that is counter intuitive:

std::string s("Hi"); std::cout.operator<<(s); // or is it std::operator<<(std::cout,s)??

So the language added rules for lookup to find operators (and functions) in different namespaces, and in particular in the namespace of the arguments to the function. In this case inside std:: in case the operator<< that takes a std::string is not a member of std::cout. The same behavior is extended to all free functions in the same namespace (why not?) allowing the interface of a type to include not only member functions but also free functions in the same namespace.

Now if you focus on this, the purpose is accessing functions that are part of the interface of the type, and those are defined with the type. When you add a typedef in a different namespace you are just creating a shorthand to refer to the original type. All of the functions that were provided with the type (for example operator<<(std::ostream&,MyType)) are in the original namespace, no in the namespace of the typedef. You want ADL to look into the namespace where the real type was defined, not where the alias was created.

Community · Accepted Answer · 2017-05-23 12:02:48Z

This behaviour is specified by the standard (my emphasis):

3.4.2 Argument-dependent name lookup [basic.lookup.argdep]

2 - For each argument type T in the function call, there is a set of zero or more associated namespaces and a set of zero or more associated classes to be considered. The sets of namespaces and classes is determined entirely by the types of the function arguments (and the namespace of any template template argument). Typedef names and using-declarations used to specify the types do not contribute to this set.

This is somewhat unfortunate; it means that e.g. the code (adapted from ADL with typedefs from another namespace):

std::vector<int> v; count(v.begin(), v.end(), 0);

will depend for its validity and meaning on whether std::vector<T>::iterator is a typedef to T * or to some type in namespace std.

MWid · Accepted Answer · 2012-11-02 10:15:07Z

The main point to note is that a typedef does not introduce a new type, but is a synonym for another type. So d has type ns::data.

Now ADL applies and the function func will be found in the namespace ns.

Addition: To prevent ADL you can write (func)(d).

Collectives™ on Stack Overflow

Argument dependent name lookup and typedef

4 Answers 4

Comments

Comments

3.4.2 Argument-dependent name lookup [basic.lookup.argdep]

Comments

Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

Comments

3.4.2 Argument-dependent name lookup [basic.lookup.argdep]

Comments

Comments

Linked

Related