CKTIS / C
Asignación por multiplicación (`*=`) en C
El operador `*=` multiplica el valor actual y guarda el resultado en el mismo objeto. El operando izquierdo se evalúa una sola vez, pero hay que comprobar el límite antes de duplicar una capacidad.
Versión: ISO C23; implementation support may vary
Sintaxis
lhs *= rhslhs *= rhs multiplica el valor actual de lhs por rhs y guarda el resultado en el objeto designado por lhs. El operando izquierdo debe ser un lvalue modificable de tipo aritmético, y ambos tipos deben ser válidos para *. No admite punteros y en C no se pueden sobrecargar operadores. Estas reglas corresponden a ISO C23; la compatibilidad con C23 puede variar según la implementación.
lhs = lhs * (rhs) ilustra la operación, pero no siempre es una sustitución correcta: *= evalúa el operando izquierdo una sola vez, así que capacities[i++] *= 2 incrementa i una sola vez. Eso no implica que el operando izquierdo se evalúe antes que el derecho. La expresión de asignación tiene el valor almacenado, pero no es un lvalue. Para un objeto atómico, *= realiza una operación atómica de lectura, modificación y escritura con el orden de memoria memory_order_seq_cst.
Las conversiones aritméticas usuales determinan el tipo de la multiplicación; luego se convierte el producto al tipo de destino. El desbordamiento en una multiplicación de enteros con signo produce comportamiento indefinido; en una multiplicación sin signo, el resultado se reduce módulo uno más que el máximo del tipo del resultado. Un destino sin signo no garantiza una multiplicación sin signo: las promociones de enteros pueden dar lugar a un cálculo en int.
Antes de duplicar una capacidad de tipo size_t, calcula max_elements = SIZE_MAX / sizeof(element_type), donde element_type es el tipo de los elementos y SIZE_MAX, de <stdint.h>, es el máximo de size_t. Rechaza una capacidad superior a max_elements / 2 antes de usar *= 2. Así compruebas que se pueden representar tanto el nuevo número de elementos como su tamaño en bytes, pero no garantizas que la reserva de memoria vaya a tener éxito. *= no reserva memoria.
Ejemplos
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
int main(void)
{
size_t capacities[] = {4, 8};
size_t i = 0;
const size_t max_elements = SIZE_MAX / sizeof(unsigned char);
if (capacities[i] > max_elements / 2) {
return 1;
}
capacities[i++] *= 2;
printf("capacities[0] = %zu, capacities[1] = %zu, i = %zu\n",
capacities[0], capacities[1], i);
return 0;
}
Resultado
capacities[0] = 8, capacities[1] = 8, i = 1
El ejemplo no reserva ningún búfer y usa `sizeof(unsigned char)`, cuyo valor es 1. La primera capacidad pasa de 4 a 8, la segunda sigue en 8 e `i` pasa de 0 a 1.
Lecciones relacionadas
- C · Lección 74 · Avanzado · Versión: 3