How to introduce static_assert into template variable definition

Question

How to introduce static_assert into template variable definition?

My attemption is to use lambda function:

#include <type_traits>
#include <utility>

#include <cstdlib>

namespace
{
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wglobal-constructors"

template< typename F >
F f = ([] () { static_assert(std::is_default_constructible< F >{}); }(), F{});

#pragma clang diagnostic pop
}

struct L
{
    L() = default;
    L(L const &) = delete;
    L(L &&) = delete; 
};

int
main()
{
    static_cast< void >(f< L >);
    return EXIT_SUCCESS;
}

But for non-moveable objects it is impossible to construct the value object in such a manner.

Using comma operator I can't perform value-initialization in form F f = ([] () { static_assert(std::is_default_constructible< F >{}); }(), {});.

I can't use additional template parameter in form , typename = decltype([] () { static_assert(std::is_default_constructible< F >()); }), due to it is an error lambda expression in an unevaluated operand.

Disabling instantiation by SFINAE is not the solution. I do need static_assert to say user about error explicitly.

It would be nice if static_assert return void or bool.

`template< typename F >class F_class{ static_assert(...); using type=F; }; template< typename F > typename F::type f;` — zch, Sep 25 '15 at 12:29
With SFINAE, error message is not very clear :( [Demo](http://coliru.stacked-crooked.com/a/f3b79dcc2d79186a) — Jarod42, Sep 25 '15 at 12:32
@zch Strictly saying I want to introduce the `static_assert` directly into variable template definition. — Tomilov Anatoliy, Sep 25 '15 at 12:33
Why? If it isn't default constructible the variable template definition will tell you that anyway. Will the obfuscation of the code really be worth a slightly better error message? — Jonathan Wakely, Sep 25 '15 at 12:38
@JonathanWakely *Default constructible* is just an example. I consider general problem. — Tomilov Anatoliy, Sep 25 '15 at 12:43

score 5 · Accepted Answer · answered Sep 25 '15 at 12:36

5

template<typename T>
struct require_default_constructible {
  static_assert(std::is_default_constructible<T>{}, "is default constructible");
  using type = T;
};

namespace
{
template< typename F >
  typename require_default_constructible<F>::type f{};
}

Or so the check appears directly in the variable template:

template<typename T, bool B>
struct check {
  static_assert(B, "???");
  using type = T;
};

namespace
{
template< typename F >
  typename check<F, std::is_default_constructible<F>::value>::type f{};
}

answered Sep 25 '15 at 12:36

Jonathan Wakely

166,810
27
341
521

Second variant is exact solution. It clearly saying what is checked into variable template definition directly. – Tomilov Anatoliy Sep 25 '15 at 12:41
1

I still think it's a waste of time asserting that something you default construct is default constructible. – Jonathan Wakely Sep 25 '15 at 12:42
*Default constructible* is just an example. I consider general problem. – Tomilov Anatoliy Sep 25 '15 at 12:44

How to introduce static_assert into template variable definition

1 Answers1