static-assert

I've noticed strange behavior of static_assert : #include <iostream> template <typename T, unsigned int D> struct Vec { static_assert(D && 0, "Invalid dimension for vector!"); }; template <typename T> struct Vec<T, 1> {union {T x, r;};}; template <typename T> struct Vec<T, 2> : Vec<T, 1> {union {T y, g;};}; template <typename T> struct Vec<T, 3> : Vec<T, 2> {union {T z, b;};}; template <typename T> struct Vec<T, 4> : Vec<T, 3> {union {T w, a;};}; int main() { Vec<float, 3> v; v.x = 1; v.y = 2; v.z = 3; return 0; } It compiles fine: http://ideone.com/wHbJYP . I would expect static_assert(0,

I have a problem with the static_assert feature. When I instantiate a class template directly, everything works as expected. But when I pass it as a parameter for the different class template, static_assert does not work. template <int X> class A{ static_assert(X == 0, "X != 0"); }; template <class T> class B{ }; B<A<1>> b; // Static assert does not work A<1> a; // error: static assertion failed: X != 0 EDIT Thanks all for the answers. Is there a way to explicitly instantiate A without creation of A instances / inheriting from A? I was trying this: template <int X> class A{ static_assert(X ==

This is a follow-up to this other question I was trying to establish at compile time whether a specific implementation had added unnamed padding inside a struct. Specific implementation like gcc allow to use pragmas to control padding and alignment in structs but at the price of compatibility with other implementations. As both static_assert and offset_of are required by the n1570 draft for C11, I wanted to use them to see whether an implementation used padding between members. Here is the relevant part of code (full code in referenced question): #include <stdio.h> #include <stddef.h> #include

I want to ensure, that a derived class implements a specific static method. I think doing so should be possible using static_assert , std::is_same , decltype , CRTP and maybe making use of SFINAE . However, similar code I found so far is quite complex and it seems I do not yet fully understand it making me unable to adopt it to my needs. What I tried so far is this template <class T> class Base { static_assert(std::is_same<decltype(T::foo(1)), int>::value, "ERROR STRING"); }; class Derived : public Base <Derived> { public: static int foo(int i) { return 42; }; }; However, it does not compile

This issue has been discussed a few times but all the solutions I have found either didn't work or were based on boost's static assert. My problem is simple. I have a class, and I only want to allow real types (double and float). I want a compile-time error if I try to instantiate the class with a type other than float or double. I am using Visual C++ 11. Here is what I have tried: template <typename RealType> class A { // Warning C4346 static_assert(std::is_same<RealType, double>::value || std::is_same<RealType, float>::value); } template <typename RealType> class A { // Error C2062: type

I like to give helpful errors / messages, and I also want to do so for my static_assert s. The problem is, that they depend on template parameters. Normally, those parameters will get displayed on way or an other due to the error raised, but they are either obscure or not grouped so they make sense. Example: template<class T> struct fake_dependency{ static bool const value = false; }; template<class T, class Tag> struct Foo{ Foo(){} template<class OtherTag> Foo(Foo<T, OtherTag> const&){ static_assert(fake_dependency<T>::value, "Cannot create Foo<T,Tag> from Foo<T,OtherTag>."); } }; int main(){