Assignment operators

Los operadores de asignación y asignación compuesta son operadores binarios que modifican la variable a su izquierda utilizando el valor a su derecha.

Asignación simple

Las expresiones de operador de asignación simple tienen la forma

donde

La asignación realiza conversión implícita del valor de rhs al tipo de lhs y luego reemplaza el valor en el objeto designado por lhs con el valor convertido de rhs .

La asignación también devuelve el mismo valor que fue almacenado en lhs (de modo que expresiones como a = b = c son posibles). La categoría de valor del operador de asignación es no-lvalue (de modo que expresiones como ( a = b ) = c son inválidas).

rhs y lhs deben satisfacer una de las siguientes condiciones:

• tanto lhs como rhs tienen tipos compatibles de struct o union , o..
• rhs debe ser implícitamente convertible a lhs , lo que implica

• tanto lhs como rhs tienen tipos aritméticos , en cuyo caso lhs puede estar volatile -calificado o atómico (desde C11)
• tanto lhs como rhs tienen puntero a tipos compatibles (ignorando calificadores), o uno de los punteros es un puntero a void, y la conversión no agregaría calificadores al tipo apuntado. lhs puede estar volatile o restrict (desde C99) -calificado o atómico (desde C11) .
• lhs es un puntero (posiblemente calificado o atómico (desde C11) ) y rhs es una constante de puntero nulo como NULL o un valor nullptr_t (desde C23)

Notas

Si rhs y lhs se superponen en memoria (por ejemplo, son miembros de la misma unión), el comportamiento es indefinido a menos que la superposición sea exacta y los tipos sean compatibles .

Aunque los arreglos no son asignables, un arreglo envuelto en una estructura es asignable a otro objeto del mismo (o compatible) tipo de estructura.

El efecto secundario de actualizar lhs está secuenciado después de los cálculos de valor, pero no de los efectos secundarios de lhs y rhs mismos, y las evaluaciones de los operandos están, como es habitual, no secuenciadas entre sí (por lo que expresiones como i = ++ i ; no están definidas)

La asignación elimina el rango y precisión adicional de las expresiones de punto flotante (consulte FLT_EVAL_METHOD ).

En C++, los operadores de asignación son expresiones lvalue, no así en C.

#include <stdio.h>
int main(void)
{
    // enteros
    int i = 1, j = 2, k = 3; // inicialización, no asignación
    i = j = k;   // los valores de i y j ahora son 3
//  (i = j) = k; // Error: se requiere lvalue
    printf("%d %d %d\n", i, j, k);
    // punteros
    const char c = 'A'; // inicialización; no asignación
    const char *p = &c;  // inicialización; no asignación
    const char **cpp = &p; // inicialización; no asignación
//  cpp = &p;   // Error: char** no es convertible a const char**
    *cpp = &c;  // OK, char* es convertible a const char*
    printf("%c \n", **cpp);
    cpp = 0;    // OK, la constante de puntero nulo es convertible a cualquier puntero
    // arreglos
    int arr1[2] = {1,2}, arr2[2] = {3, 4};
//  arr1 = arr2; // Error: no se puede asignar a un arreglo
    printf("arr1[0]=%d arr1[1]=%d arr2[0]=%d arr2[1]=%d\n",
            arr1[0],   arr1[1],   arr2[0],   arr2[1]);
    struct { int arr[2]; } sam1 = { {5, 6} }, sam2 = { {7, 8} };
    sam1 = sam2; // OK: se pueden asignar arreglos encapsulados en estructuras
    printf("%d %d \n", sam1.arr[0], sam1.arr[1]);
}

3 3 3
A
arr1[0]=1 arr1[1]=2 arr2[0]=3 arr2[1]=4
7 8

Asignación compuesta

Las expresiones de operadores de asignación compuesta tienen la forma

donde

La expresión lhs @= rhs es exactamente igual que lhs = lhs @ ( rhs ) , excepto que lhs se evalúa solo una vez.

T1* addr = &lhs;
T2 val = rhs;
T1 old = *addr;
T1 new;
do { new = old @ val } while (!atomic_compare_exchange_strong(addr, &old, new);

#include <stdio.h>
int main(void)
{
    int x = 10; 
    int hundred = 100; 
    int ten = 10; 
    int fifty = 50; 
    printf("%d %d %d %d\n", x, hundred, ten, fifty);
    hundred *= x; 
    ten     /= x; 
    fifty   %= x; 
    printf("%d %d %d %d\n", x, hundred, ten, fifty);
    return 0;
}

10 100 10 50
10 1000 1 0

Referencias

Véase También

Precedencia de operadores

Véase también