What is the purpose of a unary "+" before a call to std::numeric_limits members?

Question

I saw this example in cppreference's documentation for std::numeric_limits

#include <limits>
#include <iostream>

int main() 
{
    std::cout << "type\tlowest()\tmin()\t\tmax()\n\n";

    std::cout << "uchar\t"
              << +std::numeric_limits<unsigned char>::lowest() << '\t' << '\t'
              << +std::numeric_limits<unsigned char>::min() << '\t' << '\t'
              << +std::numeric_limits<unsigned char>::max() << '\n';
    std::cout << "int\t"
              << std::numeric_limits<int>::lowest() << '\t'
              << std::numeric_limits<int>::min() << '\t'
              << std::numeric_limits<int>::max() << '\n';
    std::cout << "float\t"
              << std::numeric_limits<float>::lowest() << '\t'
              << std::numeric_limits<float>::min() << '\t'
              << std::numeric_limits<float>::max() << '\n';
    std::cout << "double\t"
              << std::numeric_limits<double>::lowest() << '\t'
              << std::numeric_limits<double>::min() << '\t'
              << std::numeric_limits<double>::max() << '\n';
}

I don't understand the "+" operator in

<< +std::numeric_limits<unsigned char>::lowest()

I have tested it, replaced it with "-", and that also worked. What is the use of such a "+" operator?

This question would not *need* to be asker if the writer of the code cares to explain what it means or use an explicit cast instead... — user202729, Sep 03 '18 at 13:57
if you replace with `-` then the outputs won't be the correct values for the limits — phuclv, Sep 03 '18 at 18:28
For the record, if you want to Google this kind of thing in yourself, this is called the "unary plus" operator -- it's unary because it takes a single value (in this case, the thing right after it), and "plus" is the Google-friendly way to say `+`. In this case, your query would probably be "c++ unary plus". It's... not exactly intuitive, and you still have to learn to read the documentation that you'll find, but IMO it's a useful skill to cultivate. — Nic, Sep 04 '18 at 19:46

score 140 · Accepted Answer · answered Sep 03 '18 at 08:46

The output operator << when being passed a char (signed or unsigned) will write it as a character.

Those function will return values of type unsigned char. And as noted above that will print the characters those values represent in the current encoding, not their integer values.

The + operator converts the unsigned char returned by those functions to an int through integer promotion. Which means the integer values will be printed instead.

An expression like +std::numeric_limits<unsigned char>::lowest() is essentially equal to static_cast<int>(std::numeric_limits<unsigned char>::lowest()).

score 37 · Answer 2 · answered Sep 03 '18 at 08:46

+ is there to turn the unsigned char into an int. The + operator is value preserving, but it has the effect of inducing integral promotion on its operand. It's to make sure you see a numerical value instead of some (semi-)random character that operator << would print when given a character type.

score 20 · Answer 3 · edited Sep 04 '18 at 19:23

Just to add a reference to the answers already given. From the CPP standard working draft N4713:

8.5.2.1 Unary operators
...

The operand of the unary + operator shall have arithmetic, unscoped enumeration, or pointer type and the result is the value of the argument. Integral promotion is performed on integral or enumeration operands. The type of the result is the type of the promoted operand.

And char, short, int, and long are integral types.

phuclv · Answer 4 · 2018-09-05T05:36:00.453

Without + the result will be different. The following snippet outputs a 97 instead of a a

char ch = 'a';
std::cout << ch << ' ' << +ch << '\n';

The reason is because different overloads prints different types of data. There's no basic_ostream& operator<<( char value ); overload for std::basic_ostream and it's explained at the end of the page

Character and character string arguments (e.g., of type char or const char*) are handled by the non-member overloads of operator<<. Attempting to output a character using the member function call syntax (e.g., std::cout.operator<<('c');) will call one of overloads (2-4) and output the numerical value. Attempting to output a character string using the member function call syntax will call overload (7) and print the pointer value instead.

The non-member overload that will be called when you pass a char variable is

template< class CharT, class Traits> basic_ostream<CharT,Traits>& operator<<(
    basic_ostream<CharT,Traits>& os, char ch );

which prints out the character at the codepoint ch

So basically if you pass char, signed char or unsigned char directly to the stream it'll print the character out. If you try removing the + on the above lines you'll see that it prints some "strange" or non-visible characters which is not what one would expect

If you want their numerical values instead you must call the overload for short, int, long or long long. The easiest way to do this is promoting from char to int with unary plus +. That's one of the rare useful applications of the unary plus operator. An explicit cast to int will also work

There are many people who faced that problem on SO like

Did you mean unary _plus_, not minus? – Ruslan Sep 03 '18 at 16:39 — Ruslan, Sep 03 '18 at 16:39

What is the purpose of a unary "+" before a call to std::numeric_limits members?

4 Answers4