Повторное использование буфера с плавающей запятой для двойных значений без неопределенного поведения

Я думаю, что следующий код является допустимым способом сделать это (на самом деле это всего лишь небольшой пример идеи):

#include <memory>

void f(float* buffer, std::size_t buffer_size_in_bytes)
{
    double* d = new (buffer)double[buffer_size_in_bytes / sizeof(double)];

    // we have started the lifetime of the doubles.
    // "d" is a new pointer pointing to the first double object in the array.        
    // now you can use "d" as a double buffer for your calculations
    // you are not allowed to access any object through the "buffer" pointer anymore since the floats are "destroyed"       
    d[0] = 1.;
    // do some work here on/with the doubles...


    // conceptually we need to destory the doubles here... but they are trivially destructable

    // now we need to start the lifetime of the floats again
    new (buffer) float[10];  


    // here we are unsure about wether we need to update the "buffer" pointer to 
    // the one returned by the placement new of the floats
    // if it is nessessary, we could return the new float pointer or take the input pointer
    // by reference and update it directly in the function
}

int main()
{
    float* floats = new float[10];
    f(floats, sizeof(float) * 10);
    return 0;
}

Важно, чтобы вы использовали только указатель, полученный от нового размещения. И важно разместить новые поплавки. Даже если это нерабочая конструкция, вам нужно снова запустить время жизни поплавков.

Забудьте о std::launder и reinterpret_cast в комментариях. Размещение новое сделает эту работу за вас.

edit: убедитесь, что у вас правильное выравнивание при создании буфера в main.

Обновление:

Я просто хотел дать обновленную информацию о вещах, которые обсуждались в комментариях.

1. Первое, о чем упоминалось, это то, что нам может понадобиться обновить первоначально созданный указатель с плавающей запятой на указатель, возвращаемый поплавками с заменой новых (вопрос заключается в том, можно ли по-прежнему использовать исходный указатель с плавающей запятой для доступа к поплавкам, потому что числа с плавающей запятой теперь являются «новыми» числами с плавающей запятой, полученными с помощью дополнительного нового выражения).

Для этого мы можем либо а) передать указатель с плавающей запятой по ссылке и обновить его, либо б) вернуть из функции новый полученный указатель с плавающей запятой:

a)

void f(float*& buffer, std::size_t buffer_size_in_bytes)
{
    double* d = new (buffer)double[buffer_size_in_bytes / sizeof(double)];    
    // do some work here on/with the doubles...
    buffer = new (buffer) float[10];  
}

b)

float* f(float* buffer, std::size_t buffer_size_in_bytes)
{
    /* same as inital example... */
    return new (buffer) float[10];  
}

int main()
{
    float* floats = new float[10];
    floats = f(floats, sizeof(float) * 10);
    return 0;
}

2. Следующим и более важным моментом, о котором следует упомянуть, является то, что Placement-new может иметь накладные расходы памяти. Таким образом, реализации разрешено размещать некоторые метаданные перед возвращаемым массивом. Если это произойдет, то наивный расчет того, сколько двойников уместится в нашей памяти, будет заведомо неверным. Проблема в том, что мы не знаем, сколько байтов потребуется реализации заранее для конкретного вызова. Но это было бы необходимо, чтобы скорректировать количество двойников, которые, как мы знаем, поместятся в оставшееся хранилище. Здесь ( https://stackoverflow.com/a/8721932/3783662 ) - еще один пост SO, в котором Говард Хиннант провел тест фрагмент. Я проверил это с помощью онлайн-компилятора и увидел, что для тривиальных разрушаемых типов (например, double) накладные расходы равны 0. Для более сложных типов (например, std::string) накладные расходы составляют 8 байтов. Но это может варьироваться для вашей платформы/компилятора. Проверьте это заранее с помощью фрагмента от Говарда.

3. На вопрос, почему нам нужно использовать какое-то новое размещение (либо с помощью new[], либо с одним элементом new): нам разрешено указывать указатели любым способом, которым мы хотим. Но, в конце концов, когда мы обращаемся к значению, нам нужно использовать правильный тип, чтобы не нарушать строгие правила алиасинга. Проще говоря: доступ к объекту разрешен только тогда, когда действительно существует объект типа указателя, живущий в месте, заданном указателем. Так как же оживить объекты? стандарт говорит:

https://timsong-cpp.github.io/cppwp/intro.object# 1 :

https://timsong-cpp.github.io/cppwp/basic.life# 1:

Вы можете добиться этого двумя способами.

Первый:

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
}

Во-вторых: вместо float * вам нужно выделить «бестиповый» буфер char[] и использовать новое размещение, чтобы поместить внутрь числа с плавающей запятой или двойное число:

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);

Затем используйте этот аксессуар:

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;

Третий способ может быть чем-то вроде ответа phön (см. мои комментарии под этим ответом), к сожалению, я не могу найти правильное решение из-за эта проблема.

Вот альтернативный подход, который менее страшен.

Ты говоришь,

... плавающий/двойной союз невозможен без... выделения дополнительного пространства, что противоречит цели и в моем случае оказывается дорогостоящим...

Так что просто пусть каждый объект объединения содержит два поплавка вместо одного.

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;
}

Конечно, это усложняет индексацию, и код вызова придется модифицировать. Но у него нет накладных расходов, и это более очевидно правильно.

tl;dr Не создавайте псевдонимы указателей - вообще - если вы не сообщите компилятору, что вы собираетесь это сделать в командной строке.

Самый простой способ сделать это — выяснить, какой переключатель компилятора отключает строгие псевдонимы, и использовать его для рассматриваемых исходных файлов.

Потребности должны, а?

Думал об этом еще. Несмотря на все эти вещи о размещении new, это единственный безопасный способ.

Почему?

Что ж, если у вас есть два указателя разных типов, указывающих на один и тот же адрес, то у вас есть псевдоним для этого адреса, и у вас есть хорошие шансы обмануть компилятор. И не имеет значения, как вы присваиваете значения этим указателям. Компилятор этого не запомнит.

Так что это единственный безопасный способ, и именно поэтому нам нужен std::pun.

Эта проблема не может быть решена в переносимом C++.

C++ строг, когда дело доходит до псевдонимов указателей. Несколько парадоксально это позволяет ему компилироваться на очень многих платформах (например, где, возможно, double чисел хранится в разных местах до float чисел).

Излишне говорить, что если вы стремитесь к переносимому коду, вам нужно будет перекодировать то, что у вас есть. Вторая лучшая вещь — быть прагматичным, признать, что это будет работать на любой настольной системе, с которой я сталкивался; возможно, даже static_assert по имени/архитектуре компилятора.