An assert macro which expands to static_assert when possible?

Question

I have some generic code that needs to run an assertion over the result of a member function. This member function may be constexpr, or it may not be.

template<typename T>
void foo(T t) {
  assert(t.member_function() == 10);
}

Because t.member_function() might be a constant expression, I'm wondering if it's possible to be treated as a static_assert in such cases, but otherwise default to a normal assert. Is this possible?

Similar to http://stackoverflow.com/q/11441302/560648. Not sure it's that applicable though. — Lightness Races in Orbit, Aug 13 '13 at 18:23
http://stackoverflow.com/q/6939103/560648 is closer, and [it says the answer is "no"](http://stackoverflow.com/a/6941680/560648). — Lightness Races in Orbit, Aug 13 '13 at 18:25
[stackoverflow.com/questions/18648069](http://stackoverflow.com/questions/18648069/g-doesnt-compile-constexpr-function-with-assert-in-it) is even more close and says "yes but" — Patrick Fromberg, Sep 10 '13 at 09:10

Aaron McDaid · Answer 1 · 2013-10-04T22:42:02.920

This is a slightly crazy solution.

Uncomment the Const c; foo(c); line and you'll see that it won't compile. This is the compile-time assert.

It requires variable length arrays, and maybe other compiler specific stuff. I'm on g++-4.6.

The size of the array is either 0 or -1, depending on whether the member function returns 10. So if this can be computed at compile-time, then the compile realizes it's a non-variable length array, and that it has negative size. The negative size allows it to complain. Otherwise, it falls through to a conventional assert.

Please note: I'm getting some core dump with the Runtime version just after the runtime assertion fails. Maybe it doesn't like trying to free an array with negative size. Update: I'm getting core dumps with any assertion failure, even int main() {assert (1==2);}. Is this normal?

#include <iostream>
#include <cassert>
using namespace std;

struct Const {
        constexpr int member_function() { return 9; }
};
struct Runtime {
                  int member_function() { return 9; }
};

template<typename T>
void foo(T t) {
        if(0) {  // so it doesn't actually run any code to malloc/free the vla
            int z[(t.member_function()==10)-1]; // fails at compile-time if necessary
        }
        assert(t.member_function()==10);
}


int main() {
        //Const c; foo(c);
        Runtime r; foo(r);
}

cool hack. although i'd have assumed the compiler be smart enough to directly ignore the if(0). lol like what if a constexpr of false were in an if statement. but i guess if might try compile what's inside with the constexpr creating that -1 size array, which fails the assertion. — Puddle, Nov 23 '18 at 19:47

An assert macro which expands to static_assert when possible?

1 Answers1