Как изменить значение поля enum в рантайме?

Question

[Zellily]

Скажем, есть у меня некоторая функция, которая в какой-то момент времени вернёт либо true, либо false. В зависимости от результата этой функции мне нужно задать значения enum:
Скажем, был такой enum:
enum class Foo{qqq, www };
А стал такой:
Foo::qqq = 5; Foo::www = 10;
(это псевдокод, так работать не будет, но нужно аналогичное по смыслу)

Если так нельзя, то какие вообще варианты возможны в таком случае, если нужен enum со значениями, меняющимися во время работы? Может быть создать два энума с одинаковыми по названию полями, и возвращать указатель на энум в зависимости от true/false функции?

Comments

[Евгений Шатунов]

Zellily , странные у тебя желания, честно-говоря. :)
Используй свой enum как набор индексов, а свои переменные значения храни в массиве.

enum class ValueIndices
{
   qqq = 0,
   www,
   
   NAX_VALUES
};

using Values = std::array<int32_t, size_t( ValueIndices::MAX_VALUES )>;

[devalone]

Какая изначальная задача? Потому как то, что хочешь сделать ты - костыли.

[Толстый Лорри]

enum - это множество констант, их нельзя менять чисто идеологически. Наборы ключей со значением - это std::map

[Zellily]

devalone, Понятный и простой код - изначальная задача...

[Zellily]

Толстый Лорри, Ну мог бы быть указатель на множество констант. Раз структура у этих двух множеств одинаковая. Но вижу, что нельзя.

А, теперь понятно, почему я мэп не знаю, у нас bare metal.

[Zellily]

Евгений Шатунов, Нету у нас std, у нас bare metal

[Евгений Шатунов]

Zellily , искренне соболезную твоей команде.
И как же это мешает использовать массив для хранения изменяемых значений? :)

[Zellily]

Евгений Шатунов, Нам нравится копаться в потрохах :)
Хранить не мешает, но пользоваться потом неудобно в эклипсе.

[Толстый Лорри]

Zellily, можно. Более того, можно определить переменную, хранящую значение константы. Собственно, чаще всего так с ними и поступают:

enum class MyEnum { VAL1, VAL2, VAL3 };

MyEnum myTemp = MyEnum::VAL2;
myTemp = MyEnum::VAL3;

[Евгений Шатунов]

Zellily , вот тебе неотесанная глыба.

template< typename TEnumType, typename TValueType >
class EnumValues final
{
   static_assert( std::is_enum<TEnumType>::value, "The `TEnumType` type have to be enumeration." );
public:
   using UnderlyingType = std::underlying_type_t<TEnumType>;
   using Values         = std::array<TValueType, static_cast<UnderlyingType>( TEnumType::MAX )>;
   
   EnumValues()                     = default;
   EnumValues( const EnumValues& )  = default;
   EnumValues( EnumValues&& )       = default;
   EnumValues( std::initializer_list<TValueType> values );
   EnumValues( const Values& values );
   EnumValues( Values&& values );
   
   inline EnumValues& operator = ( cosnt EnumValues& )   = default;
   inline EnumValues& operator = ( EnumValues&& )        = default;
   inline EnumValues& operator = ( std::initializer_list<TValueType> values );
   inline EnumValues& operator = ( const Values& values );
   inline EnumValues& operator = ( Values&& values );
   
   inline TValueType& operator [] ( const TEnumType value )             { return m_values[ static_cast<UnderlyingType>( value ) ]; };
   inline const TValueType& operator [] ( const TEnumType value ) const { return m_values[ static_cast<UnderlyingType>( value ) ]; };

private:
   Values   m_values;
};

Побудь немного скульптором, отсеки лишнее, тогда станет понятно, как этим пользоваться.

Твой вопрос в совершенно непонятен. А попытки пояснить свой вопрос и свои мысли выдают у тебя полное незнание инструмента C++. Более удобных способов решения - море. Просто их невозможно вывести без формально поставленной задачи.

[Zellily]

Евгений Шатунов, Говорю же, нету у нас никаких std :) Это красиво, но сложно, за такое меня побьют :)

[devalone]

Zellily,

devalone, Понятный и простой код - изначальная задача...

нет, это не задача, а условие реализации, я имею ввиду, что программа должна делать?

[Евгений Шатунов]

Zellily , да, это печально, я уже писал об этом.
И это никак не мешает оценить пример и его возможную полезность. :)

[Zellily]

devalone, Было как-то так:

enum blabla{
a1 = 1,
a2 = 10,
a3 = 7,
};

void somefunc() {do_something_with blabla::a2}

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

[devalone]

Zellily, всё равно не понятно..

[Евгений Шатунов]

Zellily , и снова ничего не понятно.
void somefunc() {do_something_with blabla::a2}
Что там конкретно происходит? Откуда функция булева, если тип ее результата - void?

[Zellily]

Евгений Шатунов, somefunc - это одна функция, а булева - другая.
Если конкретно, то вычитывается значение по адресу, а адрес - это значение одного из полей enum.

Answer 1

[res2001]

enum - это константы.
Если у вас всего 2 варианта значений, то добавьте в enum дополнительные значения:
enum class Foo{qqq = 0, www = 1, qqq1 = 5, www1 = 10 };
Если больше - нужно менять схему и использовать не enum.

Comments

[Zellily]

Названия одинаковые должны быть, а qqq и qqq1 - разные.

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

[Денис Загаевский]

Zellily, зачем?

[Zellily]

Чтобы код красиво выглядел и легко читался. Чтобы не вызывать функцию, возвращающую либо true, либо false, 10 раз в разных местах. Вызвать её один раз и переопределить enum.
дефайнить на этапе компиляции неохота...

[res2001]

Вместо енумов просто сделайте массивы констант
const int qqqmas[] = {0, 5};
const int wwwmas[] = {1, 10};
А вашу функцию возвращающую true или false переделайте так, чтоб она возвращала индекс для этих массивов.
ну и чтоб функцию 10 раз не вызывать где-нить в начале:
const int qqq = qqqmas[ind];
const int www = wwwmas[ind];

[Zellily]

res2001, 0 и 5 - это вполне определённые вещи, а так они безымянные получатся. Неудобно пользоваться.

[res2001]

Zellily, сделайте ваши определенные вещи в enume, дайте им имена, а в массивах используйте имена их enuma. Так же можно использовать #define.

[Zellily]

res2001, А другие прогеры как этим пользоваться будут? Каждый раз в описание энума лазать при работе с массивом? Эклипс, например, подсказки даёт, если начать набивать Foo::

[res2001]

Zellily, сделайте это в виде функции:
getqqq() и getwww(), туда можно запрятать и массив и энум и пользоваться просто.

[Zellily]

res2001, Две функции ничем не лучше двух энумов :(

[res2001]

Zellily, а в чем собственно проблема? Используйте мар, как советовал GavriKos. Но для вашего случая мар кажется перебором. Он работает в разы медленнее предложенного мною способа.
В любом случае использовать enum так как вы хотите нельзя. Вам накидали возможные варианты. Выбирать вам. Или изобретите свой велосипед, например, можно сделать не функциями, а классом, но сути это не меняет.

[GavriKos]

Zellily, сделайте одну функцию, параметр у нее - один енам, которая исходя из параметра вернет нужное в данном рантайме значение. А значение брать из массива констант, как предложил выше res2001. Такой себе map руками. И другим программистам норм будет - они будут видеть enum, и костылей почти минмиум.

[Zellily]

GavriKos, А значение параметра откуда возьмёт?

[Zellily]

res2001, На структуру, наверное, перейду :)

[GavriKos]

Zellily, дык в вызове передавать будете. По сути функция: GetValueByType(FooEnum type). Внутри нее что то вроде
return myConstsArray[(int)type];
В myConstArray храните нужные вам значения последовательно, как и в енаме. Нужно переопределить значение - или меняете содержимое массива, или можно через константые массивы - весь сразу.
Использование:
GetValueByType(FooEnum::MyMegaEnumElement);
вместо того что щас у вас (чтобы понятно было)
value = FooEnum::MyMegaEnumElement

Эдакий черезжопный вариант map

[Zellily]

GavriKos, Нее, я не могу в вызове передать тип енума, потому что заранее его не знаю.

[GavriKos]

Zellily, эээ. А как вы с ними вообще работаете? Можно пример кода?

[Zellily]

GavriKos, С кем, с энумами? Было как-то так:

enum blabla{
a1 = 1,
a2 = 10,
a3 = 7,
};

void somefunc() {do_something_with blabla::a2}

А теперь блабла может иметь двойной набор значений в зависимости от результата булевской функции.

Answer 2

[GavriKos]

Чисто на енамах - никак. После компиляции енама нет - там просто инты.
Самый простой вариант в данном случае - map. Ключ - строка (или можете тот же енам использовать, если вам удобнее), значение - текущее значение собсно.

Comments

[Zellily]

Вариант с указателем на нужный enum тоже не прокатит?

[GavriKos]

Zellily, могу ошибиться, но это же будут указатели на разные типы данных. Вы их приводить друг к другу что ли будете? Ну и честно - так себе метод. Потому что вы тогда зависите от енамов, прописаных в коде. И как только вам их надо поменять - надо лезть в код и пересобирать приложение. Вариант с map - более универсален.

[Zellily]

Да я даже не знаю, можно ли их привести. Но enum-ы структуру одинаковую имею в любом случае, только значения разные. Спасибо, буду рыть map

[GavriKos]

Zellily, enum Foo и enum Foo2 - это разные типы. Привести их можно через (int), но нафига тогда вообще енамы.

[Zellily]

GavriKos, Ну да, наверное на структуру стоит перевести...

Answer 3

[Антон Жилин]

Вам нужны tagged union. Вот как это выглядело бы на Swift, например:

enum Foo {
    case qqq(Int)
    case www(Int)
}

let x = Foo.qqq(5)
let y = Foo.www(10)

На C++ это часто эмулируется с помощью наследования:

class Foo {
public:
    virtual ~Foo() = 0;
};

class qqq : public Foo {
public:
    int value;
    explicit qqq(int value);
};

class www : public Foo {
public:
    int value;
    explicit www(int value);
};

using FooPtr = std::unique_ptr<Foo>;
FooPtr makeQqq(int value);
FooPtr makeWww(int value);

FooPtr x = makeQqq(5);
FooPtr y = makeWww(10);

Я опустил небольшое количество кода, который, я не сомневаюсь, вы могли бы сами закончить, если действительно хотите заставить этого монстра работать :)

Есть и более чистый способ: подключите либу type_safe (кликабельно).

#include <type_safe/strong_typedef.hpp>
#include <type_safe/variant.hpp>

namespace ts = type_safe;

using qqq = ts::strong_typedef<int>;
using www = ts::strong_typedef<int>;
using Foo = ts::variant<qqq, www>;

// ...

auto x = Foo(qqq(5));
auto y = Foo(www(10));

if (x.has_value(ts::variant_type<qqq>{})) {
    qqq value = x.value(ts::variant_type<qqq>{}));
    std::cout << "qqq" << ' ' << static_cast<int>(value);
}