Представление равномерного распределения по диапазону произвольного типа перечисления

Вот три реализации дистрибутива в порядке возрастания сложности:

Во-первых, если мы можем полагаться на то, что значения различны, или если повторяющиеся значения имеют избыточный вес, мы можем просто проиндексировать контейнер _values():

template<class Enum>
struct SimpleEnumDistribution
{
    std::uniform_int_distribution<typename Enum::_integral> dist{0, Enum::_size() - 1};
    template<class Generator> Enum operator()(Generator& g) { return Enum::_values()[dist(g)]; }
};

В противном случае мы можем использовать выборку отклонения, предварительно вычислив минимум и максимум диапазона значений перечисления:

template<class Enum>
struct UniformEnumDistribution
{
    std::uniform_int_distribution<typename Enum::_integral> dist{
        *std::min_element(Enum::_values().begin(), Enum::_values().end()),
        *std::max_element(Enum::_values().begin(), Enum::_values().end())};
    template<class Generator> Enum operator()(Generator& g)
    {
        for (;;)
            if (auto value = Enum::_from_integral_nothrow(dist(g)))
                return *value;
    }
};

Если это будет неэффективно (возможно, значения перечисления разрежены), мы можем вычислить таблицу поиска при инициализации:

template<class Enum>
struct FastUniformEnumDistribution
{
    std::uniform_int_distribution<std::size_t> dist;
    std::array<typename Enum::_integral, Enum::_size()> values;
    FastUniformEnumDistribution()
    {
        std::copy(Enum::_values().begin(), Enum::_values().end(), values.data());
        std::sort(values.begin(), values.end());
        dist.param(std::uniform_int_distribution<std::size_t>::param_type{0u, static_cast<std::size_t>(
            std::distance(values.begin(), std::unique(values.begin(), values.end())) - 1)});
    }
    template<class Generator> Enum operator()(Generator& g)
    {
        return Enum::_from_integral_unchecked(values[dist(g)]);
    }
};

Пример.

При использовании улучшенных перечислений эта проблема может быть решена следующим образом:

template<typename T>
typename T get_uniform_value(std::default_random_engine& eng)
{
    std::uniform_int_distribution<int> dist(0, T::_size() - 1);
    return T::_values()[dist(eng)];
}

Пример использования:

BETTER_ENUM(Channel, int, Red, Green = 2, Blue) // Enum to generate random values of
...
std::default_random_engine rng(std::random_device{}());
Channel r = get_uniform_value<Channel>(rng); // Uniformly distributed between 0, 2 and 3

Я бы сказал, что более идиоматично было бы создать массив и выбрать индекс из массива:

 template <typename Rnd>
 Color RandomColor(Rnd& rnd)
 {
     const std::array<Color, 3u> colors {Color::Red, Color::Green, Color::Blue};

     std::uniform_int_distribution<int> dist(0, colors.size() - 1);
     return colors[dist(rnd)];
 }

Лучшие перечисления позволяют не создавать массив вручную с помощью Color::_values:

 template <typename BetterEnum, typename Rnd>
 BetterEnum RandomBetterEnum(Rnd& rnd)
 {
     std::uniform_int_distribution<int> dist(0, BetterEnum::_size() - 1);
     return BetterEnum::_values()[dist(rnd)];
 }

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

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

Есть и другие фундаментальные проблемы:

В случае, который вы показали

enum Color { Red = 1, Green = 2, Blue = 4 }

Предположительно, равномерное распределение, которое вы хотите, составляет от 0 до 7 (каждый перечислитель возможен с помощью ИЛИ вместе с использованием битовых масок).

Предположим, что перечисление было:

enum Color { Red = 1, Green = 2, Blue = 3 }

Тогда, по-видимому, вам нужны только 1, 2, 3 в вашем дистрибутиве.

Я думаю, вы не можете ожидать, что компилятор или любой код шаблона поймет ваши намерения - любой код "enum -> унифицированное распределение" потребует подсказок, чтобы он знал, какие перечислители должны быть объединены с комбинациями других, а какие это просто варианты.

Короче говоря, я думаю, вы должны делать именно то, что делает вопрос, на который вы ссылаетесь, и генерировать соответствующее распределение по int или чему-то еще, а затем static_cast в перечисление. И не пытайтесь использовать какое-то шаблонное решение, которое пытается прочитать ваши мысли для каждого возможного перечисления.