Concepto básico

Disculpe alguien sabe que significa esta expresión: c+=1; ó i+=c; gracias si alguien me puede decir ke significan o que hacen.

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.

Mi chavo, búscale bien :)

 

▼ Aquí está un video con una explicación del asunto:

img

Tutorial Java - 7 - Asignaciones Compuestas


Google es tu mejor amigo. Como dijo una vez José Manuel:

Mi chavo, búscale bien :)

Ja, ja.

Disculpe Asted

~~~

Imagen de ezamudio

concepto viejo

Esto viene de C (y no sé si de antes, de hecho).

Estás haciendo suma y asignación en un solo paso. a+=b es una manera más corta de decir a=a+b, pero la primera permite además al compilador optimizar a menos instrucciones en bytecode. Se puede hacer con casi todos los operadores: a-=b, a*=b, a/=b e incluso con los de bits/boolean: a|=b, a&=b, a^=b etc.

Es una abreviación de  c =

Es una abreviación de

 c = c + 1;

Y de

i = i + c;

@jpaul es probable que YoMismo no supiera el nombre del término que tenía que buscar y parte de su búsqueda es precisamente preguntar aquí.

Imagen de ezamudio

c+=1

Y de hecho los casos específicos de c=c+1 y c=c-1 tienen otra abreviación/optimización: c++ y c--, y la variante ++c y --c. Eso viene de C (o antes), y se traducía a una sola instrucción de ensamblador de incrementar un registro. La diferencia entre c++ y ++c es que c++ incrementa el registro pero devuelve el valor anterior, y ++c incrementa el registro y luego devuelve el valor (por lo que devuelve el valor ya incrementado). De modo que:

int a=1;
int b=a++;
int c=++a;

a vale 1, b vale 1 y c vale 3.

a += b, donde b es literal entero

 

Al parecer a += b es una especie de incremento en Java cuando b es un literal entero. A saber:

Java:

  1. public class Main {
  2.  
  3.     public static void main(String[] args) {
  4.         int a, b, c;
  5.         a = 0;
  6.         b = 0;
  7.         a = a + 10;
  8.         b += 10;
  9.         c = a++;
  10.         c = ++b;
  11.         c += a + b;
  12.     }
  13.  
  14. }

bytecode:

  1. /* ******************************************** */
  2. /* Generated by Dr. Garbage Bytecode Visualizer */
  3. /* <a href="http://www.drgarbage.com" title="http://www.drgarbage.com">http://www.drgarbage.com</a>                     */
  4. /* Version: 4.5.0.201508311741                  */
  5. /* Class retrieved from: Filesystem             */
  6. /* Retrieved on: 2015-09-18 23:05:50.957        */
  7. /* ******************************************** */
  8.  
  9. /* class file format version 52.0 (java 1.8) */
  10.  
  11. public class Main {
  12.  
  13.     /* compiled from Main.java */
  14.  
  15.     public Main() {
  16.         /* L1 */
  17.         0 aload_0;                /* this */
  18.         1 invokespecial 8;        /* java.lang.Object() */
  19.         4 return;
  20.     }
  21.  
  22.     public static void main(java.lang.String[] args) {
  23.         /* L5 */
  24.         0 iconst_0;
  25.         1 istore_1;               /* a */
  26.         /* L6 */
  27.         2 iconst_0;
  28.         3 istore_2;               /* b */
  29.         /* L7 */
  30.         4 iinc 1 10;              /* a += 10 */
  31.         /* L8 */
  32.         7 iinc 2 10;              /* b += 10 */
  33.         /* L9 */
  34.         10 iload_1;               /* a */
  35.         11 iinc 1 1;              /* a++ */
  36.         14 istore_3;              /* c */
  37.         /* L10 */
  38.         15 iinc 2 1;              /* b++ */
  39.         18 iload_2;               /* b */
  40.         19 istore_3;              /* c */
  41.         /* L11 */
  42.         20 iload_3;               /* c */
  43.         21 iload_1;               /* a */
  44.         22 iload_2;               /* b */
  45.         23 iadd;
  46.         24 iadd;
  47.         25 istore_3;              /* c */
  48.         /* L12 */
  49.         26 return;
  50.     }
  51. }

Obsérvese que:

  • a++ corresponde con iinc 1 1. Es decir, incrementar la variable 1 (a) por 1.
  • a += 10 corresponde con iinc 1 10. Es decir, incrementar la variable 1 (a) por 10.
    En realidad, es a = a + 10, pero el compilador lo optimiza.

~~~

Imagen de Cid

Y algo más

Cuando utilizas tipos de datos diferentes en los dos operandos generalmente se hace un cast al tipo de dato al que le estas asignando el resultado de la operación

                char letra = 'a';
                //Aqui un entero (representacion numerica del caracter en Unicode) y el caracter de la variable letra
                System.out.println((int)letra + " " + letra);
                /*Luego le aplicamos un operador compuesto en este caso de adicion aplica el cast
                al tipo de dato de letra:  */

                letra += 2.5; // Este sería su equivalente letra = (char)(letra+2.5);
                //Aqui observamos de nuevo el entero (representacion numerica del caracter en Unicode) y el caracter de la variable letra
                System.out.println((int)letra + " " + letra);

Para más info checate esto

Algol 68

 

De acuerdo con Dennis M. Ritchie (1), Ken Thompson se basó en la notación de Algol 68 para escribir los operadores de asignación compuestos (incluidos primeramente en el lenguaje B).

Por ejemplo, en Algo 68 existía el operador plusab (2). Así, x plusab y en Algol 68 se escribía como x +:= y, que en su forma expandida era x := x + y.

Y, siguiendo con Dennis M. Ritchie, fue Ken Thompson quien inventó los operadores de incremento ++ y decremento --, pero estos fueron incluidos en C.


Notas

  1. Dennis M. Ritchie. The Development of the C Language. http://www.bell-labs.com/usr/dmr/www/chist.html
  2. Andrew D. McGettrick. Algol 68: A First and Second Course. p. 33-34. https://books.google.com.mx/books?id=4g44AAAAIAAJ&pg=PA33

~~~

Gracias

Gracias