¿Está usando increment (operator ++) en floats bad style?

¿Se considera "mal estilo" usar el operador de incremento (++) en flotadores? Se compila muy bien, pero me parece mal y contraintuitivo.¿Está usando increment (operator ++) en floats bad style?

La pregunta: ¿En qué casos está usando ++ en variable de flotador justificado y mejor que += 1.0f? Si no hay casos de uso, ¿existe una guía de estilo C++ respetable que diga explícitamente que ++ en flotación es malo?

Para float ++ no se incrementa por el menor valor posible, sino por 1.0. 1.0f no tiene ningún significado especial (a diferencia del número entero 1). Puede confundir al lector haciéndole pensar que la variable es int.

Para flotante no se garantiza que el operador ++ cambie el argumento. Por ejemplo, el siguiente bucle no es infinito:

float i, j; 
for (i=0.0, j=1.0; i!=j;i=j++);

consecuencia haciendo ++ inmediatamente después - no garantiza que el valor no cambia.

Fuente

2011-12-19 Muxecoid

Hay una gran diferencia entre j ++ y ++ j – luke

¿Por qué no divide su par pregunta-respuesta en una pregunta adecuada y una respuesta correcta? Puede obtener más votos si las personas están de acuerdo con usted. – vitaut

+1 - Acepto que '++' tiene una connotación de "avanzar al siguiente valor", no "aumentar por el número mágico 1".Y en ese sentido, no tiene mucho sentido usarlo con flotadores. Aún así, dudo que haya una respuesta satisfactoria a esta pregunta. – tenfour

En general, ++/-- no está definido para flotadores, ya que no está claro con qué valor debe aumentarse el flotador. Por lo tanto, puede tener suerte en un sistema donde ++ lleva a f += 1.0f pero puede haber situaciones en las que esto no sea válido. Por lo tanto, para flotadores, deberá proporcionar un valor específico.

++/-- se define como "incremento/disminución en 1". Por lo tanto, esto es aplicable a los valores de coma flotante. Sin embargo, personalmente, creo que esto puede ser confuso para alguien que no conoce esta definición (o solo la aplica a enteros), por lo que recomendaría usar f += 1.0f.

Fuente

2011-12-19 12:34:45

Se define para todos los tipos aritméticos y puntero: 'El valor del objeto operando se modifica agregando 1 a él, a menos que el objeto sea de tipo bool, en cuyo caso se establece en true' – fefe

También gcc no se queja float ++ al compilar con -Wall. – Muxecoid

@fefe: Gracias por aclarar –

Cuando se agrega una gran cantidad de 1.0 a un flotador, a causa de la aritmética de punto flotante que podría ser un poco apagado en el extremo

La mejor manera es hacer

for (int i = 0; i < 100; i++) 
{ 
    float f = 2.433f + i * 1.0f;

en lugar de

for (float f = 2.433f; f < 102.433f; f += 1.0f)

En el segundo caso, el error aritmético de punto flotante se suma y en el primer caso no. Como ciertos usuarios han señalado en los comentarios a continuación, agregar flotantes integrales podría no acumular errores, pero en general es una buena idea evitarlo.

Fuente

2011-12-19 12:34:53

Sí. (Pero ¿por qué multiplicar por 1.0f? 'Float f = 2.433f + i;' es suficiente.) – TonyK

@TonyK Estaba pensando en un incremento general ... y dejar que el incremento sea 1.0f ... :) –

Mientras está Es cierto que ciertos valores fraccionarios no tienen representación exacta como flotantes, los valores integrales siempre lo hacen y el resultado de agregar dos flotantes con valores integrales (que parece ser lo que hace el OP) nunca tendrá un error de redondeo. – Ferruccio

Es un mal estilo. ++ y -- están destinados a establecer un lvalue a su valor siguiente o anterior, como el entero siguiente o anterior, el elemento siguiente o anterior en una matriz (para punteros), el elemento siguiente o anterior en un contenedor (iteradores), etc.

Los valores siguientes y anteriores no están bien definidos para los flotadores. Haz f += 1. explícitamente.

Fuente

2011-12-19 12:36:04

No estoy seguro de seguir lo que dices. En la medida en que los operadores de incremento y decremento "tengan la intención" de hacer algo, están destinados a incrementar y disminuir cualquier tipo para el que estén definidos, incluidos los tipos de coma flotante. La única diferencia entre 'f + = 1.' y' ++ f' es que el primero promueve 'f' a un doble para el cálculo. –

@Mike: creo que larsmans y el que pregunta están en efecto afirmando que fue un error (de mal estilo) en el estándar C definir '++' para los tipos de coma flotante. Lo afirman en función de su percepción del propósito previsto de ese operador para otros tipos, y que solo porque la definición se puede aplicar a cualquier tipo con un operador de asignación '+ =' que toma '1' en el rhs, no lo hace significa que el propósito aplica. –

@SteveJessop: Exactamente. Tuve una discusión sobre el tema con mi colega, así que ahora estoy buscando una guía de estilo que respalde mi punto.:) – Muxecoid

No hay nada de malo con el uso de ++ y -- en flotante o operandos dobles. Simplemente agrega o resta 1. ¡Para eso es!

Fuente

2011-12-19 13:03:53 TonyK

Eso es falso en lo que a mí respecta, de acuerdo con el 'estándar' que realmente no especifica el comportamiento aquí, no confiaría en eso. – ScarletAmaranth

@ScarletAmaranth La norma sí especifica el comportamiento, con mucha precisión. (Eso no significa necesariamente que sea una buena idea.) –

@TonyK Mis disculpas señor, pase por alto mi comentario anterior, aunque su comportamiento no está definido cuando se trata de carrozas (considerando muchos problemas de interpretación de coma flotante). Entonces sí, simplemente se incrementa en uno :) – ScarletAmaranth

¿Está usando increment (operator ++) en floats bad style?

Respuesta

Cuestiones relacionadas