2

I am a little confused about overloading rules,

let's say there are following literal operators,

unsigned long long operator "" _xx(unsigned long long cooked_literal_int); //1
unsigned long long operator "" _xx(const char * raw_literal_string); // 2
unsigned long long operator "" _xx(long double cooked_literal_double); // 3

if both 1, 2, & 3 are defined, the overloading is obvious,

13_xx //call 1
13.5_xx //call 3

if 1 & 2 are defined, 

13_xx //call 1
13.5_xx //call 2

if 2 & 3 are defined

13_xx // call 2 or 3??
13.5_xx // call 3

The confusion comes from latest c++0x standard n3225 2.14.8/3,

If L is a user-defined-integer-literal, let n be the literal without its ud-suffix. If S contains a literal operator with parameter type unsigned long long, the literal L is treated as a call of the form

operator "" X (n ULL)

Otherwise, S shall contain a raw literal operator or a literal operator template (13.5.8) but not both. If S contains a raw literal operator, the literal L is treated as a call of the form

operator "" X ("n")

Otherwise (S contains a literal operator template), L is treated as a call of the form

operator "" X <’c1’, ’c2’, ... ’ck’>()

where n is the source character sequence c1c2...ck.

This says that, if 1 is present (an unsigned long long parameter), 13_xx shall call 1, otherwise, 13_xx shall call 2. And from 13.5.8,

In particular, they are looked up like ordinary functions and function templates and they follow the same overload resolution rules.

From my understanding, if 1 is not present, 13_xx can be implicitly converted to double and call 3.

Therefore if 1 is not present, both 2 & 3 are somehow valid from the standard description.

I hope someone can help me clear my doubts. Many thanks.

ildjarn
  • 62,044
  • 9
  • 127
  • 211
user534498
  • 3,926
  • 5
  • 27
  • 52

1 Answers1

4

I believe that 13.5.8/7 clarifies this issue :

Note: literal operators and literal operator templates are usually invoked implicitly through user-defined literals (2.14.8). However, except for the constraints described above, they are ordinary namespace-scope functions and function templates. In particular, they are looked up like ordinary functions and function templates and they follow the same overload resolution rules.

From my understanding, regular overload resolution rules are only implied for literal operators when called outside an implicit invocation through user-defined literals.

So I think that if 2 & 3 are defined, 13_xx calls 2 (the raw literal operator).

icecrime
  • 74,451
  • 13
  • 99
  • 111
  • Thanks. So for user defined literals, the implicit invocation of these literal operator functions will not use any int-to-float, and also char-to-int and char-to-float type conversions. Only explicit invocation of these functions will try to apply overloading resolution. This makes sense to me. – user534498 Dec 08 '10 at 09:23
  • Sure it does. The phrase "they are looked up like ordinary functions and function templates and they follow the same overload resolution rules." Says just what it says. It doesn't state the things the questioner concluded. And it could also be entirely removed. It's non-normative text. The rules of 2.14.8/3 are clear - they are not undermined by overload resolution somehow. – Johannes Schaub - litb Dec 08 '10 at 11:14