union U {
    int i{0};
    float f{0};
};

int foo()
{
        U u;
	u.i = -1;
	u.f = 0.0f;

	return u.i; // 0 или -1?
}

template <class To, class From>
typename std::enable_if_t<
    sizeof(To) == sizeof(From) &&
    std::is_trivially_copyable_v<From> &&
    std::is_trivially_copyable_v<To>,
    To>
// constexpr support needs compiler magic
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;
}

void doWork(const CData &data)
{
}

template<typename С>
void iterateContainer(const С& c)
{
    for (const auto &item: c)
    {
        if constexpr (std::is_pointer_v<C::value_type>)
            doWork(*item);
        else
            doWork(item);
    }
}

foo(f(), g());

vector<bool> bools;
auto &chars = reinterpret_cast<vector<char>&>(bools);