static-assert

Update I posted a working rough draft of rebind as an answer to the question. Though I didn't have much luck finding a generic way to keep static_assert s from breaking metafunctions. Basically I want to check if a templated type T<U, Args...> can be constructed from some other type T<V, Args...> . Where T and Args... is the same in both types. The problem is, T<> might have a static_assert in it that totally breaks my metafunction. Below is a rough summary of what I'm trying to do. template<typename T> struct fake_alloc { using value_type = T; }; template<typename T, typename Alloc = fake

This question is inspired from my previous question No template parameter deduction of parameter pack . Consider following code example: #include <memory> #include <string> template<typename... FArgs> class Callback { public: class Handle{}; }; class BaseCallbackHandle { }; using TypeErasedCallbackHandle = std::unique_ptr<BaseCallbackHandle>; template<typename H> TypeErasedCallbackHandle makeTypeErasedCallbackHandle( H handle) { return {}; } int main() { Callback<int>::Handle h; std::string s; makeTypeErasedCallbackHandle(h); //should compile fine makeTypeErasedCallbackHandle(s); //should

Can static_assert check if a type is a vector? IE, an int would raise the assertion, whereas a vector<int> would not. I'm thinking of something along the lines of: static_assert(decltype(T) == std::vector, "Some error") Yes. Consider the following meta function: #include <stdio.h> #include <vector> template <class N> struct is_vector { static const int value = 0; }; template <class N, class A> struct is_vector<std::vector<N, A> > { static const int value = 1; }; int main() { printf("is_vector<int>: %d\n", is_vector<int>::value); printf("is_vector<vector<int> >: %d\n", is_vector<std::vector<int

With the following macro: #define ASSERT_IF_TEMP(expr) static_assert(?, "Is temporary!"); What should I put for question mark? First we should clarify: What do you mean by "temporary"? Many people mean different things when they say temporary. Technically, int() is not a temporary, but most people will include them into their own meaning of that term. Technically, given std::string s; , then move(s) isn't a temporary either, but you may want to treat it as one with your macro. The first kind of "temporaries" I mentioned above are really "prvalue expressions". Those are the std::string("foo")

Given the following #include <array> struct litmus final : std::array<unsigned char, 16> { }; static_assert(std::is_pod<std::array<unsigned char, 16> >::value, "not pod"); // this fails on MSVC: static_assert(std::is_pod<litmus>::value, "not pod"); The following compilers agree that litmus is pod: clang++ version 3.5 (trunk 198621) http://coliru.stacked-crooked.com/a/7add7a2fe58a7e38 g++ 4.8.1 http://coliru.stacked-crooked.com/a/74cfe97f06c8c128 However, MSVC12 (VS2013 RTM) maintains that the second assert fails. Who's right? Is there any trick to make MSVC treat the class as pod? EDIT For

I want to create a structure that allocates statically an array of 2^N bytes , but I don't want the users of this structure to specify this size as the exponent. Example: my_stupid_array<char, 32> a1; // I want this! my_stupid_array<char, 5> a2; // And not this... How do I check if this template parameter is a power of two and warn the user with a nice message about this? I've been able to check for this with a simple template: template<int N> struct is_power_of_two { enum {val = (N >= 1) & !(N & (N - 1))}; }; However, I'm unable to warn the user about this with a sane message. Any ideas? EDIT