Re: name lookup and unnamed namespaces
James Kanze schrieb:
The use of the operator<< is in the template code for
ostream_iterator, not in your code. In this case, the
operator<< will doubtlessly be a dependant name lookup (he sais,
without even looking at the source code). Dependant name lookup
does the lookup in two separate contexts: the context where the
template was defined (and it can never find your operator
there), and using ADL in the instantiation context. The fact
that it uses ADL only in the instantiation context means that
only names in a dependant namespace of one of the arguments can
be found: here in std (because of the std::ostream argument) and
in the global namespace (because of your class C). Since your
operator is in neither, it isn't found.
Yes, that is a very clear and complete explanation - much better
than mine.
The fact that in this second example, the function call is not
in a template. There is only one context for lookup, which is
where the function call is written. (Think of it for a minute.
The function call in ostream_iterator is in <iterator>. Your
operator hasn't been declared at all yet.) In this context,
names found by both normal lookup and ADL are considered; normal
lookup at the point of the call finds your function, and so it
works.
Hmmh, forgive me, but I don't understand your reasoning:
What do you mean with "the function call is not in a template"?
Let me replicate the calling point of the 2nd OP example here:
namespace N{
template <class T> struct K
{
void f(const T& t) { g(t); }
};
}
As I see it, g is called inside a member function of the
class template ::N::K. The call is under dependent lookup
conditions, because g is called unqualified with an argument
t which has type T, which is the template parameter. As far
as I see, this call fulfills all conditions of ADL.
Since I like to learn, I would like to present what I think
happens (or should happen), so please point out, what
is wrong in my argumentation. For easier analysis I
repeat the complete code added with some annotations:
namespace N {
template <class T> struct K {
void f(const T& t) { g(t); } // (a)
};
}
using namespace N;
class C {};
namespace {
void g(const C&) {}
}
// (b)
int main() {
K<C> k;
k.f(C());
}
The call of g at point (a) should be a dependent one,
because its argument t is of dependent on T, such we
should have all conditions for dependent lookup. Under
these conditions we should have 2 phase lookup. The
first phase uses ordinary lookup and does not find
any match here, because ordinary lookup takes everything
into account, that occurs lexically before (a). There
is nothing to find here (Note: In the case of the first
example the compiler could possibly find other overloads
of operator<< from namespace std at this stage, if these
were #included before the definition of
::std::ostream_iterator<T, ..>::operator=(const T&); But
this is an implementation-depended issue).
Since K has no member g, it is also not found as immediate
member of K.
In the second phase we have to consider the instantiation point.
According to instantiation rules, the POI of K<C> should occur
at the point (b). In this phase *only* ADL is taken into account,
that means, because C is of class type, that according to
3.4.2 p. 2:
- "its associated classes are: the class itself; the class of
which it is a member, if any; and its direct and indirect base
classes. Its associated namespaces are the namespaces
in which its associated classes are defined."
According to the following para 2a:
"If the ordinary unqualified lookup of the name finds the declaration
of a class member function, the associated namespaces and
classes are not considered."
we have to proceed with the seach, because there is no
function member ::N::K<..>::g found. These rules are explained as
"Otherwise the set of declarations found by the lookup of the
function name is the union of the set of declarations found using
ordinary unqualified lookup and the set of declarations found
in the namespaces and classes associated with the argument types."
The set of declarations found via ordinary lookup was empty.
C is defined in the global namespace, where we do not have
any ::g().
There indeed exists a function g() inside an unnamed
namespace, which should behave according to 7.3.1.1 p. 1
as-if a using directive would exist:
namespace "some_unique_identifier" {}
using namespace "some_unique_identifier";
namespace "some_unique_identifier" {
void g(const C&){}
}
Although at point (b) the function "some_unique_identifier"::g
*could* be seen (e.g. under the rules of ordinary lookup), this
case is explicitly exluded from ADL via 3.4.2 p 3:
"Any using-directives in the associated namespace are ignored."
At this point I don't see, how g could be found in this example.
Thank you very much for your explanation,
Daniel
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]