Reutilización de un búfer flotante para dobles sin comportamiento indefinido

Puedes lograr esto de dos maneras.

Primero:

void set(float *buffer, size_t index, double value) {
    memcpy(reinterpret_cast<char*>(buffer)+sizeof(double)*index, &value, sizeof(double));
}
double get(const float *buffer, size_t index) {
    double v;
    memcpy(&v, reinterpret_cast<const char*>(buffer)+sizeof(double)*index, sizeof(double));
    return v;
}
void f(float *buffer) {
    // here, use set and get functions
}

Segundo: en Lugar de float *, necesita asignar una "abreviado" char[] búfer y la colocación de nuevo para poner flotadores o dobles, interior:

template <typename T>
void setType(char *buffer, size_t size) {
    for (size_t i=0; i<size/sizeof(T); i++) {
        new(buffer+i*sizeof(T)) T;
    }
}
// use it like this: setType<float>(buffer, sizeOfBuffer);

Luego use este accesor:

template <typename T>
T &get(char *buffer, size_t index) {
    return *std::launder(reinterpret_cast<T *>(buffer+index*sizeof(T)));
}
// use it like this: get<float>(buffer, index) = 33.3f;

Una tercera vía podría ser algo así como la respuesta de phön (ver mis comentarios bajo esa respuesta), desafortunadamente no puedo hacer una solución adecuada, debido a este problema.

Tl; dr No alias punteros - en absoluto - a menos que le digas al compilador que vas a hacerlo en la línea de comandos.

La forma más fácil de hacer esto podría ser averiguar qué conmutador de compilador deshabilita el alias estricto y usarlo para los archivos fuente en cuestión.

Las necesidades deben, ¿eh?

Pensé en esto un poco más. A pesar de todas esas cosas sobre la colocación nueva, esta es la única manera segura.

¿Por qué?

Bueno, si tienes dos indicadores de diferentes tipos que apuntan a la misma dirección entonces usted ha aliased esa dirección y usted tiene una buena oportunidad de engañar al compilador. Y no importa cómo asignes valores a esos punteros. El compilador no va a recordar eso.

Así que esta es la única forma segura, y es por eso que necesitamos std::pun.

Aquí hay un enfoque alternativo que es menos aterrador.

Usted dice,

...una unión flotante/doble no es posible sin ella...la asignación de espacio adicional, que frustra el propósito y pasa a ser costoso en mi caso...

Así que solo tiene que cada objeto de unión contiene dos flotadores en lugar de uno.

static_assert(sizeof(double) == sizeof(float)*2, "Assuming exactly two floats fit in a double.");
union double_or_floats
{
    double d;
    float f[2];
};

void f(double_or_floats* buffer)
{
    // Use buffer of doubles as scratch space.
    buffer[0].d = 1.0;
    // Done with the scratch space.  Start filling the buffer with floats.
    buffer[0].f[0] = 1.0f;
    buffer[0].f[1] = 2.0f;
}

Por supuesto, esto hace que la indexación sea más complicada, y el código de llamada tendrá que ser modificado. Pero no tiene gastos generales y es más obviamente correcto.

Este problema no se puede resolver en portable C++.

C++ es estricto cuando se trata de aliasing de puntero. Paradójicamente, esto le permite compilar en muchas plataformas (por ejemplo, donde, tal vez double los números se almacenan en lugares diferentes a float los números).

No hace falta decir que, si usted está luchando por el código portátil, entonces usted tendrá que recodificar lo que tiene. La segunda mejor cosa es ser pragmático, aceptar que funcionará en cualquier sistema de escritorio que me he encontrado; tal vez even static_assert en nombre / arquitectura del compilador.

Editar

Pensé en esto un poco más y no está garantizado que sea seguro por las razones que he agregado a mi respuesta original. Así que dejaré el código aquí como referencia, pero no recomiendo que lo uses.

En lugar de eso, haz lo que te sugiero arriba. Es una pena, me gusta bastante el código que escribí, a pesar de los votos negativos misteriosos (me golpea el infierno, pensé que hice un buen trabajo aquí).

Edit 2: (solo para completar, este post es ya muerto)

Esta solución solo funcionará para tipos primitivos y POD. Esto es deliberado, dado el alcance de la pregunta original.

Pensé en publicar una respuesta de seguimiento porque @phön ha encontrado una mejor solución diferente que yo y quería ordenarla un poco y agregar algunas ideas propias.

Por favor nota: Este es un post serio. Solo porque me sienta un poco alegre hoy, no significa que solo esté engañando alrededor.

En primer lugar, asignaría el buffer 'master' usando malloc(). Esto es porque:

• Me devuelve un void *, que en realidad es el apropiado aquí. Verás por qué en un minuto.
• Es marginalmente más eficiente (aunque este es un detalle).
• Puedo controlar la alineación del búfer si necesito (para SSE, por ejemplo) con aligned_alloc.

No hay realmente una desventaja de esto. Si quiero manejarlo con un puntero inteligente, puedo utilice siempre un deleter personalizado.

Entonces, ¿por qué es eso void * tan maravilloso? Porque me impide hacer el tipo de cosas que phön hizo en su post, es decir, que estaba tentado a 'revertir' el uso del buffer a una matriz de float s y no creo que eso sea sabio.

Mejor, más bien, es ciertamente más limpio, usar la colocación new cada vez que desee tratar el búfer como una matriz de Foo y luego dejar que ese puntero salga silenciosamente del alcance cuando haya terminado con él. Sobrecarga es mínimo, sin duda para los tipos de vaina. De hecho, esperaría que cualquier compilador decente lo optimizara completamente en este caso, pero no lo he probado.

Así que usted debe, por supuesto, envolver todo esto en una clase, así que vamos a hacer eso. Entonces no necesitamos ese deleter personalizado. Aquí va.

La clase:

#include <cstdlib>
#include <new>
#include <iostream>

class SneakyBuf
{
public:
    SneakyBuf (size_t bufsize, size_t alignment = 8) : m_bufsize (bufsize)
    {
        m_buf = aligned_alloc (alignment, bufsize);
        if (m_buf == nullptr)
            throw std::bad_alloc ();
        std::cout << std::hex << "m_buf is at " << m_buf << "\n\n";
    }

    ~SneakyBuf () { free (m_buf); }

    template <class T> T* Cast (size_t& count)
    {
        count = m_bufsize / sizeof (T);
        return new (m_buf) T;   // no need for new [] here
    }

private:
    size_t m_bufsize;
    void *m_buf;
};

Programa de prueba:

void do_float_stuff (SneakyBuf& sb)
{
    size_t count;
    float *f = sb.Cast <float> (count);
    std::cout << std::hex << "floats are at " << f << "\n";
    std::cout << std::dec << "We have " << count << " floats\n\n";
    f [0] = 0;
    // ...
}

void do_double_stuff (SneakyBuf& sb)
{
    size_t count;
    double *d = sb.Cast <double> (count);
    std::cout << std::hex << "doubles are at " << d << "\n";
    std::cout << std::dec << "We have " << count << " doubles\n";
    d [0] = 0;
    // ...
}

int main ()
{
    SneakyBuf sb (100 * sizeof (double));
    do_float_stuff (sb); 
    do_double_stuff (sb);
}

Salida:

m_buf is at 0x1e56c40

floats are at 0x1e56c40
We have 200 floats

doubles are at 0x1e56c40
We have 100 doubles

Demostración en Vivo.

Escrito en mi tabla, trabajo duro!