Unterschied zwischen a += b und a = a + b

In Java, ich Frage mich wirklich, gibt es einen Unterschied zwischen der Verwendung a += b; oder a = a + b; . Was sollte ich verwenden hauptsächlich? Ich weiß, das erste ist sowas wie Verknüpfung, aber funktioniert der compiler diese beiden Indikationen anders?

Bitte Sprache angeben.
Welche Sprache? In welchem Kontext? Abhängig von der Sprache, es kann auch abhängen von der Art der a und b.
look up "sytactic Zucker".
Siehe: stackoverflow.com/questions/8710619/java-operator
Die a+=b, was sinnvoll ist, präziser Auftrag, aber nicht unbedingt am einfachsten zu verstehen! Das hängt nur von Euch, denke ich.
Ich habe gerade überprüft die Verbindung. "wow". diese waren wirklich anders. Dank

InformationsquelleAutor El3ctr0n1c4 | 2012-01-07

java operators

16

Sehen die Java language specification, 15.26.2 Zusammengesetzte Zuweisungsoperatoren

Zitieren die einschlägigen Teile:

Eine zusammengesetzte Zuweisung Ausdruck der form E1 op= E2 ist gleichbedeutend
E1 = (T)((E1) op (E2)), wobei T der Typ von E1, außer, dass E1
wird nur einmal ausgewertet.
```
short x = 3;
x += 4.6;
```
und Ergebnisse in x, das den Wert 7, weil es ist äquivalent zu:
```
short x = 3;
x = (short)(x + 4.6);
```
So ist es mehr als syntaktischer Zucker, wie
```
int x = 1;
long a = 2l;
x+= a;
```
kompiliert, wo
```
int x =1;
long a =2l;
x = x+a;
```
gibt Ihnen einen compile-Fehler, wie diskutiert wurde hier auf StackOverflow vor kurzem
- Vielen Dank für Ihre Antwort, Dies ist, was ich wirklich will..
- Wie unterscheidet sich dies von dem link, der bisher durch das Mystische in den Kommentaren zu der ursprünglichen Frage?
- Ich würde sagen, es ist anders, dass diese Antwort gibt, bevor Sie in irgendeiner Weise Bearbeiten, dass es mehr als syntaktischer Zucker, wie wurde ausgiebig diskutiert hier vor ein paar Tagen. Und er hat den link zu diesen aktuellen Fragen.
InformationsquelleAutor Robin
3

abhängig von der Sprache, aber in c# ist es sehr leicht effizienteren Verwendung von a += b;.

a wird nur einmal ausgewertet.

in a = a + b, a ist zweimal beurteilt.

http://msdn.microsoft.com/en-us/library/sa7629ew.aspx

InformationsquelleAutor Evert
3

Nur syntaktischen Zucker in den meisten Sprachen, die ich kenne, das wäre auch c, c++, C#, java, javascript..

deutlichen Unterschied gemerkt von Zikade in Bezug auf c++:

Auf die numerischen Typen (int und Freunde), gibt es keinen Unterschied.
Auf Benutzer-definierten Klassen kann es ein Unterschied sein.
Eine Bemerkenswerte, man wäre D3DXVECTOR3 von DirectX, zum Beispiel.
Mit + zusammenstellten, ein temporäres Objekt, während das += nicht wäre.
Letzteres ist etwa 30% schneller.
- Es ist nicht syntaktische Zucker in C++.
- Kann eine überschriebene operator in C++ anders? Das ist, überschreiben Sie + in der einen und += andere Möglichkeit?
- Ja. (Und ich wünschte, es konnte nicht sein.)
- es hat eine Weile gewesen, da ich C++, könnten Sie mir bitte sagen, was der Unterschied zwischen a += b; a = a + b;?
- ja, wenn es außer Kraft gesetzt, aber in seinen default-Zustand ist, ist es nicht im Prinzip das gleiche, oder bin ich etwas fehlt?
- Auf die numerischen Typen (int und Freunde), gibt es keinen Unterschied. Auf Benutzer-definierten Klassen kann es ein Unterschied sein. Eine Bemerkenswerte, man wäre D3DXVECTOR3 von DirectX, zum Beispiel. Mit + würde bauen ein temporäres Objekt, während += würde nicht. Letzteres ist etwa 30% schneller.
- Danke, tun Sie etwas dagegen, wenn ich dies nur Hinzugefügt, um die Antwort auf Vollständigkeit?
- Fühlen Sie sich frei, dies zu tun.
InformationsquelleAutor Bassam Mehanni
2

In den meisten Sprachen, die Unterstützung dieser notation a = a + b ist das gleiche wie a += b, aber es ist nicht immer der Fall.

Hier ist ein Beispiel in Python (mit Numpy):
```
>>> import numpy as np
>>> a = np.array([1])
>>> b = np.array([2])
>>> c = a
>>> a = a + b
>>> print a
[3]
>>> print c
[1]
```
Hier a = a + b erstellt ein neues array für a + b und speichert es in a. c, die war mit die gleiche Referenz wie die ersten a hält immer noch den ersten Arrays (mit Wert 1).
```
>>> a = np.array([1])
>>> b = np.array([2])
>>> c = a
>>> a += b
>>> print a
[3]
>>> print c
[3]
```
Hier a += b re-verwendet den ersten array a. Als ein Ergebnis, da beide a und c auf dasselbe array verweisen, die beide a und c geändert werden.

InformationsquelleAutor Bruno
2

Zusätzlich zu allem oben gesagt, Sie können auch die folgenden shortcuts:

- Operator (+=)
```
x+=y;
```
gleiche wie:
```
x=x+y;
```
Operator (-=)
```
x-=y;
```
gleiche wie:
```
x=x-y;
```
- Operator (*=)
```
x*=y;
```
gleiche wie:
```
x=x*y;
```
- Operator (/=)
```
x/=y;
```
gleiche wie:
```
x=x/y;
```
- Operator (%=)
```
x%=y;
```
gleiche wie :
```
x=x%y;
```
- Operator (&=)
```
x&=y;
```
gleiche wie :
```
x=x&y;
```
- Operator (|=)
```
x|=y;
```
gleiche wie :
```
x=x|y;
```
- Operator (^=)
```
x^=y; 
```
gleiche wie :
```
x=x^y;
```
- Operator (>>=)
```
x>>=y;
```
gleiche wie
```
result=x>>y;
```
Die gleiche operation-operator (<<=) und-operator (>>>=) .

InformationsquelleAutor Vladislav Zakatov
1

In den meisten Fällen endet es damit, die gleiche Sache.

In einigen Sprachen += ist ein separater operator, der überladen werden kann, etwas anderes zu tun.

Z.B. in Python mit Listen, das Verhalten ist anders (ich lernte auf die harte Weise)
```
a = [1]
b = [2]
z = a
a = a + b
#z is not modified

a = [1]
b = [2]
z = a
a += b
# z is modified
```
- Siehe die Antwort unten ( stackoverflow.com/questions/8773349/... ) für die Erklärung.
InformationsquelleAutor Davy8

Ich'ld lieber a += b über a = a + b. Vor allem ist es weniger zu schreiben, zweitens ist es klarer, was Los ist. Und wenn man über C++ - Klassen und es könnte effizienter sein, mit +=. Werfen Sie einen Blick auf dieses Beispiel:

class C {
public:
    const C &operator =(const C &rhs) { printf("=\n"); x = rhs.x; return *this; }
    C operator +(const C &rhs) { printf("+\n"); C c; c.x = x + rhs.x; return c; }
    C &operator +=(const C &rhs) { printf("+=\n"); x += rhs.x; return *this; }

    int x;
};
C a, b;
a.x = 1;
b.x = 2;
a += b;     //same as a.operator+=(b)
a = a + b;  //same as a.operator=(a.operator+(b))

Wie Sie sehen können, mit operator += Sie haben weniger temporäre Objekte und bessere Leistung.

InformationsquelleAutor Werner Henze

0

Es ist compiler- (und damit von der Implementierung) definiert, ob der compiler erzeugt anderen code aus den oben genannten Quellen, aber eins ist sicher: a += b ist, soll ein einfacher short-hand notation a = a + b. (das ist, warum, im Allgemeinen, ein vernünftiger compiler erzeugen würde, den gleichen code für beide).

InformationsquelleAutor
0

Nein, der compiler macht keinen Unterschied zwischen den beiden im Ausgang. Der einzige Unterschied ist bei der Analyse und möglicherweise in der lexikalischen Analyse (je nach ausbau). Sie würden in der Regel verwenden Sie das Tastaturkürzel form +=. Es ist nur syntaktischer Zucker.

InformationsquelleAutor Ry-

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.