Структура с необязательными членами в современном C++

А как насчет миксинов?

struct QPoint {};
struct QVector3D {};
struct Area {
    int area;
};
struct CoarsePosition {
    QPoint coarse_position;
};
struct FinePosition {
    QVector3D fine_position;
};
template <class ...Bases>
struct Location : Bases... {
};

Location<Area, CoarsePosition> l1;
Location<Area, FinePosition> l2;

Сначала я скажу, что иногда мне хотелось иметь "необязательную" опцию класса, когда все члены становятся необязательными. Я думаю, возможно, это было бы возможно без правильного метапрограммирования с использованием кода, подобного magic_get Антония Полухина.

Но как бы то ни было ... У вас может быть карта атрибутов с частичной типобезопасностью с произвольно типизированными значениями:

class Location {
    enum class Attribute { area, coarse_position, fine_position, layer };   
    std::unoredered_map<Attribute, std::any> attributes;
}

std::any может содержать любой тип (что-то, выделяя пространство в стеке, иногда внутренне). Облицовка наружу шрифт стирается, но вы можете восстановить его методом get<T>(). Это безопасный в том смысле, что вы получите исключение, если вы сохранили объект одного типа и пытаетесь get() другого типа, но это небезопасно в том смысле, что вы не получите ошибку во время компиляции.

Это можно адаптировать к случаю произвольных атрибутов, помимо тех, которые вы изначально планировали, например:

class Location {
    using AttributeCode = uint8_t;
    enum : AttributeCode { 
        area            = 12,
        coarse_position = 34,
        fine_position   = 56,
        layer           = 789
    };   
    std::unoredered_map<AttributeCode, std::any> attributes;
}

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

На практике, кстати, std::vector, вероятно, будет быстрее искать, чем std::unordered_map.

Предостережение: это решение не дает вам желаемой типобезопасности.

У вас может быть версия структуры, которая заставляет растровое изображение компилировать и проверять его там. Я предполагаю, что для определенного фрагмента кода вы делаете предположения о том, что присутствует. В этом коде вы можете взять версию с битовой картой времени компиляции. Чтобы успешно преобразовать версию с битовым отображением во время выполнения в битовую версию во время компиляции, битовая карта должна быть проверена.

#include <stdexcept>

struct foo
{
    int a;
    float b;
    char c;
};

struct rt_foo : foo
{
    unsigned valid;
};

template <unsigned valid>
struct ct_foo : foo
{
    // cannnot default construct
    ct_foo () = delete;

    // cannot copy from version withouth validity flags
    ct_foo (foo const &) = delete;
    ct_foo & operator = (foo const &) = delete;

    // copying from self is ok
    ct_foo (ct_foo const &) = default;
    ct_foo & operator = (ct_foo const &) = default;

    // converting constructor and assignement verify the flags 
    ct_foo (rt_foo const & rtf) :
        foo (check (rtf))
    {
    }

    ct_foo & operator = (rt_foo const & rtf)
    {
        *static_cast <foo*> (this) = check (rtf);

        return *this;
    }

    // using a member that is not initialize will be a compile time error at when
    // instantiated, which will occur at the time of use

    auto & get_a () { static_assert (valid & 1); return a; }
    auto & get_b () { static_assert (valid & 2); return a; }
    auto & get_c () { static_assert (valid & 3); return a; }

    // helper to validate the runtime conversion

    static foo & check (rt_foo const & rtf)
    {
        if ((valid & rtf.valid) != 0)
            throw std::logic_error ("bad programmer!");
    }
};

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

#include <stdexcept>
#include <iostream>

struct stream {
    template <typename value> value read ();
    template <typename value> void read (value &);
};

template <unsigned valid>
struct foo
{
    int a;
    float b;
    char c;

    auto & get_a () { static_assert (valid & 1); return a; }
    auto & get_b () { static_assert (valid & 2); return b; }
    auto & get_c () { static_assert (valid & 4); return c; }
};

template <unsigned valid>
foo <valid> read_foo (stream & Stream)
{
    if (Stream.read <unsigned> () != valid)
        throw std::runtime_error ("unexpected input");

    foo <valid> Foo;

    if (valid & 1) Stream.read (Foo.a);
    if (valid & 2) Stream.read (Foo.b);
    if (valid & 4) Stream.read (Foo.c);
}

void do_something (stream & Stream)
{
    auto Foo = read_foo <3> (Stream);

    std::cout << Foo.get_a () << ", " << Foo.get_b () << "\n";

    // don't touch c cause it will fail here
    // Foo.get_c ();
}

Это также позволяет шаблонам обрабатывать отсутствующие поля с помощью if constexpr.

template <unsigned valid>
void print_foo (std::ostream & os, foo <valid> const & Foo)
{
    if constexpr (valid & 1)
        os << "a = " << Foo.get_a () << "\n";
    if constexpr (valid & 2)
        os << "b = " << Foo.get_b () << "\n";
    if constexpr (valid & 4)
        os << "c = " << Foo.get_c () << "\n";
}