9

In the C++ code below, foobar is defined first for a single double parameter, and then again for a single parameter of type Foo. Both are defined within the global namespace.

Within the one namespace, a further overload of foobar is defined, with a single parameter of type Bar. From this version of foobar, an unqualified call to foobar with a double argument (42.0) will fail. A similar call to foobar, this time qualified with the (::) scope resolution operator, also with a double argument, will though succeed.

On the other hand, an unqualified call to foobar, with an argument of type Foo, succeeds. A call to foobar with a Foo argument, qualified by the scope resolution operator, also succeeds.

Why do the two scenarios behave differently? I use both gcc 4.7 and clang++ 3.2.

struct Foo {};
struct Bar {};

double foobar(double x) { return x; }
Foo    foobar(Foo f)    { return f; }

namespace one {

  Bar foobar(Bar b) {
    //foobar(42.0); // error: can't convert to Bar
    ::foobar(42.0);

    Foo f;
      foobar(f);    // no problem
    ::foobar(f);
    return b;
  }
};
user2023370
  • 10,488
  • 6
  • 50
  • 83

1 Answers1

8

Argument dependent lookup.

In the call foobar(f) functions from the namespace of Foo will be considered.

Doesn't work for double because that type is not declared in any namespace.

Community
  • 1
  • 1
Bo Persson
  • 90,663
  • 31
  • 146
  • 203
  • As an addition to the last sentence: Unqualified name lookup stops as soon as it finds a matching *name*, first considering the local scopes and only if it doesn't find any name there it will search the upper and global scopes. – Xeo Aug 08 '12 at 22:09
  • @Xeo: Would that not imply that the call to `foobar(f)` would fail upon finding `foobar(Bar b)`? – user2023370 Aug 08 '12 at 22:39
  • @user643722: No. Since `f` is of class-type, ADL is done too, in addition to unqualified lookup. – Xeo Aug 09 '12 at 07:32