static-assert

We have a special framework for interfaces in our project, and part of the requirements is that classes which represent an interface may only be used as virtual base classes, not as non-virtual ones. Is there a way to enforce this in code? That is, produce a compilation error if the class is derived from non-virtually. I have access to C++11 as implemented by VS 2010: this means static_assert , enable_if and <type_traits> are available. IMO, there is no clean and platform independent solution available to this problem. The best way is to manually go and change each and every inheritance to

I've wrote several constexpr functions and use them in static_asserts to control some resource limits. But I'd like to not only enforce compile-time predicate but also to see the actual values calculated during normal compilation process or at least when assertion fails. There are ways to print string messages during compilation, but what's about printing results of constexpr computations? Here is some code that exploits gcc's diagnostic messages to print values of interest after an assert message. To find the values of interest, you just need to search the error string for T x = : #include

Inspired by this question , i'm wondering if there is some compile-time check one can introduce to detect if two given template instantiations: template <typename T> class Templ... typedef Templ<std::string> stringInstance; typedef Templ<double> doubleInstance; are constructed from the same definition, or if they are built from different specializations of the Templ template so basically the hypothetical template function will behave like this: template <typename T> class Templ {} template <> class Templ<std::string> {} template <> class Templ<double> {} template <typename T1,typename T2>

Here is a simplified version of what I'm trying to do enum First { a, b, c, nbElementFirstEnum, }; enum Second { a, b, c, nbElementSecondEnum, }; static_assert( First::nbElementFirstEnum == Second::nbElementSecondEnum, "Not the same number of element in the enums."); /*static_assert( First::nbElementFirstEnum == Second::nbElementSecondEnum, "Not the same number of element in the enums." + First::nbElementFirstEnum + " " + Second::nbElementSecondEnum);*/ But I would like to be able to print the value of First::nbElementFirstEnum and Second::nbElementSecondEnum in the assert message (like in the

Our existing compile-time assert implementation is based on negative array index, and it provides poor diagnostic output on GCC. C++0x's static_assert is a very nice feature, and the diagnostic output it provides is much better. I know GCC has already implemented some C++0x features. Does anyone know if static_assert is among them and if it is then since what GCC version? According to this page , gcc has had static_assert since 4.3. If you need to use a gcc version which does not support it you can use #include <boost/static_assert.hpp> BOOST_STATIC_ASSERT( /* assertion */ ) Basically, what

I'd like to have a C++0x static_assert that tests whether a given struct type is POD (to prevent other programmers from inadvertently breaking it with new members). ie, struct A // is a POD type { int x,y,z; } struct B // is not a POD type (has a nondefault ctor) { int x,y,z; B( int _x, int _y, int _z ) : x(_x), y(_y), z(_z) {} } void CompileTimeAsserts() { static_assert( is_pod_type( A ) , "This assert should not fire." ); static_assert( is_pod_type( B ) , "This assert will fire and scold whoever added a ctor to the POD type." ); } Is there some kind of is_pod_type() macro or intrinsic that I