Проблема каламбура в C++

Одной из очевидных возможностей было бы разделить данные, общие для обоих, в отдельный класс (или структуру), а затем получить их из объекта, когда они вам понадобятся.

struct Common {
// ...
};

template <bool b>
class Dynamic { 
    Common c;
public:
    Common &get_data() { return c; }
    // ...
};

Отсюда остальное кажется довольно очевидным — когда вам нужны данные из Dynamic<whatever>, вы звоните get_data() и уходите.

Конечно, есть и вариации на общую тему — например, вместо этого вы можете использовать наследование:

struct Common { /* ... */ };

template <bool t>
class Dynamic : public Common {
    // ...
};

Это устраняет дополнительные c., которые требовались предыдущей версии для каждой ссылки на общие данные, но (по крайней мере, на мой взгляд) наследование, вероятно, слишком высокая цена, чтобы платить за это.

В стандарте «запрещено» переинтерпретировать область памяти из типа A в тип B. Это называется алиасингом. Есть 3 исключения для псевдонимов, одинаковые типы с разной квалификацией CV, базовые типы и регионы char[]. (а для char отступление работает только однонаправленно в направлении char)

Если вы используете std::aligned_storage и новое размещение, вы можете переинтерпретировать этот регион во что угодно, и компилятор не сможет жаловаться. Вот как работает variant.

РЕДАКТИРОВАТЬ: Хорошо, вышесказанное на самом деле верно (если вы не забудете std::launder), но вводит в заблуждение из-за «срока службы». Одновременно поверх области хранения может находиться только один объект. Таким образом, это неопределенное поведение — интерпретировать его через представление другого типа, пока оно живо. Ключ — это конструкция.

Если я могу предложить, перейдите на cppreference, возьмите их static_vector пример, упростите его. к случаю 1. Добавьте несколько геттеров, поздравляю, вы заново изобрели bitcast :) (предложение http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0476r2.html).

Вероятно, это будет выглядеть так:

#include <type_traits>
#include <string>
#include <new>
#include <cstring>
#include <iostream>

using namespace std;

template< bool B >
struct Dynamic
{
    template <bool B2 = B>
    void ConditionalMethod(typename enable_if<B2>::type** = 0)
    {}

    string m_sharedObject = "stuff";
};

int main()
{
    using D0 = Dynamic<false>;
    using D1 = Dynamic<true>;
    aligned_storage<sizeof(D0), alignof(D0)>::type store[1];

    D0* inst0 = new (&store[0]) D0 ;

    // mutate
    inst0->m_sharedObject = "thing";

    // pune to D1
    D1* inst1 = std::launder(reinterpret_cast<D1*>(&store[0]));

    // observe aliasing
    cout << inst1->m_sharedObject;

    inst0->~D0();
}

см. действие в wandbox

РЕДАКТИРОВАТЬ: после продолжительного обсуждения есть и другие части нового стандарта, кроме раздела «Типы 8.2.1.11», которые лучше объясняют, почему это не является строго действительным. Я рекомендую обратиться к главе «пожизненной».
https://en.cppreference.com/w/cpp/language/lifetime
Из комментария Майлза Буднека:

по этому адресу нет объекта Dynamic<true>, доступ к нему через Dynamic<false> является поведением undefined.

После прочтения обсуждения в https://stackoverflow.com/a/57318684/2166857 и прочтения исходного кода для bit_cast и много исследований в Интернете, я думаю, что нашел самое безопасное решение моей проблемы. Это работает, только если

1) Выравнивание и размер обоих типов совпадают

2) оба типа легко копируются (https://en.cppreference.com/w/cpp/named_req/TriviallyCopyable)

Сначала определите тип памяти с помощьюalign_storage

typedef std::aligned_storage<sizeof(Dynamic<true>),alignof(Dynamic<true>)>::type DynamicMem;

затем введите переменную этого типа

DynamicMem dynamic_buff;

затем используйте новое размещение, чтобы инициировать объект в первичном классе (в моем случае Dynamic)

new (&dynamic_buff) Dynamic<true>();

затем всякий раз, когда это необходимо, используйте reinterpret_cast для определения ссылки на объект или указателя, связанного с ним в области видимости.

{
    Dynamic<true>* dyn_ptr_true=reinterpret_cast<Dynamic<true>*>(&dynamic_buff)
    // do some stuff with dyn_ptr_true
}

Это решение ни в коем случае не идеально, но мне оно подходит. Я призываю всех прочитать тему https://stackoverflow.com/a/57318684/2166857 и следовать назад и четвертый между @Miles_Budnek и @v.oddou. Я, конечно, многому у него научился.

Единственный безопасный метод каламбура в стандартном C++ — через std::bit_cast. Однако это может включать копирование вместо обработки одного и того же представления памяти как другого типа, если компилятор не может его оптимизировать. Кроме того, в настоящее время std::bit_cast поддерживается только MSVC, хотя в Clang вы можете использовать __builtin_bit_cast

Поскольку вы используете GCC, вы можете использовать атрибут __may_alias__ чтобы сообщить, что псевдоним безопасен

template<int T>
struct Dynamic {};

template<>
struct Dynamic<true>
{
    uint32_t v;
} __attribute__((__may_alias__));

template<>
struct Dynamic<false>
{
    float v;
} __attribute__((__may_alias__));

float f(Dynamic<true>& d_true)
{
    auto& d_false = *reinterpret_cast<Dynamic<false>*>(&d_true);
    return d_false.v;
}

Clang и ICC также поддерживают этот атрибут. See demo on Godbolt , никаких предупреждений не выдается ивен