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

Я преодолеваю ограничение в своем предыдущем ответе. Вы можете увидеть новый ответ ниже.

Новый ответ:

#include <array>
#include <iostream>
#include <memory>
#include <tuple>

class IAggregate
{
public:
    virtual ~IAggregate() = default;
};

template<typename... Bases>
class Aggregate : public IAggregate, public Bases...
{
public:
    Aggregate() { std::cout << "Aggregate\n"; }
    virtual ~Aggregate() override = default;
};

// Base classes for demonstration
class CharBase
{
public:
    CharBase() { std::cout << "CharBase display\n"; }
};

class UnsignedCharBase
{
public:
    UnsignedCharBase() { std::cout << "UnsignedCharBase display\n"; }
};

class ShortBase
{
public:
    ShortBase() { std::cout << "ShortBase display\n"; }
};

class IntBase
{
public:
    IntBase() { std::cout << "IntBase display\n"; }
};

class FloatBase
{
public:
    FloatBase() { std::cout << "FloatBase display\n"; }
};

// List of all base classes
using AllBases                 = std::tuple<CharBase, UnsignedCharBase, ShortBase, IntBase, FloatBase>;
constexpr std::size_t NumBases = std::tuple_size_v<AllBases>;

// Custom constexpr bitset class auto configured BITS_PER_WORD
template<std::size_t N, std::size_t BITS_PER_WORD>
class ConstexprBitset
{
public:
    constexpr ConstexprBitset()
        : bits {}
    {
    }

    constexpr void set(std::size_t pos)
    {
        if (pos >= N)
            throw std::out_of_range("Bit position out of range");
        bits[pos / BITS_PER_WORD] |= (1ULL << (pos % BITS_PER_WORD));
    }

    constexpr bool test(std::size_t pos) const
    {
        if (pos >= N)
            throw std::out_of_range("Bit position out of range");
        return (bits[pos / BITS_PER_WORD] & (1ULL << (pos % BITS_PER_WORD))) != 0;
    }

private:
    std::array<unsigned long long, (N + BITS_PER_WORD - 1) / BITS_PER_WORD> bits;
};

constexpr std::size_t calculateOptimalBitsPerWord(std::size_t numBases)
{
    return (numBases + 63) / 64; // Each unsigned long long covers 64 bits
}

constexpr std::size_t OptimalBitsPerWord = calculateOptimalBitsPerWord(NumBases);

template<int Mask, typename Tuple, typename Enable = void, typename... Types>
struct TypeExtractor;

template<int Mask, typename Tuple, typename... Types>
struct TypeExtractor<Mask, Tuple, std::enable_if_t<Mask == 0>, Types...>
{
    using type = Aggregate<Types...>;
};

template<int Mask, typename Tuple, typename... Types>
struct TypeExtractor<Mask, Tuple, std::enable_if_t<Mask != 0>, Types...>
{
    static constexpr ConstexprBitset<NumBases, OptimalBitsPerWord> mask = []()
    {
        ConstexprBitset<NumBases, OptimalBitsPerWord> bs;
        for (std::size_t i = 0; i < NumBases; ++i)
            if (Mask & (1 << i))
                bs.set(i);
        return bs;
    }();

    static constexpr std::size_t highestBit = []()
    {
        for (std::size_t i = NumBases; i > 0; --i)
            if (mask.test(i - 1))
                return i - 1;
        throw std::out_of_range("No bits are set");
    }();

    using BaseType = std::tuple_element_t<highestBit, Tuple>;
    using type = typename TypeExtractor<Mask & ~(1 << highestBit), Tuple, void, Types..., BaseType>::type;
};

template<int Mask>
using ExtractTypes = typename TypeExtractor<Mask, AllBases>::type;

using AggregatePtr = std::unique_ptr<IAggregate>;
template<int Mask>
AggregatePtr createAggregateInstance()
{
    return std::make_unique<ExtractTypes<Mask>>();
}

// Helper to create a map of factory functions
template<int... Masks>
constexpr auto createFactoryMap(std::integer_sequence<int, Masks...>)
{
    using FuncType = AggregatePtr (*)();
    return std::array<FuncType, sizeof...(Masks)> {{&createAggregateInstance<Masks>...}};
}

// The factory map consists of AllBases tuple
constexpr auto factoryMap = createFactoryMap(std::make_integer_sequence<int, 1 << NumBases> {});

AggregatePtr createAggregate(int mask)
{
    if (mask < factoryMap.size())
        return factoryMap[mask]();
    return nullptr;
}

int main()
{
    for (int i = 1; i <= 3; ++i)
    {
        auto instance = createAggregate(i);
        if (!instance)
            std::cout << "Invalid combination for input: " << i << "\n";
        std::cout << "\n";
    }

    return 0;
}

Прямой эфир

Старый ответ:

Вот это решение, которое мне удалось придумать. Единственное ограничение здесь — это highestSetBit. Я пытался избавиться от этого, но не смог, буду признателен, если кто-нибудь сможет это понять.

#include <array>
#include <iostream>
#include <memory>
#include <tuple>

class IAggregate
{
public:
    virtual ~IAggregate() = default;
};

template<typename... Bases>
class Aggregate : public IAggregate, public Bases...
{
public:
    Aggregate() { std::cout << "Aggregate\n"; }
    virtual ~Aggregate() override = default;
};

class CharBase
{
public:
    static constexpr int Mask = 1 << 0;
    CharBase() { std::cout << "CharBase display\n"; }
};

class UnsignedCharBase
{
public:
    static constexpr int Mask = 1 << 1;
    UnsignedCharBase() { std::cout << "UnsignedCharBase display\n"; }
};

class ShortBase
{
public:
    static constexpr int Mask = 1 << 2;
    ShortBase() { std::cout << "ShortBase display\n"; }
};

class IntBase
{
public:
    static constexpr int Mask = 1 << 3;
    IntBase() { std::cout << "IntBase display\n"; }
};

// List of all base classes
using AllBases = std::tuple<CharBase, UnsignedCharBase, ShortBase, IntBase>;

constexpr int highestSetBit(const int mask) // This is the only limitation in this design
{
    for (int i = 31; i >= 0; --i)
        if (mask & (1 << i))
            return i;
    return -1; // should never reach here for valid masks
}

template<int Mask, typename Tuple, typename Enable = void, typename... Types>
struct TypeExtractor;

template<int Mask, typename Tuple, typename... Types>
struct TypeExtractor<Mask, Tuple, std::enable_if_t<Mask == 0>, Types...>
{
    using type = Aggregate<Types...>;
};

template<int Mask, typename Tuple, typename... Types>
struct TypeExtractor<Mask, Tuple, std::enable_if_t<Mask != 0>, Types...>
{
    static constexpr int highestBit = highestSetBit(Mask);
    using BaseType                  = std::tuple_element_t<highestBit, Tuple>;
    using type                      = typename TypeExtractor<Mask & ~(1 << highestBit), Tuple, void, Types..., BaseType>::type;
};

template<int Mask>
using ExtractTypes = typename TypeExtractor<Mask, AllBases>::type;

using AggregatePtr = std::unique_ptr<IAggregate>;

template<int Mask>
AggregatePtr createAggregateInstance()
{
    return std::make_unique<ExtractTypes<Mask>>();
}

// Helper to create a map of factory functions
template<int... Masks>
constexpr auto createFactoryMap(std::integer_sequence<int, Masks...>)
{
    using FuncType = AggregatePtr (*)();
    return std::array<FuncType, sizeof...(Masks)> {{&createAggregateInstance<Masks>...}};
}

// The factory map consist of AllBases tuple
constexpr auto factoryMap = createFactoryMap(std::make_integer_sequence<int, 1 << std::tuple_size_v<AllBases>> {});

AggregatePtr createAggregate(int mask)
{
    if (mask < factoryMap.size())
        return factoryMap[mask]();
    return nullptr;
}

int main()
{
    for (int i = 1; i <= 3; ++i)
    {
        auto instance = createAggregate(i);
        if (!instance)
            std::cout << "Invalid combination for input: " << i << "\n";
        std::cout << "\n";
    }

    return 0;
}

Прямой эфир

Один из способов превратить значение времени выполнения в значение компиляции — использовать std::variant.

В вашем случае я бы использовал std::tuple для сохранения результата для «необязательного» типа.

template <typename T>
std::variant<std::tuple<>,
             std::tuple<std::type_identity<T>>>
AsOptionalTypeVar(bool b)
{
    if (b) {
        return std::tuple<std::type_identity<T>>{};
    } else {
        return std::tuple<>{};
    }
}

Помощник для преобразования кортежа в Aggregate

template <typename T> struct to_aggregate;
template <typename... Ts> struct to_aggregate<std::tuple<std::type_identity<Ts>...>>
{
    using type = Aggregate<Ts...>;
};

Тогда вы можете позволить std::visit выполнить декартово произведение

std::visit(
    [](auto... bases){
        using all_base = decltype(std::tuple_cat(bases...));
        using aggregate = typename to_aggregate<all_base>::type;

        // Use aggregate type as you want
    },
    AsOptionalTypeVar<CharBase>(useCharBase),
    AsOptionalTypeVar<UnsignedCharBase>(useUnsignedCharBase),
    AsOptionalTypeVar<ShortBase>(useShortBase),
    AsOptionalTypeVar<IntBase>(useIntBase)
);

Демо