Bdtyk

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?

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);

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.

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, "");

 }