Great question! Even though you use the same py::enum_ syntax to bind both regular enums and enum classes, there are subtle but important differences in how they behave in Python. Here's a breakdown of the key distinctions you might have missed:

1. Implicit Integer Conversion #

• Regular enums (enum words): Since C++ allows implicit conversion of regular enums to integers, pybind11 mirrors this behavior in Python. You can freely convert between enum values and integers without explicit casting:

  print(int(words.hello))  # Outputs 0
  print(words.hello + 1)   # Outputs 1
  

• Enum classes (enum class options): C++ enum classes are strongly typed and don’t support implicit conversion to integers. In Python, this means you can’t directly perform arithmetic or implicit conversion unless you explicitly cast to an integer:

  print(int(options.maybe))  # Works (explicit cast)
  print(options.maybe + 1)   # Throws a TypeError (no implicit conversion)
  

2. Type Safety in Function Arguments #

If you have C++ functions that accept these enum types as parameters:

• For a regular enum (words), pybind11 will automatically accept integers as valid inputs and convert them to the corresponding enum value:

  void func(words w) { /* ... */ }
  

  func(0)  # Works, gets converted to words.hello
  func(words.world)  # Also works
  

• For an enum class (options), pybind11 enforces strict type safety—you can’t pass an integer directly; you must pass the enum value itself or explicitly cast the integer to the enum type:

  void func(options o) { /* ... */ }
  

  func(0)  # Throws TypeError: incompatible function arguments
  func(options.maybe)  # Works
  func(options(0))     # Works (explicit cast from integer)
  

3. Underlying Type Consistency #

• Regular enums in C++ have an implementation-defined underlying type (typically int unless specified otherwise). Pybind11 will infer this type, but if you want to explicitly set it, you need to use py::enum_<words, int>(...) (or another type).
• Enum classes allow you to explicitly specify an underlying type in C++ (e.g., enum class options : uint8_t { maybe, yes, no };). Pybind11 respects this underlying type when converting to Python integers, ensuring the value matches exactly what’s defined in C++. For regular enums, you can also specify the underlying type in the binding, but it’s not required by default.

4. Scoping (C++ vs Python) #

In C++, enum class values require the scope resolution operator (options::maybe), while regular enum values can be accessed without the enum name if they’re in the same scope. However, in Python, both types are fully scoped under their enum class name (e.g., options.maybe and words.hello), so this difference doesn’t translate to Python usage.

Are There Any Other Differences? #

For most common use cases, these are the main distinctions. The binding syntax is identical because pybind11’s enum_ template handles both types automatically, adapting its behavior based on whether it’s dealing with a regular enum or an enum class.

So to sum up: the core differences stem from C++’s inherent type safety rules for enum classes, which pybind11 faithfully replicates in Python. Regular enums retain their implicit conversion flexibility, while enum classes enforce stricter type checks.

内容的提问来源于stack exchange，提问作者Alpha Omega 111000