static-assert

Could you give an example where static_assert(...) 'C++0x' would solve the problem in hand elegantly? I am familiar with run-time assert(...) . When should I prefer static_assert(...) over regular assert(...) ? Also, in boost there is something called BOOST_STATIC_ASSERT , is it the same as static_assert(...) ? Off the top of my head... #include "SomeLibrary.h" static_assert(SomeLibrary::Version > 2, "Old versions of SomeLibrary are missing the foo functionality. Cannot proceed!"); class UsingSomeLibrary { // ... }; Assuming that SomeLibrary::Version is declared as a static const, rather than

I have tried to use this suggestion to do a static assert, but I do not get a compilation error if I use it within a method of a template. The example follows : #include <iostream> #define STATIC_ASSERT(expr, msg) \ { \ char STATIC_ASSERTION__##msg[(expr)?1:-1]; \ (void)STATIC_ASSERTION__##msg[0]; \ } template <typename T > class A { public: int foo(const int k ) { // does not work STATIC_ASSERT( k > 9, error_msg ); return k+5; } }; int bar(const int k ) { // works fine //STATIC_ASSERT( k > 9, error_msg ); return k+5; } int main() { A<int> a; const int v = 2; std::cout<<a.foo(v)<<std::endl;

P0292R1 constexpr if has been included , on track for C++17. It seems useful (and can replace use of SFINAE), but a comment regarding static_assert being ill-formed, no diagnostic required in the false branch scares me: Disarming static_assert declarations in the non-taken branch of a constexpr if is not proposed. void f() { if constexpr (false) static_assert(false); // ill-formed } template<class T> void g() { if constexpr (false) static_assert(false); // ill-formed; no // diagnostic required for template definition } I take it that it's completely forbidden to use static_assert inside

Since boost is forbidden in a company I work for I need to implement its functionality in pure C++. I've looked into boost sources but they seem to be too complex to understand, at least for me. I know there is something called static_assert() in the C++0x standart, but I'd like not to use any C++0x features. AProgrammer One other trick (which can be used in C) is to try to build an array with a negative size if the assert fail: #define ASSERT(cond) int foo[(cond) ? 1 : -1] as a bonus, you may use a typedef instead of an object, so that it is usable in more contexts and doesn't takes place

How would one properly do a static_assert within a constexpr function? For example: constexpr int do_something(int x) { static_assert(x > 0, "x must be > 0"); return x + 5; } This is not valid C++11 code, because a constexpr function must only contain a return statement. I don't think that the standard has an exception to this, although, the GCC 4.7 does not let me compile this code. This is not valid C++11 code, because a constexpr function must only contain a return statement. This is incorrect. static_assert in a constexpr function are fine. What is not fine is using function parameters in