Question

我知道我不能在getValue()语句中使用switch的结果，因为案例树是在编译时构建的。

我所拥有的是一个包含static const成员的类，这些成员在构造函数的运行时设置了常量值。要设置的值始终在编译时已知。

是否可以使用模板或其他解决方案以类型安全的方式定义这些const对象并将它们保持为类的静态成员？

请注意，在这种情况下我不想要enum，因为我想在以下示例中打开不同的类型，例如int。

示例：

#include <iostream>

using namespace std;

class Some_Class {
private:
   int _value;

public:
   Some_Class(int value) {
      _value = value;
   }

   int getValue() const {
      return _value;
   }

   static const Some_Class ONE;
   static const Some_Class TWO;
}; // class

const Some_Class Some_Class::ONE(1);
const Some_Class Some_Class::TWO(2);

int main() {
   int value = 1;

   switch (value) {
      case Some_Class::ONE.getValue():
         cout << "Do thing 1" << endl;
         break;
      case Some_Class::TWO.getValue():
         cout << "Do thing 2" << endl;
   }

   return 0;
}

这不适用于上述问题：

main.cpp(29) : error C2051: case expression not constant
main.cpp(32) : error C2051: case expression not constant

Answer 1

只要构造函数可以是constexpr并且可以继承类，就可以完成类似的操作。由于我们不能static constexpr Some_Class作为Some_Class的成员，我们可以使用派生类来解决这个问题。

#include <iostream>

namespace detail
{
    class Base_Class //Has the functionality
    {
    private:
        int _value;
    public:
        constexpr Base_Class(int value) : _value(value) {}
        constexpr int getValue() const
        {
            return _value;
        }
    };
}

//Inherits functionality, has static members
class Some_Class : public detail::Base_Class
{
public:
    using Base_Class::Base_Class;
    static constexpr Base_Class ONE{1};
    static constexpr Base_Class TWO{2};
};

int main()
{
    int value = 1;
    switch (value)
    {
    case Some_Class::ONE.getValue():
        std::cout << "Do thing 1" << std::endl;
        break;
    case Some_Class::TWO.getValue():
        std::cout << "Do thing 2" << std::endl;
    }
    return 0;
}

有没有办法为静态对象成员定义符合开关的常量？

1 个答案: