C++ c++；：是否有类似“的东西？”；boost/std类型特征条件“；在编译时生成值（而不是类型）的？

我目前正在执行以下操作，以便在编译时生成一个值，这很有效：

        //if B is true, m_value = TRUEVAL, else FALSEVAL, T is the value type
        template<bool B, class T, T TRUEVAL, T FALSEVAL>
        struct ConditionalValue
        {
            typedef T Type;

            Type m_value;

            ConditionalValue():
            m_value(TRUEVAL)
            {}
        };

        template<class T, T TRUEVAL, T FALSEVAL>
        struct ConditionalValue<false, T, TRUEVAL, FALSEVAL>
        {
            typedef T Type;

            Type m_value;

            ConditionalValue():
            m_value(FALSEVAL)
            {}
        };

//如果B为true，m_value=TRUEVAL，否则为false val，T为值类型
模板
结构条件值
{
T型；
类型m_值；
条件值（）：
m_值（真值）
{}
};
模板
结构条件值
{
T型；
类型m_值；
条件值（）：
m_值（假值）
{}
};

然后，您可以简单地执行以下操作：

template<class T>
void loadPixels(uint32 _w, uint32 _h, T * _pixels)
{
    PixelDataType::Type pixelType = PixelDataType::Auto; //enum I want to set

    ConditionalValue<boost::is_same<T, uint8>::value, PixelDataType::Type, PixelDataType::UInt8, PixelDataType::Auto> checker;
    pixelType = checker.m_value;

   ConditionalValue<boost::is_same<T, uint16>::value, PixelDataType::Type, PixelDataType::UInt16, PixelDataType::Auto> checker2;
   pixelType = checker2.m_value;

   ...

}

模板
无效加载像素（uint32\u w、uint32\u h、T*\u像素）
{
PixelDataType:：Type pixelType=PixelDataType:：Auto；//我要设置的枚举
条件值检查器；
pixelType=checker.m_值；
条件值校验器2；
pixelType=checker2.m_值；
...
}

我知道这个例子没有多大意义，但我使用该代码在编译时设置枚举的值。-因此，我的问题是：在std/boost type traits allready中是否有类似的内容？当浏览引用时，我只发现它几乎满足了我的要求，但只生成了一个类型，而不是一个值

编辑：

更新的示例

Edit2:

我刚刚意识到boost:：is_same:：value是我解决问题所需要的全部。-至于问题的答案：正如thiton所指出的，std/boost中似乎没有包含任何内容

EDIT3: 如果您仍在寻找在编译时创建值的解决方案，那么您可以使用my code wich works。如果您正在寻找与boost/stl非常接近的产品，Kerrek或Nawaz似乎也是有效的解决方案。如果您正在寻找一种在编译时分配正确枚举的解决方案，那么Luc-Touraille方法似乎很有趣，尽管我认为这对于我的情况来说太过分了

有一组类在编译时操作数据类型，以及一些算术运算。这些类将一个值包装到一个类型中，例如整数

4

可以用类型

mpl:：int\uu

表示

您可以在编译时条件中使用这些选项：

typedef typename 
    mpl::if_< 
        boost::is_same< T, uint8 >, 
        mpl::int_< 42 >, 
        mpl::int_< 187 >
    >::type result;

int i = result::value;

typedef typename
mpl：：如果
boost：：是相同的吗，
mpl:：int<42>，
mpl：：int_uu<187>
>：：输入结果；
int i=结果：：值；

MPL还提供了可用于枚举的通用方法：

template<class T>
void loadPixels(uint32 _w, uint32 _h, T * _pixels)
{
    PixelDataType::Type pixelType = PixelDataType::Auto; //enum I want to set

    typedef typename mpl::if_<
        boost::is_same<T, uint8>, 
        mpl::integral_c<PixelDataType::Type, PixelDataType::UInt8>,
        mpl::integral_c<PixelDataType::Type, PixelDataType::Auto>
    >::type checker;

    pixelType = checker::value;

    typedef typename mpl::if_<
        boost::is_same<T, uint16>, 
        mpl::integral_c<PixelDataType::Type, PixelDataType::UInt16>,
        mpl::integral_c<PixelDataType::Type, PixelDataType::Auto>
    >::type checker2;

    pixelType = checker2::value;

    ...
}

模板
无效加载像素（uint32\u w、uint32\u h、T*\u像素）
{
PixelDataType:：Type pixelType=PixelDataType:：Auto；//我要设置的枚举
typedef typename mpl:：if_<
boost：：是一样的，
mpl：：积分，
mpl：：积分
>：：类型检查器；
pixelType=棋盘格：：值；
typedef typename mpl:：if_<
boost：：是一样的，
mpl：：积分，
mpl：：积分
>：：类型检查器2；
pixelType=checker2:：value；
...
}

如果你有很多这样的映射，你可以考虑使用一个混合编译时/运行时数据结构，例如，但这可能有点过头：）：

typedef fusion:：map<
融合：：配对，
fusion:：pair>
地图类型；
映射类型像素类型映射(
生成一对（PixelDataType:：UInt8），
生成_对（PixelDataType:：UInt16））；
...
模板
无效加载像素（uint32\u w、uint32\u h、T*\u像素）
{
//如果T不在地图上，需要特殊处理
PixelDataType:：Type pixelType=fusion:：at_键（pixelTypesMap）；
...
}

您可以自己编写：

namespace extend 
{
  template<bool B, class T, T X, T Y>  
  struct conditional
  {
       static const T value = X;
  };
  template<class T, T X, T Y>  
  struct conditional<false,T,X,Y>
  {
       static const T value = Y;
  };
}

//test
assert(conditional<std::is_same<int,int>::value, int, 10, 20>::value == 10);
assert(conditional<std::is_same<int,char>::value, int, 10, 20>::value == 20);

名称空间扩展
{
模板
结构条件
{
静态常数T值=X；
};
模板
结构条件
{
静态常数T值=Y；
};
}
//试验
断言（条件：：值==10）；
断言（条件：：值==20）；

在某些情况下，

std:：conditional

和

std:：integral\u constant

的组合可能会起作用：

template <bool B, typename T, T trueval, T falseval>
struct conditional_val : std::conditional<B,
       std::integral_constant<T, trueval>,
       std::integral_constant<T, falseval>>::type
{ };

---

我认为答案很简单：因为运算符？：可以很好地选择值。类型更难选择，这就是为什么存在boost构造。对于病理病例，boost:：mpl magic Luc建议的方法很好，但应该很少见。

我遇到了一个案例，我需要做

？

所做的事情（比较值、返回值），但使用模板专门化（为什么需要这样做？很简单：

？

的编译时评估可能会导致“无法访问代码”警告）

因此，对于您的原始问题和我的imho，最标准的解决方案是：

std::conditional<myval, 
                 std::integral_constant<T, val>, 
                 std::integral_constant<T, val>
                >::type::value;

std:：conditional:：type:：value；

---

现在只需将“myval”替换为

std:：is_same

，您就有了一个案例解决方案（比较类型、返回值），而上面是我案例的解决方案（比较值、返回值

？

）

为什么你不能直接编写

bool b=boost:：is_same:：value；

并完全跳过

检查器呢？我想你需要一个更好的例子来激发这一点，因为听起来你要求的工作实际上比已经存在的工作要多。是的，这个例子很愚蠢。-如上所述，我试图将枚举的值设置为c文件时间。-我将更新我猜的示例。关于Edit2：有一些解决方案，@Kerrek和我都给了你一些。这些可能对你的特定用例没有用处，但在进行更繁重的元编程时非常有价值。我将编辑答案并指出这一点！我准备好了自己写的……我问是否有类似于在inside std/boost typetraits，这样我就可以用它来代替。@moka:你的态度真是忘恩负义，令人沮丧。我试图帮助你，你因此惩罚了我。那一刻我只是觉得你对我的问题的回答是错误的。-我还能做什么
const int q = conditional_val<B, int, 12, -8>::value;

const int q = B ? 12 : -8;

std::conditional<myval, 
                 std::integral_constant<T, val>, 
                 std::integral_constant<T, val>
                >::type::value;