Можно ли использовать placement new как замену bit_cast?

Question

[yatanai]

Мне интересны возможности обойти ограничение на бинарное приведение типов, ибо bit_cast использует копирование в переменную на стеке, что не особо быстро.
Но насколько я знаю, тривиальные типы не инициализируют память в дефолтных конструкторах. Значит ли это что для bit_cast'а в тривиальный тип мы можем использовать placement new с указателем на интересующую нас память и тем самым сохранить байты в памяти без изменений и избавить себя от ненужного копирования?
Есть ли какие-либо позиции стандарта по этому поводу, которые я не могу нагуглить и которые запрещают использовать мне placement new с какими-то "нетакими" указателями?

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

#include <iostream>
using namespace std;
class Foo 
{ 
    private: int __unused; 
    public: Foo() : __unused(1) {} //Мы всёравно сохраняеем trivially_copyable, так что всё хорошо
};

int main()
{
    //char bytes[1024];
    //auto* foo = new(bytes) Foo;
    
    Foo bytes{};
    auto* foo = new(&bytes) int;
    
    cout << *foo;
    return 0;
}

Comments

[maaGames]

C++ хорош тем, что можно испортить себе жизнь огромным количеством способов.
bit_cast это что? reinterpret_cast?

[yatanai]

maaGames, с точки зрения С++ делать вот так нельзя: int32_t x; reinterpret_cast<float*>(&x); Почему? Потому что это не типобезопасно. Поэтому в стандарт ввели bit_cast. Когда вместо приведения, ты просто копируешь память. Внутри оно устроено как-то так

template<class To, class From>
To bit_cast(const From& src) noexcept
{
    static_assert(std::is_trivially_constructible_v<To>,
        "This implementation additionally requires "
        "destination type to be trivially constructible");
 
    To dst;
    std::memcpy(&dst, &src, sizeof(To));
    return dst;
}

Надежда вся на комппилятор, что он сможет оптимизировать вызов и заменить копирование на нужные инструкции в процессорее.

Всё ради типобезопасности. Но можешь быть спокоен, всем на это давно пофиг. Огромное количество кода используют всякиее "небезопасные" вещи с точки зрения стандарта, потому если это решат пофиксить мир рухнет.

[maaGames]

yatanai, благодарю, нагуглил. С++20 пока не пользуюсь.
Всё-таки, подобный код чаще обозначает ошибки проектирования, чем реальную необходимость.
Правда я не понимаю, зачем делать memcpy, если этим же static_assert можно было проверять размерности перед reinterpret_cast. Скорее всего что-то связанное с выравниванием памяти. Но всё это обнаруживается при падении при первом же использовании... Ладно, возвращаясь к теме.
Размещающий new всё-равно будет требовать корректное выравнивание, особенно для вещественных чисел. Не буду утверждать, что будет падение при обращение к памяти, может просто будут дополнительные операции и сильное падение производтиельности.
Если смущает временная переменная dst и её копирование, которое компилятор может быть не заоптимизирует, то можно сделать свой вариант bit_cast, но с двумя аргументами, второй из которых будет ссылкой на dest. Байтовое копирование останется, но не будет временной переменной.

[yatanai]

maaGames, Как раз reinterpret_cast пользоваться во многих случаях нельзя. Почитайте про type alias в С++. Тут проблема именно в типобезопасности выражений. Ты можешь использовать reinterpret_cast для конвертации целых чисел, но, условно, поменять указатель с int* на long* таким методом нельзя и ты нарушаешь стандарт. Эта проблема приводит к тому, что ты даже не можешь пользоваться union, потому что с точки зрения стандарта, ты можешь использовать только один тип объединения и если ты напишешь как ниже, то ты нарушишь стандарт.

union type { int x; long y; } var;
var.x = 1;
std::cout << var.y;

Для таких вещей и придумали bit_cast, теперь чтобы не нарушать стандарт тебе придётся писать условно как-то так

union type { int x; long y; } var;
var.x = 1;
std::cout << bit_cast<long>(var.x);

И тут у меня возникли вопросы к релизации bit_cast. Ведь я помню что существует ровно похожая конструкция, где мы можем инициализировать объект через чужую память, при этом имеея ровно те же ограничения что и вариант реализованный в стандарте. Мы так же создаём неинициализированную переменную и так же используем чужую память. Разница лишь в том, что bit_cast создаёт новый объект с копией памяти нашего объекта, а placement new создаёт новый объект как ссылку на уже существующий.

[maaGames]

yatanai, по моему, ты путаешь static_cast и reinterpret_cast. Вот для чего reinterpret_cast не нужен, так это для чисел, тем более целых.

[yatanai]

Я некорректно выражался, но в целом вместо спора надо читать документики -> https://en.cppreference.com/w/cpp/language/reinter...

Из чего следует что в целом reinterpret_cast не нужен ни для чего кроме конвертаций указатель<->число и каста указателей в char*. В остальном же это UB + какие-то компиляторы позволяют безопасно кастить в void* и приводить указатели к другому типу, но тут уже начинаются приколы с псевдонимами типов, который используется оптимизатором + если использовать преобразованные указатели\ссылки то опять всё падает в UB.

Мир С++ полон жути(

Answer 1

[#]

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

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

Comments

[#]

Значит ли это что для bit_cast'а в тривиальный тип мы можем использовать placement new с указателем на интересующую нас память и тем самым сохранить байты в памяти без изменений и избавить себя от ненужного копирования?

и вы думаете, что это за вас будет выяснять дядя?
.. дядя сказал - вы криво думаете.. но ни когда не поздно учится