What is the purpose of the unary plus (+) operator in C?

Question

In C, it\'s legal to write something like:

int foo = +4;

However, as far as I can tell, the unary plus (+) in +4

Answer 1

Not precisely a no-op

The unary + operator does only one thing: it applies the integer promotions. Since those would occur anyway if the operand were used in an expression, one imagines that unary + is in C simply for symmetry with unary -.

It's difficult to see this in action because the promotions are so generally applied.

I came up with this:

printf("%zd\n", sizeof( (char) 'x'));
printf("%zd\n", sizeof(+(char) 'x'));

which (on my Mac) prints

1
4

Answer 2

You can use it as a sort of assertion that an expression has arithmetic type:

#define CHECK_ARITHMETIC(x) (+(x))

This will generate a compile-time error if x evaluates to (say) a pointer.

That is about the only practical use I can think of.

Answer 3

As per the C90 standard in 6.3.3.3:

The result of the unary + operator is the value of its operand. The integral promotion is performed on the operand. and the result has the promoted type.

and

The operand of the unary + or - operator shall have arithmetic type..

Answer 4

I found two things that unary + operator do is

• integer promotion
• turning lvalue into rvalue

integer promotion example:

#include <stdio.h>

int main(void) {

    char ch;
    short sh;
    int i;
    long l;

    printf("%d %d %d %d\n",sizeof(ch),sizeof(sh),sizeof(i),sizeof(l));
    printf("%d %d %d %d\n",sizeof(+ch),sizeof(+sh),sizeof(+i),sizeof(+l));
    return 0;
}

Typical output (on 64-bit platform):

1 2 4 8
4 4 4 8

turning lvalue into rvalue example:

int i=0,j;

j=(+i)++; // error lvalue required

Answer 5

Pretty much. It's mainly present for completeness, and to make constructions like this look a little cleaner:

int arr[] = {
    +4,
    -1,
    +1,
    -4,
};

Answer 6

There's one very handy use of the unary plus operator I know of: in macros. Suppose you want to do something like

#if FOO > 0

If FOO is undefined, the C language requires it be replaced by 0 in this case. But if FOO was defined with an empty definition, the above directive will result in an error. Instead you can use:

#if FOO+0 > 0

And now, the directive will be syntactically correct whether FOO is undefined, defined as blank, or defined as an integer value.

Of course whether this will yield the desired semantics is a completely separate question, but in some useful cases it will.

Edit: Note that you can even use this to distinguish the cases of FOO being defined as zero versus defined as blank, as in:

#if 2*FOO+1 == 1
/* FOO is 0 */
#else
/* FOO is blank */
#endif