How to pass a not explicitly string literal error message to a static_assert?

Question

I have a few static asserts in different places in code.

static_assert(bool_constexpr_1, error_message);
...
static_assert(bool_constexpr_2, error_message);

And want all of them to share the same error_message.

The first solution is to copy-paste the message.

The second one is to #define the error_message.

Is there something better?

P.S. I expected static constexpr auto to work, yet it failed.

I've used `static constexpr auto name[] = ""` before, have you tried that already? — JVApen, Aug 14 '19 at 19:42
@JVApen Are you sure. `static_assert` requires the message to be a string literal. — NathanOliver, Aug 14 '19 at 19:44
No, ain't sure, I know it works in some template situations where everything else ain't working — JVApen, Aug 14 '19 at 19:45
@JesperJuhl The compiler will most likely not even include those strings in the executable. I'd be surprised if they existed even on `-O0`. — Justin, Aug 14 '19 at 19:51
@JesperJuhl No, it doesn't. The string literal is being used inside a `static_assert` and is never used at runtime — Justin, Aug 14 '19 at 19:54

score 4 · Accepted Answer · answered Aug 14 '19 at 19:56

You either have to copy-paste the literal, or use the preprocessor. Per [dcl.dcl]/1 The grammar of static_assert is defined as

static_assert-declaration:
      static_assert ( constant-expression ) ;
      static_assert ( constant-expression , string-literal ) ;

So you either provide a string literal, or you don't. There is no other way to use it.

score 3 · Answer 2 · answered Aug 15 '19 at 05:53

Your question sounds a lot like a variation: How to make static_assert block re-usable in template classes?

You have defined it a bit to generic, however, as you want to reuse the same 'error' message, I would assume that your check will also be similar. Let's use an example where you want to force inheritance:

 struct Interface {};
 struct Impl : Interface {};
 struct Other {};
 static_assert(std::is_base_of_v<Interface, Impl>, "Implementations should inherit from the interface. See document at ... for more details."); // Success
 static_assert(std::is_base_of_v<Interface, Other>, "Implementations should inherit from the interface. See document at ... for more details."); // Failure

Here, it might make sense to implement your own type trait. For example:

 template<typename T> using FrameworkInjectionRequirement = std::is_base_of<Interface, T>
 template<typename T> constexpr bool FrameworkInjectionRequirement_v = FrameworkInjectionRequirement<T>::value;

  static_assert(FrameworkInjectionRequirement_v<Impl>);

By doing this, you already gave a good name to what you try to check, which could be sufficient in order to use the terse version of static_assert instead, without needing an explanation.

Alternatively, you could wrap you assert into a struct:

template<typename T>
struct FrameworkInjectionRequirement {
    static_assert(std::is_base_of_v<Interface, T>, "Implementations should inherit from the interface. See document at ... for more details.");
};
constexpr static FrameworkInjectionRequirement<Impl> check{}; // Success
constexpr static FrameworkInjectionRequirement<Other> check{}; // Failure

By instantiating this zero-size struct at compile time (thanks to constexpr on the variable), the assert will be checked. Not only can you reuse the message into it, you again gave your check a good name. As a bonus, you can split up the different elements creating the boolean expression into it's distinct elements, which will assist you if one of them fails.

How to pass a not explicitly string literal error message to a static_assert?

2 Answers2