Until today, I thought that for example:

    i += j;

Was just a shortcut for:

    i = i + j;

But if we try this:

    int i = 5;
    long j = 8;

Then `i = i + j;` will not compile but `i += j;` will compile fine.

Does it mean that in fact `i += j;` is a shortcut for something like this
`i = (type of i) (i + j)`?

    


Why don&#39;t Java&#39;s +=, -=, *=, /= compound assignment operators require casting?

 - What does *copying an object* mean?
 - What are the *copy constructor* and the *copy assignment operator*?
 - When do I need to declare them myself?
 - How can I prevent my objects from being copied?

What is The Rule of Three?

What is this idiom and when should it be used? Which problems does it solve? Does the idiom change when C++11 is used?

Although it&#39;s been mentioned in many places, we didn&#39;t have any singular &quot;what is it&quot; question and answer, so here it is. Here is a partial list of places where it was previously mentioned:

 * [What are your favorite C++ Coding Style idioms:  Copy-swap](https://stackoverflow.com/questions/276173/what-are-your-favorite-c-coding-style-idioms/2034447#2034447)
 * [Copy constructor and = operator overload in C++: is a common function possible?](https://stackoverflow.com/questions/1734628/copy-constructor-and-operator-overload-in-c-is-a-common-function-possible/1734640#1734640)
 * [What is copy elision and how it optimizes copy-and-swap idiom](https://stackoverflow.com/questions/2143787/what-is-copy-elision-and-how-it-optimizes-copy-and-swap-idiom)
 * [C++: dynamically allocating an array of objects?](https://stackoverflow.com/questions/255612/c-dynamically-allocating-an-array-of-objects/255744#255744)

What is the copy-and-swap idiom?

What are the differences between the assignment operators `=` and `&lt;-` in R? 

I know that operators are slightly different, as this example shows

    x &lt;- y &lt;- 5
    x = y = 5
    x = y &lt;- 5
    x &lt;- y = 5
    # Error in (x &lt;- y) = 5 : could not find function &quot;&lt;-&lt;-&quot;

But is this the only difference? 


What are the differences between &quot;=&quot; and &quot;&lt;-&quot; assignment operators in R?

I&#39;m having a little trouble understanding the pass-by-reference properties of `data.table`. Some operations seem to &#39;break&#39; the reference, and I&#39;d like to understand exactly what&#39;s happening.

On creating a `data.table` from another `data.table` (via `&lt;-`, then updating the new table by `:=`, the original table is also altered. This is expected, as per:

`?data.table::copy`
and [stackoverflow: pass-by-reference-the-operator-in-the-data-table-package](&lt;https://stackoverflow.com/questions/8030452/pass-by-reference-the-operator-in-the-data-table-package&gt;)

Here&#39;s an example:

    library(data.table)

    DT &lt;- data.table(a=c(1,2), b=c(11,12))
    print(DT)
    #      a  b
    # [1,] 1 11
    # [2,] 2 12

    newDT &lt;- DT        # reference, not copy
    newDT[1, a := 100] # modify new DT

    print(DT)          # DT is modified too.
    #        a  b
    # [1,] 100 11
    # [2,]   2 12

However, if I insert a non-`:=` based modification between the `&lt;-` assignment and the `:=` lines above, `DT` is now no longer modified:

    DT = data.table(a=c(1,2), b=c(11,12))
    newDT &lt;- DT        
    newDT$b[2] &lt;- 200  # new operation
    newDT[1, a := 100]

    print(DT)
    #      a  b
    # [1,] 1 11
    # [2,] 2 12

So it seems that the `newDT$b[2] &lt;- 200` line somehow &#39;breaks&#39; the reference. I&#39;d guess that this invokes a copy somehow, but I would like to understand fully how R is treating these operations, to ensure I don&#39;t introduce potential bugs in my code.

I&#39;d very much appreciate if someone could explain this to me.

Understanding exactly when a data.table is a reference to (vs a copy of) another data.table

I&#39;m using R 2.8.1 and it is possible to use both `=` and `&lt;-` as variable assignment operators. What&#39;s the difference between them? Which one should I use?

What&#39;s the difference between `=` and `&lt;-` in R?

What does the `=&amp;` (equals-ampersand) assignment operator do in PHP?

Is it deprecated?


Reference assignment operator in PHP, =&amp;

I have a class `B` with a set of constructors and an assignment operator.

Here it is:

    class B
    {
     public:
      B();
      B(const string&amp; s);
      B(const B&amp; b) { (*this) = b; }
      B&amp; operator=(const B &amp; b);

     private:
      virtual void foo();
      // and other private member variables and functions
    };

I want to create an inheriting class `D` that will just override the function `foo()`, and no other change is required.

But, I want `D` to have the same set of constructors, including copy constructor and assignment operator as `B`:

    D(const D&amp; d) { (*this) = d; }
    D&amp; operator=(const D&amp; d);

Do I have to rewrite all of them in `D`, or is there a way to use `B`&#39;s constructors and operator? I would especially want to avoid rewriting the assignment operator because it has to access all of `B`&#39;s private member variables.

How to use base class&#39;s constructors and assignment operator in C++?

Is there a magic method that can overload the assignment operator, like `__assign__(self, new_value)`?

I&#39;d like to forbid a re-bind for an instance:

    class Protect():
      def __assign__(self, value):
        raise Exception(&quot;This is an ex-parrot&quot;)

    var = Protect()  # once assigned...
    var = 1          # this should raise Exception()

Is it possible? Is it insane? Should I be on medicine?

Is it possible to overload Python assignment?

I have a long set of comparisons to do in Java, and I&#39;d like to know if one or more of them come out as true. The string of comparisons was long and difficult to read, so I broke it up for readability, and automatically went to use a shortcut operator `|=` rather than `negativeValue = negativeValue || boolean`.

    boolean negativeValue = false;
    negativeValue |= (defaultStock &lt; 0);
    negativeValue |= (defaultWholesale &lt; 0);
    negativeValue |= (defaultRetail &lt; 0);
    negativeValue |= (defaultDelivery &lt; 0);
I expect `negativeValue` to be true if any of the default&amp;lt;something&amp;gt; values are negative. Is this valid? Will it do what I expect? I couldn&#39;t see it mentioned on Sun&#39;s site or stackoverflow, but Eclipse doesn&#39;t seem to have a problem with it and the code compiles and runs.

---

Similarly, if I wanted to perform several logical intersections, could I use `&amp;=` instead of `&amp;&amp;`?

Shortcut &quot;or-assignment&quot; (|=) operator in Java

So for binary operators on booleans, Java has `&amp;`, `|`, `^`, `&amp;&amp;` and `||`.

Let&#39;s summarize what they do briefly here:

 * &lt;a href=&quot;http://java.sun.com/docs/books/jls/third_edition/html/expressions.html#15.22.2&quot;&gt;JLS 15.22.2 Boolean Logical Operators &amp;, ^, and |&lt;/a&gt;
 * &lt;a href=&quot;http://java.sun.com/docs/books/jls/third_edition/html/expressions.html#15.23&quot;&gt;JLS 15.23 Conditional-And Operator &amp;&amp;&lt;/a&gt; 
 * &lt;a href=&quot;http://java.sun.com/docs/books/jls/third_edition/html/expressions.html#15.24&quot;&gt;JLS 15.24 Conditional-Or Operator ||&lt;/a&gt;

&gt; For `&amp;`, the result value is `true` if both operand values are `true`; otherwise, the result is `false`.
&gt;
&gt; For `|`, the result value is `false` if both operand values are `false`; otherwise, the result is `true`.
&gt;
&gt; For `^`, the result value is `true` if the operand values are different; otherwise, the result is `false`.
&gt;
&gt; The `&amp;&amp;` operator is like `&amp;` but evaluates its right-hand operand only if the value of its left-hand operand is `true`.
&gt;
&gt; The `||` operator is like `|`, but evaluates its right-hand operand only if the value of its left-hand operand is `false`.

Now, among all 5, 3 of those have compound assignment versions, namely `|=`, `&amp;=` and `^=`. So my question is obvious: why doesn&#39;t Java provide `&amp;&amp;=` and `||=` as well? I find that I need those more than I need `&amp;=` and `|=`.

And I don&#39;t think that &quot;because it&#39;s too long&quot; is a good answer, because Java has `&gt;&gt;&gt;=`. There must be a better reason for this omission.

----

From &lt;a href=&quot;http://java.sun.com/docs/books/jls/third_edition/html/expressions.html#15.26&quot;&gt;15.26 Assignment Operators&lt;/a&gt;:

&gt; There are 12 assignment operators; [...] `= *= /= %= += -= &lt;&lt;= &gt;&gt;= &gt;&gt;&gt;= &amp;= ^= |=`

----

A comment was made that if `&amp;&amp;=` and `||=` were implemented, then it would be the only operators that do not evaluate the right hand side first. I believe this notion that a compound assignment operator evaluates the right hand side first is a mistake.

From &lt;a href=&quot;http://java.sun.com/docs/books/jls/third_edition/html/expressions.html#15.26.2&quot;&gt;15.26.2 Compound Assignment Operators&lt;/a&gt;:

&gt; A compound assignment expression of the form `E1 op= E2` is equivalent to `E1 = (T)((E1) op (E2))`, where `T` is the type of `E1`, except that `E1` is evaluated only once. 
&gt; 

As proof, the following snippet throws a `NullPointerException`, not an `ArrayIndexOutOfBoundsException`.

		int[] a = null;
		int[] b = {};
		a[0] += b[-1];



Why doesn&#39;t Java have compound assignment versions of the conditional-and and conditional-or operators? (&amp;&amp;=, ||=)

What is the motivation for Scala assignment evaluating to Unit rather than the value assigned?

A common pattern in I/O programming is to do things like this:

    while ((bytesRead = in.read(buffer)) != -1) { ...

But this is not possible in Scala because...

    bytesRead = in.read(buffer)

.. returns Unit, not the new value of bytesRead.

Seems like an interesting thing to leave out of a functional language.
I am wondering why it was done so?

What is the motivation for Scala assignment evaluating to Unit rather than the value assigned?

In C++, the concept of returning reference from the copy assignment operator is unclear to me. Why can&#39;t the copy assignment operator return a copy of the new object? In addition, if I have class `A`, and the following:

    A a1(param);
    A a2 = a1;
    A a3;
    
    a3 = a2; //&lt;--- this is the problematic line

The `operator=` is defined as follows:

    A A::operator=(const A&amp; a)
    {
    	if (this == &amp;a)
    	{
    		return *this;
    	}
    	param = a.param;
    	return *this;
    }

Why must the copy assignment operator return a reference/const reference?

In Java, I understand that assignment evaluates to the value of the right operand, so statements like `x == (y = x)` evaluate to `true`.

This code, however, outputs `false`.

    public static void main(String[]args){
        String x = &quot;hello&quot;;
        String y = &quot;goodbye&quot;;
        System.out.println(x.equals(x = y));
    }


Why is this? In my understanding, it first evaluates `(x = y)`, which assigns `x` the value of `y`, and then returns the value of `y`. Then `x.equals(y)` is evaluated, which should be `true` since `x` and `y` should share the same references now, but instead, I get `false`. 

[![Screenshot showing the source and that the output is &quot;false&quot;][1]][1]


  [1]: https://i.stack.imgur.com/6YH2a.png


What is happening here?

Java assignment operator execution

We have equivalent assignment operators for all Logical operators, Shift operators, Additive operators and all Multiplicative operators.

Why did the logical operators get left out?
Is there a good technical reason why it is hard?

Why are there no ||= or &amp;&amp;= operators in C#?

What is the difference between the following Python expressions:

    # First:

    x,y = y,x+y

    # Second:

    x = y
    y = x+y

*First* gives different results than *Second*.

e.g.,

*First:*

    &gt;&gt;&gt; x = 1
    &gt;&gt;&gt; y = 2
    &gt;&gt;&gt; x,y = y,x+y
    &gt;&gt;&gt; x
    2
    &gt;&gt;&gt; y
    3

*Second:*

    &gt;&gt;&gt; x = 1
    &gt;&gt;&gt; y = 2
    &gt;&gt;&gt; x = y
    &gt;&gt;&gt; y = x+y
    &gt;&gt;&gt; x
    2
    &gt;&gt;&gt; y
    4

*y* is 3 in *First* and 4 in *Second*

Multiple assignment and evaluation order in Python

If I override `operator=` will the copy constructor automatically use the new operator? Similarly, if I define a copy constructor, will `operator=` automatically &#39;inherit&#39; the behavior from the copy constructor?

The copy constructor and assignment operator

This is a question I&#39;ve been mildly irritated about for some time and just never got around to search the answer to.

However I thought I might at least ask the question and perhaps someone can explain.

Basically many languages I&#39;ve worked in utilize syntactic sugar to write (using syntax from C++):

    int main() {
        int a = 2;
        a += 3; // a=a+3
    }

while in lua the `+=` is not defined, so I would have to write `a=a+3`, which again is all about syntactical sugar. when using a more &quot;meaningful&quot; variable name such as: `bleed_damage_over_time` or something it starts getting tedious to write: 

    bleed_damage_over_time = bleed_damage_over_time + added_bleed_damage_over_time 

instead of: 

    bleed_damage_over_time += added_bleed_damage_over_time

So I would like to know not how to solve this if you don&#39;t have a nice solution, in that case I would of course be interested in hearing it; but rather why lua doesn&#39;t implement this syntactical sugar.


Lua operators, why isn&#39;t +=, -= and so on defined?

Why does the regular assignment statement (say,  `x = 5`) return the value assigned (`5` in this case), while the assignment combined with a variable declaration (`var x = 5`) returns `undefined`?

I got the return values by executing these statements in the Chrome browser&#39;s Javascript console:

    &gt; var x = 5;
    undefined
    &gt; y = 5;
    5


Value returned by the assignment

I was reading through this [nice answer][1] regarding the &quot;Rule-of-five&quot; and I&#39;ve noticed something that I don&#39;t recall seeing before:

    class C {
      ...
      C&amp; operator=(const C&amp;) &amp; = default;
      C&amp; operator=(C&amp;&amp;) &amp; = default;
      ...
    };

What is the purpose of the `&amp;` character placed in front of `= default` for the copy assignment operator and for the move assignment operator? Does anyone have a reference for this?


  [1]: https://stackoverflow.com/a/4782927/1174378

All Assignment Operator Solutions on Gang of Coders

Total of 20 Assignment Operator Solutions

Why don't Java's +=, -=, *=, /= compound assignment operators require casting?

What is The Rule of Three?

What is the copy-and-swap idiom?

What are the differences between "=" and "<-" assignment operators in R?

Understanding exactly when a data.table is a reference to (vs a copy of) another data.table

What's the difference between `=` and `<-` in R?

Reference assignment operator in PHP, =&

How to use base class's constructors and assignment operator in C++?

Is it possible to overload Python assignment?

Shortcut "or-assignment" (|=) operator in Java

Why doesn't Java have compound assignment versions of the conditional-and and conditional-or operators? (&&=, ||=)

What is the motivation for Scala assignment evaluating to Unit rather than the value assigned?

Why must the copy assignment operator return a reference/const reference?

Java assignment operator execution

Why are there no ||= or &&= operators in C#?

Multiple assignment and evaluation order in Python

The copy constructor and assignment operator

Lua operators, why isn't +=, -= and so on defined?

Value returned by the assignment

What does an ampersand after this assignment operator mean?