What does = + mean in C?

Question

I met =+ unlike the standard += today in some C code; I'm not quite sure what is going on here. I also could not find it in the documentation.

Answer 1

In ancient versions of C, =+ was equivalent to += . The remains of it were found along with the earliest dinosaur bones. Moreover, it doesn't really matter — it's just a = followed by + .

Answer 2

You can find evidence of the old notation in the 7th edition of UNIX Manual (Volume 2a) of January 1979, available on the Internet at http://cm.bell-labs.com/7thEdMan/ (not available from July 2015; version June 2015; now available through WayBack Machine at http://cm.bell-labs.com/7thEdMan/ - or at https://9p.io/7thEdMan/ ).

The chapter is called Dennis M. Ritchie's "C Reference Guide" and is in the PDF version of the manual, but not in the HTML version. The relevant part says:

7.14.1 lvalue = expression

The value of the expression replaces the value of the object referenced by lvalue. The operands need not be of the same type, but both must be int, char, float, double, or a pointer. If none of the operands is a pointer, the assignment occurs as expected, possibly with the preceding conversion of the expression to the right. When both operands are int or pointers of any kind, conversion never occurs; the value of the expression is simply stored in the object referenced by lvalue. In this way, pointers can be thrown that will throw exceptions when used.

7.14.2 lvalue = + expression
7.14.3 lvalue = - expression
7.14.4 lvalue = * expression
7.14.5 lvalue = / expression
7.14.6 lvalue =% expression
7.14.7 lvalue = >> expression
7.14.8 lvalue = << expression
7.14.9 lvalue = & expression
7.14.10 lvalue = ^ expression
7.14.11 lvalue = | expression

The behavior of an expression of the form '' E1 = op E2 can be deduced if we take it equivalent to '' E1 = E1 op E2; however, E1 is evaluated only once. Moreover, expressions like '' i = + p, in which a pointer is added to an integer, are prohibited.

---

There is a separate article by L. Rosler's Evolution C in UNIX® SYSTEM: Readings and Applications, Volume II, originally published by AT&T as a technical journal in October 1984, later published in 1987 by Prentice Hall (ISBN 0 -1 3-939845-7). One of the sections of this:

III. Incompatible change management

Inevitably, some of the changes that were made alter the semantics of existing valid programs. Those who support the various compilers used internally try to ensure that programmers have sufficient warning that such changes should take effect, and that the introduction of a new release of the compiler does not immediately compile all programs.

For example, in the earliest implementations, the ambiguous expression x=-1 interpreted as meaning "decrease x by 1". Now it is interpreted as "assign value -1 x". This change has occurred over three annual major releases. At first, the compiler and verifier of the lint program were changed to generate a message warning of the presence of an “old-fashioned” assignment operation, such as =- . Then the parsers were changed to new semantics, and compilers warned of an ambiguous assignment operation. Finally, warning messages have been eliminated.

Support for using "old-fashioned initialization"

 int x 1; 

(without equal sign) was dropped by a similar strategy. This helps the analyzer make more intelligent diagnostics of syntax errors.

As expected, some C users ignored warnings until the introduction of incompatible compilers forced them to choose between changing legacy source code or accepting maintenance of their compiler versions. But overall, the gradual change strategy was successful.

Answer 3

This is just an assignment followed by a unary plus.

 #include <stdio.h> int main() { int a; a =+ 5; printf("%d\n",a); return 0; } 

Seal "5". Change a =+ 5 to a =- 5 and type "-5". An easier way to read a =+ 5 is probably a = +5 .

Answer 4

This is an ancient non-existent += option. In modern compilers, this is equivalent to an assignment operator followed by a unary + character.

Answer 5

I think,

 a =+ 5; 

should be equivalent

 a = (+5); 

and therefore the code is very bad style.

I tried the following code and printed "5":

 #include <iostream> using namespace std; int main() { int a=2; a =+ 5; cout << a; } 

Answer 6

After reading your question, I just examined them. Let me tell you what I found. Tried this on gcc and turboc. Not sure in Visual Studio since I did not install it on my PC

  int main() { int a=6; a =+ 2; printf("%d",a); } o/p , a value is 2 int main() { int a=6; a =- 2; printf("%d",a); } o/p , a value is -2 

I don’t know about the other answers, because they said that this is an ancient version of C. But modern compilers consider them to be the value to be assigned (it is positive or negative, but nothing more), and these codes below make me more confident about it .

  int main() { int a=6; a =* 2; \\ Reporting an error inavlid type of argument of unary * printf("%d",a); } if *= is equal to =* then it should not report error but its throwing an error