RealView Compilation Tools Compiler Reference Guide - ARM ...

C and C++ Implementation Details
namespace M {
int x = 99;
double g(double);
N::A ai;
int i = ai.f(0);
int i2 = ai.f();
N::A ad;
double d = ad.f(0);
double d2 = ad.f();
}
// N::A::f(int) calls N::g(int)
// N::A::f() returns 0 (= N::x)
// N::A::f(double) calls M::g(double)
// N::A::f() also returns 0 (= N::x)
The lookup of names in template instantiations does not conform to the rules in the
standard in the following respects:
• Although only names from the template definition context are considered for
names that are not functions, the lookup is not limited to those names visible at
the point where the template is defined.
• Functions from the context where the template is referenced are considered for all
function calls in the template. Functions from the referencing context are only
visible for dependent function calls.
Argument-dependent lookup
When argument-dependent lookup is enabled, functions that are made visible using
argument-dependent lookup can overload with those made visible by normal lookup.
The standard requires that this overloading occur even when the name found by normal
lookup is a block extern declaration. The compiler does this overloading, but in default
mode, argument-dependent lookup is suppressed when the normal lookup finds a block
extern.
This means a program can have different behavior, depending on whether it is compiled
with or without argument-dependent lookup, even if the program makes no use of
namespaces. For example:
struct A { };
A operator+(A, double);
void f()
{
A a1;
A operator+(A, int);
a1 + 1.0;
// calls operator+(A, double) with arg-dependent lookup
} // enabled but otherwise calls operator+(A, int);
ARM DUI 0348A Copyright © 2007, 2010 ARM Limited. All rights reserved. 5-17
Non-Confidential