c# - sirve - ¿Cómo reinterpretar lanzar un float a un int? ¿Hay un operador de conversión no estático o un operador de asignación definido por el usuario para la conversión en ''esto''?

long c#

Question

1. ¿Cómo puedo reinterpretar lanzar un flotante a un int (o un double a un long)?

float f = 2.0f;
int i = (int)f; // causes conversion

Solo quiero copiar el patrón de bits de f a i . ¿Cómo puede hacerse esto?

2. Los operadores implícitos y explícitos en C # usan un objeto intermedio porque la función del operador es estática

public static implicit operator MyClass(double s)
{
    return new MyClass(s);
} 
..
..
MyClass m = 2.2; // this code uses ''m'' and one intermediate object.

Esto está bien para los tipos de referencia, pero para los tipos de valores que son grandes (digamos 20-30 bytes), esto causará una copia de datos innecesaria. Es mi entendimiento correcto? Y en caso afirmativo, ¿por qué C no tiene un operador de conversión no estático o un operador de asignación definido por el usuario para que la conversión / asignación tenga lugar en ''esto''? Si lo hace, ¿cuál es la forma de hacerlo?

Answer 1

1. La clase BitConverter puede recuperar los bytes para cualquier tipo primitivo, que luego puede usar para crear un int. Otra opción es Buffer.BlockCopy si tiene que realizar grandes conversiones.

   float ff = 2.0f;
   int ii = BitConverter.ToInt32(BitConverter.GetBytes(ff), 0);
   
   float[] ff = new float[...];
   int[] ii = new int[ff.Length];
   Buffer.BlockCopy(ff, 0, ii, 0, ff.Length * 4); // byte-wise copy of ff into ii

2. No, no hay otra opción en C #, sin embargo, creo que si bien tiene razón en el sentido de que se realizará una copia, cualquier implementación suficientemente simple tendrá optimizaciones de JIT, posiblemente eliminando la necesidad de una copia.

Answer 2

1: BitConverter (como sixlettervariables) es una opción; como es el código inseguro (que no necesita un buffer intermedio):

    float f = 2.0f;
    int i;
    // perform unsafe cast (preserving raw binary)
    unsafe
    {
        float* fRef = &f;
        i = *((int*)fRef);
    }
    Console.WriteLine(i);

    // prove same answer long-hand
    byte[] raw = BitConverter.GetBytes(f);
    int j = BitConverter.ToInt32(raw, 0);        
    Console.WriteLine(j);

2: tenga en cuenta que debe limitar el tamaño de las estructuras. No puedo encontrar una cita, pero el número "16 bytes" (máximo, como recomendación) parece quedarse en mi mente. Por encima de esto, considere un tipo de referencia inmutable (clase).

Answer 3

Excepto el código inseguro: este es el método más rápido que conozco para realizar una reinterpretación:

    [StructLayout(LayoutKind.Explicit)]
    private struct IntFloat
    {
        [FieldOffset(0)]
        public int IntValue;
        [FieldOffset(0)]
        public float FloatValue;
    }
    private static float Foo(float x)
    {
        var intFloat = new IntFloat { FloatValue = x };
        var floatAsInt = intFloat.IntValue;
        ...

Espero que esto ayude a alguien.

Answer 4

Este enfoque, aunque inseguro, funciona como una solución genérica

static unsafe TDest ReinterpretCast<TSource, TDest>(TSource source)
{
    var tr = __makeref(source);
    TDest w = default(TDest);
    var trw = __makeref(w);
    *((IntPtr*)&trw) = *((IntPtr*)&tr);
    return __refvalue(trw, TDest);
}