如何让C++创建一个使用编译时检查常量和断言变量的表达式？

Question

下面是一个示例setup ...宏或模板CHECKEXPR_RETURNVAL（EXPR，VAL），它在返回VAL时检查EXPR是否为TRUE。

这是一个不同的地方有用的 - 就像这个高度简化的例子：

#define ISPOW2(VAL)   ((0!=VAL)&&(0==(VAL&(VAL-1)))) 
#define _ALIGNPOW2(VAL,ALIGN) ((VAL+(ALIGN-1))&(~(ALIGN-1))) 

#define ALIGNPOW2(VAL,ALIGN) CHECKEXPR_RETURNVAL(\ 
    ISPOW2(ALIGN) , _ALIGNPOW2(VAL,ALIGN)) 

所以，难的是这样的：我想要做的，如果可能的编译时检查，如果该值不是在编译时确定的常量，然后执行运行时检查。

基本上，这个想法是尽快捕捉不好的参数;如果你可以在编译时捕获一个坏的参数，那比在运行时发现更好。而且，编译时版本对于常量初始值设定项是必需的。

---

这里是我的两个（失败）的尝试使在多个地方单机版的工作（作为一个常量数组的大小，作为一个枚举初始化，并与变量的函数）。不幸的是，它们只能在编译时（常量初始化）或运行时才工作 - 我想找出一个适用于这两者的版本。

// CHECKEXPR_RETURNVAL - version "A" 
#define CTCHECK_EXPR(EXP)(CTCheckBool<EXP>::ExistsZeroIfTrue) 
template <bool bExpression> struct CTCheckBool {}; 
template <> struct CTCheckBool<true> {enum{ExistsZeroIfTrue=0};}; 
// Note: Plus ("+") is used rather than comma operator because 
// the comma operator can not be used for constant initializers 
#define CHECKEXPR_RETURNVAL_A(EXP,VAL) (CTCHECK_EXPR(EXP) + (VAL)) 

// Test Out version "A" -- works only for Compile Time Constants 
#define ALIGNPOW2_A(VAL,ALIGN) CHECKEXPR_RETURNVAL_A(\ 
    ISPOW2(ALIGN) , _ALIGNPOW2(VAL,ALIGN)) 

char AlignedVar_A[ALIGNPOW2_A(2,8)]; 
enum { AlignedVal_A = ALIGNPOW2_A(57,16) }; 

int TestAlignPow2_A(int val, int align) 
    {return(ALIGNPOW2_A(val,align));}  // Compile Error 


// CHECKEXPR_RETURNVAL - version "B" 
template<typename T> T CHECKEXPR_RETURNVAL_B(bool bExpr,T val) 
    { ASSERT(bExpr); return(val); } 

// Test Out version "B" -- works only for Runtime Computed Values 
#define ALIGNPOW2_B(VAL,ALIGN) CHECKEXPR_RETURNVAL_B(\ 
    ISPOW2(ALIGN) , _ALIGNPOW2(VAL,ALIGN)) 

char AlignedVar_B[ALIGNPOW2_B(2,8)];  // Compile Error 
enum { AlignedVal_B = ALIGNPOW2_B(57,16) }; // Compile Error 

int TestAlignPow2_B(int val, int align) 
    {return(ALIGNPOW2_B(val,align));} 

不幸的是，两种版本都不适用于所有三种情况。是否有一个适用于所有情况的代码结构？

Answer 1

好像你真的会使用的C++ 0x constexpr功能...

Answer 2

嗯......不是一个完整的答案，但我认为你可以得到这个，你想要什么：

#include <stdio.h> 

template <int I> struct S{ 
    static void doIt(){ 
     fprintf(stderr, "wow\n"); 
    } 
}; 

template<> void S<0>::doIt(){ 
    fprintf(stderr, "oops\n"); 
} 

#define EXPR(p) S<(int)((bool)(p))>::doIt()  

int main(int argc, char** argv){ 
    EXPR((5+2)==7); 
    EXPR((5+2)==8); 
    const int a = 58; 
    EXPR(a==58); 
    EXPR(58); 
    return 0; 
} 

可以基于表达式得到一个编译错误：

#include <stdio.h> 

template <int I> struct S{ 
    static void doIt(){ 
     ssdfkjehiu //deliberately invalid code 
     fprintf(stderr, "oops\n"); 
    } 
}; 

template<> void S<1>::doIt(){ 
    fprintf(stderr, "wow\n"); 
} 

#define EXPR(p) S<(int)((bool)(p))>::doIt() 



int main(int argc, char** argv){ 
    EXPR((5+2)==7); 
    EXPR((5+2)==8);//uncomment it to make code compile 
    const int a = 58; 
    EXPR(a==58); 
    EXPR(58); 
    return 0; 
} 

但是，这会导致错误将是一个漫长的模板错误信息的中间线。例如：

1.cpp(6) : error C2065: 'asdlfkjhasd' : undeclared identifier 
     1.cpp(4) : while compiling class template member function 'void S<I>::doIt(void)' 
     with 
     [ 
      I=0 
     ] 
     1.cpp(19) : see reference to class template instantiation 'S<I>' being compiled 
     with 
     [ 
      I=0 
     ] 
1.cpp(6) : error C2146: syntax error : missing ';' before identifier 'fprintf' 

正如您所看到的，错误是由消息中间提到的第19行引起的。这有点不方便。

我不能保证这两个示例都不依赖于某些未定义的C++行为。

另外，我认为未来的代码维护者可能不满意这个...

附：我想你也应该看看提升。如果我没有记错的话，它有相当多的“魔术预处理器宏”（例如循环），所以它有可能实现了类似的东西。

- 编辑 -
好了，这个怎么样？：

#include <stdio.h> 
#include <string> 

template <typename T> void a(T &i){ 
    fprintf(stderr, "variable\n"); 
} 

void a(const char* const i){ 
    fprintf(stderr, "constant\n"); 
} 

void a(bool i){ 
    fprintf(stderr, "constant\n"); 
} 

int main(int argc, char** argv){ 
    int i; 
    float f; 
    std::string s; 
    const char* s1 = "b"; 
    a(3); 
    a(3+2); 
    a(1.0f); 
    a('a'); 
    a("b"); 
    a(i); 
    a(f); 
    a(s); 
    a(s1); 
    return 0; 
}