Meta programming: Declare a new struct on the fly
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?
c++ templates metaprogramming stateful compile-time-constant
add a comment |
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?
c++ templates metaprogramming stateful compile-time-constant
7
Why would someone want to do this ? what is a typical use case?
– Samer Tufail
Mar 25 at 16:29
3
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.
– Kuba Ober
Mar 25 at 16:37
1
Related: unconstexpr. (no longer works as of GCC 8, and the code there is probably ill-formed NDR)
– HolyBlackCat
Mar 25 at 21:14
"On the fly" in this question does not mean at runtime.
– atomsymbol
2 days ago
add a comment |
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?
c++ templates metaprogramming stateful compile-time-constant
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?
c++ templates metaprogramming stateful compile-time-constant
c++ templates metaprogramming stateful compile-time-constant
asked Mar 25 at 16:01
kaykay
18.6k970118
18.6k970118
7
Why would someone want to do this ? what is a typical use case?
– Samer Tufail
Mar 25 at 16:29
3
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.
– Kuba Ober
Mar 25 at 16:37
1
Related: unconstexpr. (no longer works as of GCC 8, and the code there is probably ill-formed NDR)
– HolyBlackCat
Mar 25 at 21:14
"On the fly" in this question does not mean at runtime.
– atomsymbol
2 days ago
add a comment |
7
Why would someone want to do this ? what is a typical use case?
– Samer Tufail
Mar 25 at 16:29
3
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.
– Kuba Ober
Mar 25 at 16:37
1
Related: unconstexpr. (no longer works as of GCC 8, and the code there is probably ill-formed NDR)
– HolyBlackCat
Mar 25 at 21:14
"On the fly" in this question does not mean at runtime.
– atomsymbol
2 days ago
7
7
Why would someone want to do this ? what is a typical use case?
– Samer Tufail
Mar 25 at 16:29
Why would someone want to do this ? what is a typical use case?
– Samer Tufail
Mar 25 at 16:29
3
3
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.
– Kuba Ober
Mar 25 at 16:37
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.
– Kuba Ober
Mar 25 at 16:37
1
1
Related: unconstexpr. (no longer works as of GCC 8, and the code there is probably ill-formed NDR)
– HolyBlackCat
Mar 25 at 21:14
Related: unconstexpr. (no longer works as of GCC 8, and the code there is probably ill-formed NDR)
– HolyBlackCat
Mar 25 at 21:14
"On the fly" in this question does not mean at runtime.
– atomsymbol
2 days ago
"On the fly" in this question does not mean at runtime.
– atomsymbol
2 days ago
add a comment |
3 Answers
3
active
oldest
votes
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);
7
You rely only on unicity of__LINE__
(so care with multiple TU, or several types on same line), sotemplate <size_t> struct unique_tag {};
would be enough ->#define make_new_type unique_tag<__LINE__>
. andusing A = make_new_type;
– Jarod42
Mar 25 at 17:36
@Jarod42 Good point. Mind if I add that to the answer as an alternative?
– NathanOliver
Mar 25 at 17:52
Add it to the answer if you want..
– Jarod42
Mar 25 at 19:07
1
using A = decltype((){});
then.
– Mooing Duck
Mar 26 at 0:33
1
@MooingDuck: "error: lambda-expression in unevaluated context" before C++20 though.
– Jarod42
2 days ago
|
show 2 more comments
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.
Is "lambda expression in an unevaluated operand" allowed in C++20?
– kay
Mar 25 at 17:00
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.
– Kuba Ober
Mar 25 at 17:15
Inusing discr = std::integral_type<int, Prev::value+1>;
do you meanusing discr = std::integral_type<int, Prev::discr+1>;
? Also? How doesusing A = new_type<base_>; using A2 = new_type<base_>;
give two different types?
– NathanOliver
Mar 25 at 17:50
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.
– Kuba Ober
Mar 25 at 19:59
add a comment |
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, "");
}
2
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.
– Konrad Rudolph
Mar 25 at 16:15
@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.
– max66
Mar 25 at 16:19
add a comment |
Your Answer
StackExchange.ifUsing("editor", function () {
StackExchange.using("externalEditor", function () {
StackExchange.using("snippets", function () {
StackExchange.snippets.init();
});
});
}, "code-snippets");
StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "1"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);
StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});
function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: true,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: 10,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});
}
});
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55341859%2fmeta-programming-declare-a-new-struct-on-the-fly%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
3 Answers
3
active
oldest
votes
3 Answers
3
active
oldest
votes
active
oldest
votes
active
oldest
votes
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);
7
You rely only on unicity of__LINE__
(so care with multiple TU, or several types on same line), sotemplate <size_t> struct unique_tag {};
would be enough ->#define make_new_type unique_tag<__LINE__>
. andusing A = make_new_type;
– Jarod42
Mar 25 at 17:36
@Jarod42 Good point. Mind if I add that to the answer as an alternative?
– NathanOliver
Mar 25 at 17:52
Add it to the answer if you want..
– Jarod42
Mar 25 at 19:07
1
using A = decltype((){});
then.
– Mooing Duck
Mar 26 at 0:33
1
@MooingDuck: "error: lambda-expression in unevaluated context" before C++20 though.
– Jarod42
2 days ago
|
show 2 more comments
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);
7
You rely only on unicity of__LINE__
(so care with multiple TU, or several types on same line), sotemplate <size_t> struct unique_tag {};
would be enough ->#define make_new_type unique_tag<__LINE__>
. andusing A = make_new_type;
– Jarod42
Mar 25 at 17:36
@Jarod42 Good point. Mind if I add that to the answer as an alternative?
– NathanOliver
Mar 25 at 17:52
Add it to the answer if you want..
– Jarod42
Mar 25 at 19:07
1
using A = decltype((){});
then.
– Mooing Duck
Mar 26 at 0:33
1
@MooingDuck: "error: lambda-expression in unevaluated context" before C++20 though.
– Jarod42
2 days ago
|
show 2 more comments
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);
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);
edited Mar 25 at 16:20
answered Mar 25 at 16:15
NathanOliverNathanOliver
97.3k16138214
97.3k16138214
7
You rely only on unicity of__LINE__
(so care with multiple TU, or several types on same line), sotemplate <size_t> struct unique_tag {};
would be enough ->#define make_new_type unique_tag<__LINE__>
. andusing A = make_new_type;
– Jarod42
Mar 25 at 17:36
@Jarod42 Good point. Mind if I add that to the answer as an alternative?
– NathanOliver
Mar 25 at 17:52
Add it to the answer if you want..
– Jarod42
Mar 25 at 19:07
1
using A = decltype((){});
then.
– Mooing Duck
Mar 26 at 0:33
1
@MooingDuck: "error: lambda-expression in unevaluated context" before C++20 though.
– Jarod42
2 days ago
|
show 2 more comments
7
You rely only on unicity of__LINE__
(so care with multiple TU, or several types on same line), sotemplate <size_t> struct unique_tag {};
would be enough ->#define make_new_type unique_tag<__LINE__>
. andusing A = make_new_type;
– Jarod42
Mar 25 at 17:36
@Jarod42 Good point. Mind if I add that to the answer as an alternative?
– NathanOliver
Mar 25 at 17:52
Add it to the answer if you want..
– Jarod42
Mar 25 at 19:07
1
using A = decltype((){});
then.
– Mooing Duck
Mar 26 at 0:33
1
@MooingDuck: "error: lambda-expression in unevaluated context" before C++20 though.
– Jarod42
2 days ago
7
7
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;
– Jarod42
Mar 25 at 17:36
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;
– Jarod42
Mar 25 at 17:36
@Jarod42 Good point. Mind if I add that to the answer as an alternative?
– NathanOliver
Mar 25 at 17:52
@Jarod42 Good point. Mind if I add that to the answer as an alternative?
– NathanOliver
Mar 25 at 17:52
Add it to the answer if you want..
– Jarod42
Mar 25 at 19:07
Add it to the answer if you want..
– Jarod42
Mar 25 at 19:07
1
1
using A = decltype((){});
then.– Mooing Duck
Mar 26 at 0:33
using A = decltype((){});
then.– Mooing Duck
Mar 26 at 0:33
1
1
@MooingDuck: "error: lambda-expression in unevaluated context" before C++20 though.
– Jarod42
2 days ago
@MooingDuck: "error: lambda-expression in unevaluated context" before C++20 though.
– Jarod42
2 days ago
|
show 2 more comments
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.
Is "lambda expression in an unevaluated operand" allowed in C++20?
– kay
Mar 25 at 17:00
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.
– Kuba Ober
Mar 25 at 17:15
Inusing discr = std::integral_type<int, Prev::value+1>;
do you meanusing discr = std::integral_type<int, Prev::discr+1>;
? Also? How doesusing A = new_type<base_>; using A2 = new_type<base_>;
give two different types?
– NathanOliver
Mar 25 at 17:50
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.
– Kuba Ober
Mar 25 at 19:59
add a comment |
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.
Is "lambda expression in an unevaluated operand" allowed in C++20?
– kay
Mar 25 at 17:00
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.
– Kuba Ober
Mar 25 at 17:15
Inusing discr = std::integral_type<int, Prev::value+1>;
do you meanusing discr = std::integral_type<int, Prev::discr+1>;
? Also? How doesusing A = new_type<base_>; using A2 = new_type<base_>;
give two different types?
– NathanOliver
Mar 25 at 17:50
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.
– Kuba Ober
Mar 25 at 19:59
add a comment |
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.
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.
edited Mar 25 at 22:35
answered Mar 25 at 16:58
Kuba OberKuba Ober
71k1083197
71k1083197
Is "lambda expression in an unevaluated operand" allowed in C++20?
– kay
Mar 25 at 17:00
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.
– Kuba Ober
Mar 25 at 17:15
Inusing discr = std::integral_type<int, Prev::value+1>;
do you meanusing discr = std::integral_type<int, Prev::discr+1>;
? Also? How doesusing A = new_type<base_>; using A2 = new_type<base_>;
give two different types?
– NathanOliver
Mar 25 at 17:50
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.
– Kuba Ober
Mar 25 at 19:59
add a comment |
Is "lambda expression in an unevaluated operand" allowed in C++20?
– kay
Mar 25 at 17:00
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.
– Kuba Ober
Mar 25 at 17:15
Inusing discr = std::integral_type<int, Prev::value+1>;
do you meanusing discr = std::integral_type<int, Prev::discr+1>;
? Also? How doesusing A = new_type<base_>; using A2 = new_type<base_>;
give two different types?
– NathanOliver
Mar 25 at 17:50
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.
– Kuba Ober
Mar 25 at 19:59
Is "lambda expression in an unevaluated operand" allowed in C++20?
– kay
Mar 25 at 17:00
Is "lambda expression in an unevaluated operand" allowed in C++20?
– kay
Mar 25 at 17:00
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.
– Kuba Ober
Mar 25 at 17:15
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.
– Kuba Ober
Mar 25 at 17:15
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?– NathanOliver
Mar 25 at 17:50
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?– NathanOliver
Mar 25 at 17:50
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.
– Kuba Ober
Mar 25 at 19:59
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.
– Kuba Ober
Mar 25 at 19:59
add a comment |
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, "");
}
2
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.
– Konrad Rudolph
Mar 25 at 16:15
@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.
– max66
Mar 25 at 16:19
add a comment |
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, "");
}
2
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.
– Konrad Rudolph
Mar 25 at 16:15
@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.
– max66
Mar 25 at 16:19
add a comment |
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, "");
}
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, "");
}
answered Mar 25 at 16:11
max66max66
38.6k74473
38.6k74473
2
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.
– Konrad Rudolph
Mar 25 at 16:15
@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.
– max66
Mar 25 at 16:19
add a comment |
2
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.
– Konrad Rudolph
Mar 25 at 16:15
@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.
– max66
Mar 25 at 16:19
2
2
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.
– Konrad Rudolph
Mar 25 at 16:15
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.
– Konrad Rudolph
Mar 25 at 16:15
@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.– max66
Mar 25 at 16:19
@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.– max66
Mar 25 at 16:19
add a comment |
Thanks for contributing an answer to Stack Overflow!
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55341859%2fmeta-programming-declare-a-new-struct-on-the-fly%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
7
Why would someone want to do this ? what is a typical use case?
– Samer Tufail
Mar 25 at 16:29
3
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.
– Kuba Ober
Mar 25 at 16:37
1
Related: unconstexpr. (no longer works as of GCC 8, and the code there is probably ill-formed NDR)
– HolyBlackCat
Mar 25 at 21:14
"On the fly" in this question does not mean at runtime.
– atomsymbol
2 days ago