Meta programming: Declare a new struct on the fly

Question

Is it possible to declare a new type (an empty struct , or a struct without an implementation) on the fly?

E.g.

constexpr auto make_new_type() -> ???;

using A = decltype(make_new_type());
using B = decltype(make_new_type());
using C = decltype(make_new_type());

static_assert(!std::is_same<A, B>::value, "");
static_assert(!std::is_same<B, C>::value, "");
static_assert(!std::is_same<A, C>::value, "");

A "manual" solution is

template <class> struct Tag;

using A = Tag<struct TagA>;
using B = Tag<struct TagB>;
using C = Tag<struct TagC>;

or even

struct A;
struct B;
struct C;

but for templating / meta some magic make_new_type() function would be nice.

Can something like that be possible now that stateful metaprogramming is ill-formed?

Scrapple

Why would someone want to do this ? what is a typical use case? – Disraeli

Every lambda has a unique type :) As far as I know, they are the “just give me a unique type” idiom — the only one in C++11. – Jule

Related: unconstexpr. (no longer works as of GCC 8, and the code there is probably ill-formed NDR) – Schoenberg

"On the fly" in this question does not mean at runtime. – Bromic

Answer 1

In C++20:

using A = decltype([]{}); // an idiom
using B = decltype([]{});
...

This is idiomatic code: that’s how one writes “give me a unique type” in C++20.

In C++11, the clearest and simplest approach uses __LINE__:

namespace {
  template <int> class new_type {};
}

using A = new_type<__LINE__>; // an idiom - pretty much
using B = new_type<__LINE__>;

The anonymous namespace is the most important bit. It is a serious mistake not to put the new_type class in the anonymous namespace: the types then won't be unique anymore across translation units. All sorts of hilarity will ensue 15 minutes before you plan to ship :)

This extends to C++98:

namespace {
  template <int> class new_type {};
}

typedef new_type<__LINE__> A; // an idiom - pretty much
typedef new_type<__LINE__> B;

Another approach would be to manually chain the types, and have the compiler statically validate that the chaining was done correctly, and bomb out with an error if you don’t. So it’d not be brittle (assuming the magic works out).

Something like:

namespace {
  struct base_{
    using discr = std::integral_type<int, 0>;
  };

  template <class Prev> class new_type {
    [magic here]
    using discr = std::integral_type<int, Prev::discr+1>;
  };
}

using A = new_type<base_>;
using A2 = new_type<base_>;
using B = new_type<A>;
using C = new_type<B>;
using C2 = new_type<B>;

It takes only a small bit of magic to ensure that the lines with types A2 and C2 don’t compile. Whether that magic is possible in C++11 is another story.

Aedes

Is "lambda expression in an unevaluated operand" allowed in C++20? – Scrapple

Yes – and it’s a big deal. It enables some constructs not previously possible at all, with no amount of template metaprogramming. Heck, it even makes them easy. – Jule

In using discr = std::integral_type<int, Prev::value+1>; do you mean using discr = std::integral_type<int, Prev::discr+1>;? Also? How does using A = new_type<base_>; using A2 = new_type<base_>; give two different types? – Boehmite

It wouldn't give two different types because the second one would fail to compile. It's a bit of a pita to implement but that's the idea. It requires riding on the edges of the standard. – Jule

Answer 2

You can almost get the syntax you want using

template <size_t>
constexpr auto make_new_type() { return [](){}; }

using A = decltype(make_new_type<__LINE__>());
using B = decltype(make_new_type<__LINE__>());
using C = decltype(make_new_type<__LINE__>());

This works since every lambda expression results in a unique type. So for each unique value in <> you get a different function which returns a different closure.

If you introduce a macro you can get rid of having to type __LINE__ like

template <size_t>
constexpr auto new_type() { return [](){}; }

#define make_new_type new_type<__LINE__>()

using A = decltype(make_new_type);
using B = decltype(make_new_type);
using C = decltype(make_new_type);

Boehmite

You rely only on unicity of __LINE__ (so care with multiple TU, or several types on same line), so template <size_t> struct unique_tag {}; would be enough -> #define make_new_type unique_tag<__LINE__>. and using A = make_new_type; – Cleodal

@Cleodal Good point. Mind if I add that to the answer as an alternative? – Boehmite

Why not simply using A = [](){};? – Hilversum

@MooingDuck I don't believe that syntax is legal. using ... = expects a type and [](){} is a lambda value, not a type. – Vaughnvaught

using A = decltype([](){}); then. – Hilversum

@MooingDuck: "error: lambda-expression in unevaluated context" before C++20 though. – Cleodal

Answer 3

I know... they are distilled evil... but seems to me that this is a works for an old C-style macro

#include <type_traits>

#define  newType(x) \
struct type_##x {}; \
using x = type_##x;

newType(A)
newType(B)
newType(C)

int main ()
 {
   static_assert(!std::is_same<A, B>::value, "");
   static_assert(!std::is_same<B, C>::value, "");
   static_assert(!std::is_same<A, C>::value, "");
 }

Brahman

I don’t think this is any more “on the fly” than what OP already does. In particular, you still need to pass different identifiers to the macro. – Passant

@KonradRudolph - I don't know... the OP uses the identifier on the left of the = operator so I don't think is really different. But I have to admit that the lambda-based solution from NathanOliver is much better and really elegant. – Brahman