c++ typedef перечисление другого класса?

Я считаю, что A должно быть пространством имен, а не структурой.

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

#define CLEANENUMS_BEGIN(name) namespace name { typedef enum {
#define CLEANENUMS_END(name) } internal_ ## name ## _e;} typedef name::internal_ ## name ## _e name ## _e;

Затем вы можете использовать в глобальном масштабе:

CLEANENUMS_BEGIN(myEnum)
    horizontal,
    vertical,
CLEANENUMS_END(myEnum)

Это более или менее эмулирует С# способ обработки области перечисления. Препроцессор выдаст такой код:

namespace myEnum
{
    enum internal_myEnum_e
    {
        horizontal,
        vertical,
    }
}
typedef internal_myEnum_e myEnum_e;

Затем данное перечисление упоминается как

myEnum_e val = myEnum::horizontal;

Надеюсь, есть лучший способ сделать это, но пока это единственное решение, которое я нашел.

У меня была такая же проблема в прошлом, и вот как я ее исправил. Я хотел иметь возможность переключать реализацию библиотеки во время компиляции. Одна из библиотек использовала такой код:

namespace Lib1 
{
  enum LibEnum { One, Two, Three };
  [...]
  void someFunc(LibEnum val);
}

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

Решение 1:

namespace MyCode 
{
  // Example to avoid copying a function from Lib1 here
  typedef Lib1::someFunc aFunctionImUsing;

  // This doesn't work
  // typedef LibEnum MyEnum; 
  // As such code doesn't compile:
  // aFunctionImUsing(One); // Error unknown identifier One
  // But this did:
  struct Type
  {
     enum MyType { One = Lib1::One, Two = Lib1::Two, Three = Lib1::Three };
  }
  static inline Lib1::LibEnum as(Type::MyType t) { return (Lib1::LibEnum)t; }

  // Now code like this compiles:
  aFunctionImUsing(as(Type::One));
  // This one doesn't:
  // aFunctionImUsing(Type::One); // Can't convert from Type::MyType to Lib1::LibEnum

  [...]
}

Решение 2:

namespace MyCode 
{
  struct Type
  {
     enum MyType { One = Lib1::One, Two = Lib1::Two, Three = Lib1::Three };
  }

  // If you don't care about polluting your namespace with numerous wrapper 
  // you can write this instead of typedef someFunc:
  static inline void myFunc(Type::MyType t) { return Lib1::someFunc((Lib1::LibEnum)t); }

  // This one does:
  myFunc(Type::One); 
  [...]
}

Это 2 проблемы с фрагментом кода выше. Первая проблема заключается в том, что вы должны скопировать и вставить перечисление внутри вашего пространства имен (но с простым регулярным выражением в поиске и замене все готово). Вторая проблема заключается в том, что вашему пользователю придется использовать метод «как», что означает, что это не так просто, или вам нужно обернуть метод/функцию, используя второе решение.

В любом случае, поскольку внедрить перечисление в пространство имен невозможно, это решение — лучшее, что вы можете сделать. Обратите внимание, что ваш пользователь кода даже не знает, что вы используете библиотеку Lib1 в коде примера.

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

class TreeWindow abstract {
public:
  enum CheckState { On, Off, Partial }
};

class TreeControl abstract {
public:
  class ItemChecked abstract: public TreeWindow { // this is the hack needed
  public:
    using TreeWindow::CheckState;
  };

  void func(ItemChecked::CheckState);
};

TreeControl& tree = ...
tree.func(TreeControl::ItemChecked::Partial);

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

struct A_Enum
{
    enum A_enum
    {
        E0,
        E1,
        E2
    };
};

struct A : public A_Enum
{
    using A_Enum::A_enum;
};

struct B : public::A_Enum
{
    using A_Enum::A_enum; // original enum name
    bool testA(A_enum val) { return (val == E1); }
};

EDIT2: снова удалил второе решение, не работает, как я думал.

Почему у вас вообще есть тестовый метод в структуре B? Я не думаю, что это имеет смысл.

Определяя структуру A и определяя перечисление внутри нее, вы более или менее говорите, что «вот перечисление в области структуры A», и это то же самое, что сказать «если вы хотите использовать это перечисление, вы должны обратиться к структура А".

Помещение перечисления внутри пространства имен не решит вашу проблему. Потому что у вас будет такая же проблема с областью действия (C4482)

Мне кажется, вы слишком все усложняете. Что ты думаешь об этом?

struct A
{
    enum A_enum
    {
        E0,
        E1,
        E2
    };

    static bool test(A_enum val)
    {
        return (val == E1);
    }
};


int main()
{
    assert(A::test(A::E1));
    return 0;
}

Обратите внимание, что A::test() является статическим. Это должно быть потому, что вы не работаете с состоянием структуры. И поскольку он статичен, вам не нужен экземпляр A для вызова метода.