For a small project I'm working on, I've been looking for an iterable enum-like class in C++, since neither C-style nor scoped enums seem to support iteration in a way that isn't hack-y. I stumbled across this (relatively) old article, from which I've drawn inspiration to create a robust Enum class supporting iteration and C++11 features.The client simply creates a DEnum class, which includes the desired enum items as static const members, inheriting from this Enum class. This prevents code using DEnum from creating new items. Local object copies of the enum items can be created through the default copy and copy-assignment ctors. I've also added a function that allows creation of a local subset of the enum items, which also supports iteration (including using range-for syntax). The class should be type-safe in preventing type conversion of its members and instantiated copies.I'm just looking for any tips on how I could implement this better. Does this code follow C++11 best practices? Are there any problems I've overlooked?// enum.h#ifndef ENUM_H_#define ENUM_H_#include <algorithm>#include <functional>#include <initializer_list>#include <iostream>#include <set>template <class T>class Enum { private:  // Comparator used to determine enum item ordering  struct EnumLTComparator {    bool operator() (const T* e1, const T* e2) {      return e1->value() < e2->value();    }  }; public:  typedef std::set<const T*, EnumLTComparator> ItemsSet;  typedef typename ItemsSet::size_type set_size_type;  typedef typename ItemsSet::const_iterator const_iterator;  typedef typename ItemsSet::const_reverse_iterator const_r_iterator;  int value() const { return value_; }  static set_size_type size() { return items_.size(); }  // Iteration  static const_iterator begin() { return items_.cbegin(); }  static const_iterator end() { return items_.cend(); }  static const_r_iterator rbegin() { return items_.crbegin(); }  static const_r_iterator rend() { return items_.crend(); }  bool operator== (T e2) const {return this->value() == e2.value();}  // Return a set which contains pointers to any number of unique enum items  static ItemsSet Subset(std::initializer_list<T> items) {    ItemsSet subset;    for (auto i: items) {      subset.insert(CorrespondingEnum(i.value()));    }    return subset;  } protected:  // Constructors  explicit Enum(int value): value_(value) {    // Warn clients if they try to add multiple items with the same value    if (IsValidValue(value)) {      std::cerr << The value \' << value << \' has been assigned to                 << multiple items in this enum. All duplicates are omitted                 << from the set. << std::endl;      return;    }    // This cast seems ugly, since the object being constructed by the    //   inheriting class will already be of type T, but I don't see any    //   way around this.    items_.insert(static_cast<T*>(this));  }  // Compiler-generated copy and copy-assign ctors generate local copies of  //   the static enum items private:  static const T* CorrespondingEnum(int value) {    auto EnumPredicateCorresponds = [value](const T* elem) -> bool {      return elem->value() == value;    };    const_iterator it = find_if(items_.begin(),                                items_.end(),                                EnumPredicateCorresponds);    return (it != items_.end()) ? *it : nullptr;  }  static bool IsValidValue(int value) {    return CorrespondingEnum(value) != nullptr;  }  int value_;  static ItemsSet items_;};#endifAnd a client would use this class as follows:// color.h#ifndef COLOR_H_#define COLOR_H_#include enum.hclass Color: public Enum<Color> { public:  using Enum::Enum; //Color::Color(int) is still protected  static const Color blue;  static const Color green;  static const Color red;  static const Color white;  static const Color yellow;  static const Color multicolor;  static const Color hidden;};#endif~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~// color.cc#include color.h#include enum.h// I would prefer not to require this, but I don't see a way around ittemplate<>typename Enum<Color>::ItemsSet Enum<Color>::items_{};const Color Color::blue(0);const Color Color::green(1);const Color Color::red(2);const Color Color::white(3);const Color Color::yellow(4);const Color Color::multicolor(5);const Color Color::hidden(6);Finally, some testing with cout:#include <iostream>#include color.husing std::cout;using std::endl;int main() {  cout << Color::size() << endl; //7  for (auto iCol = Color::begin(); iCol != Color::end(); ++iCol) {    cout << (*iCol)->value() << endl;  }  /* 0   * 1   * 2   * 3   * 4   * 5   * 7   */  cout << (**(Color::begin()) == Color::blue) << endl;    //1  cout << (**(Color::begin()) == Color::red) << endl;     //0  cout << (**(Color::rbegin()) == Color::hidden) << endl; //1  cout << (**(Color::rbegin()) == Color::yellow) << endl; //0  auto subset = Color::Subset({Color::blue, Color::red});  cout << (**(subset.begin()) == Color::blue) << endl; //1  cout << (**(subset.rbegin()) == Color::red) << endl; //0  for (auto iCol: subset) {    cout << iCol->value() << endl;    // 0    // 2  }  //Color mauve(2); //Error: Color::Color is protected  //Color *col = &(Color::red); //Error: can't convert from 'const Color*'                                //  to Color*'}
Iterable enum class in C++11
c++;c++11;enum