计数枚举C 自动

不，没有，如果您需要的话，您可能不应该首先使用enum。

在您的特殊情况下，您想致电Count的用例是什么？

afaik没有自动编译器支持的关键字可以获取enum中的总元素。OTOH通常没有意义：只要值不必具有结果值（即，您可以手动分配值，而不是依靠自动编号）。<<<<<<<<<<

一种常见的做法是通过以下方式声明enum：

  typedef enum
    {
        Stopped, 
        Playing, 
        Paused,
        count
    }PossibleValues;  

这样，如果count始终是最后定义的 - 它将为您提供枚举元素的数量，假设编号从0开始，则是。

从类似问题（非序列整数C 枚举的最佳方法是什么是什么），因为它与其他几乎没有解决的问题有关。

您可以用来获得想要的模式是使用std :: prinitizer_list存储枚举的所有值。

namespace PossibleValues
{
    enum Type
    {
        ZERO= 0,
        PLUS180= 180,
        PLUS90= 90,
        MINUS90= -90
    };
    constexpr auto Values = {ZERO, PLUS180, PLUS90, MINUS90};
    size_t Count() { return Values.size(); }
    Type Default() { return *begin(Values); }
}

这也具有能够迭代枚举值的好处，即使它们没有线性值。

我认为您可以同时生成枚举，初始化器列表和带有变异宏的单个宏的功能，尽管在世界上最好的事情应该是标准。

编辑：当我将可能的价值用作枚举或使用struct作为可能的价值时，我的编译器会抱怨不完整的类型。为枚举使用名称空间有点不寻常，但效果很好。

可以改进来自https://stackoverflow.com/a/60216003/12894563的解决方案。我们可以在静态矢量中保存枚举表达式并迭代，获取最小/最大等等

用法：

#include <type_traits>
#include <algorithm>
#include <vector>
#include <iostream>
#define make_enum(Name, Type,  ...)                                              
    struct Name {                                                                
        enum : Type {                                                            
            __VA_ARGS__                                                          
        };                                                                       
        static auto count() { return values.size(); }                            
                                                                                 
        static inline const std::vector<Type> values = [] {                      
            static Type __VA_ARGS__; return std::vector<Type>({__VA_ARGS__});    
        }();                                                                     
        static Type min()                                                        
        {                                                                        
            static const Type result = *std::min_element(values.begin(), values.end()); 
            return result;                                                       
        }                                                                        
        static Type max()                                                        
        {                                                                        
            static const Type result = *std::max_element(values.begin(), values.end()); 
            return result;                                                       
        }                                                                        
}

make_enum(FakeEnum, int, A = 1, B = 0, C = 2, D);
int main(int argc, char *argv[])
{
    std::cout << FakeEnum::A     << std::endl
              << FakeEnum::min() << std::endl
              << FakeEnum::max() << std::endl
              << FakeEnum::count() << std::endl;
    return 0;
}

可能的类型可能是枚举？如果您只需要表现像枚举的事物，则可以执行以下操作：

#include <iostream>
#include <functional>
#include <set>

template <typename Representation, typename T>
class Iterable_Strong_Enum
{
private:
  struct T_Ptr_Less : public std::binary_function<T const *, T const *, bool>
  {
    bool operator()(T const * x, T const * y) const
    {
      return x->get_representation() < y->get_representation();
    }
  };
public:
  typedef std::set<T const *, T_Ptr_Less> instances_list;
  typedef typename instances_list::const_iterator const_iterator;
  Representation const & get_representation() const { return _value; }
  static Representation const & min() { return (*_instances.begin())->_value; }
  static Representation const & max() { return (*_instances.rbegin())->_value; }
  static T const * corresponding_enum(Representation const & value)
  {
    const_iterator it = std::find_if(_instances.begin(), _instances.end(), [&](T const * e) -> bool
    {
      return e->get_representation() == value;
    });
    if (it != _instances.end())
    {
      return *it;
    }
    else
    {
      return nullptr;
    }
  }
  bool operator==(T const & other) const { return _value == other._value; }
  bool operator!=(T const & other) const { return _value != other._value; }
  bool operator< (T const & other) const { return _value <  other._value; }
  bool operator<=(T const & other) const { return _value <= other._value; }
  bool operator> (T const & other) const { return _value >  other._value; }
  bool operator>=(T const & other) const { return _value >= other._value; }
  static bool is_valid_value(Representation const & value) { return corresponding_enum(value) != nullptr; }
  static typename instances_list::size_type size() { return _instances.size(); }
  static const_iterator begin() { return _instances.begin(); }
  static const_iterator end() { return _instances.end(); }
protected:
  explicit Iterable_Strong_Enum(Representation const & value);
private:
  Representation _value;
  static instances_list _instances;
};
template <typename Representation, typename T>
Iterable_Strong_Enum<Representation, T>::Iterable_Strong_Enum(Representation const & value)
: _value(value)
{
  _instances.insert(static_cast<T const *>(this));
}
class PossibleValues : public Iterable_Strong_Enum<int, PossibleValues>
{
public:
  static const PossibleValues Stopped;
  static const PossibleValues Playing;
  static const PossibleValues Pause;
protected:
private:
  explicit PossibleValues(int value);
};
PossibleValues::PossibleValues(int value) : Iterable_Strong_Enum<int, PossibleValues>(value) { }
// you need to call that explicitly
Iterable_Strong_Enum<int, PossibleValues>::instances_list Iterable_Strong_Enum<int, PossibleValues>::_instances;
const PossibleValues PossibleValues::Stopped(0);
const PossibleValues PossibleValues::Playing(1);
const PossibleValues PossibleValues::Pause(2);
void stackoverflow()
{
  std::cout << "There are " << PossibleValues::size() << " different possible values with representation: " << std::endl;
  for (auto pv = PossibleValues::begin(); pv != PossibleValues::end(); ++pv)
  {
    PossibleValues possible_value = **pv;
    std::cout << possible_value.get_representation() << std::endl;
  }
}

我对该解决方案有点撕裂。一方面，它非常普遍，另一方面是一个大问题。