C++ check if statement can be evaluated constexpr
Is there a method to decide whether something can be constexpr evaluated, and use the result as a constexpr boolean? My simplified use case is as follows:
template <typename base>
class derived
{
template<size_t size>
void do_stuff() { (...) }
void do_stuff(size_t size) { (...) }
public:
void execute()
{
if constexpr(is_constexpr(base::get_data())
{
do_stuff<base::get_data()>();
}
else
{
do_stuff(base::get_data());
}
}
}
My target is C++2a.
I found the following reddit thread, but I'm not a big fan of the macros. https://www.reddit.com/r/cpp/comments/7c208c/is_constexpr_a_macro_that_check_if_an_expression/
c++ template-meta-programming constexpr c++20 if-constexpr
|
show 3 more comments
Is there a method to decide whether something can be constexpr evaluated, and use the result as a constexpr boolean? My simplified use case is as follows:
template <typename base>
class derived
{
template<size_t size>
void do_stuff() { (...) }
void do_stuff(size_t size) { (...) }
public:
void execute()
{
if constexpr(is_constexpr(base::get_data())
{
do_stuff<base::get_data()>();
}
else
{
do_stuff(base::get_data());
}
}
}
My target is C++2a.
I found the following reddit thread, but I'm not a big fan of the macros. https://www.reddit.com/r/cpp/comments/7c208c/is_constexpr_a_macro_that_check_if_an_expression/
c++ template-meta-programming constexpr c++20 if-constexpr
1
Hmm, the body of aif constexpr
will only be evaluated if the expression in theif constexpr
is true at compile time. Is that what you are looking for?
– Jesper Juhl
2 days ago
1
But what if the test in the if constexpr([test]) is not evaluatable at compile time?
– Aart Stuurman
2 days ago
5
Maybe you can do something withstd::is_constant_evaluated
?
– 0x5453
2 days ago
en.cppreference.com/w/cpp/language/if
– Jesper Juhl
2 days ago
2
@AartStuurman: What isdo_stuff
that it can run at compile time or runtime, but itself should not beconstexpr
? Wouldn't it make more sense to just make it aconstexpr
function, and pass it the value ofget_data
as a parameter?
– Nicol Bolas
2 days ago
|
show 3 more comments
Is there a method to decide whether something can be constexpr evaluated, and use the result as a constexpr boolean? My simplified use case is as follows:
template <typename base>
class derived
{
template<size_t size>
void do_stuff() { (...) }
void do_stuff(size_t size) { (...) }
public:
void execute()
{
if constexpr(is_constexpr(base::get_data())
{
do_stuff<base::get_data()>();
}
else
{
do_stuff(base::get_data());
}
}
}
My target is C++2a.
I found the following reddit thread, but I'm not a big fan of the macros. https://www.reddit.com/r/cpp/comments/7c208c/is_constexpr_a_macro_that_check_if_an_expression/
c++ template-meta-programming constexpr c++20 if-constexpr
Is there a method to decide whether something can be constexpr evaluated, and use the result as a constexpr boolean? My simplified use case is as follows:
template <typename base>
class derived
{
template<size_t size>
void do_stuff() { (...) }
void do_stuff(size_t size) { (...) }
public:
void execute()
{
if constexpr(is_constexpr(base::get_data())
{
do_stuff<base::get_data()>();
}
else
{
do_stuff(base::get_data());
}
}
}
My target is C++2a.
I found the following reddit thread, but I'm not a big fan of the macros. https://www.reddit.com/r/cpp/comments/7c208c/is_constexpr_a_macro_that_check_if_an_expression/
c++ template-meta-programming constexpr c++20 if-constexpr
c++ template-meta-programming constexpr c++20 if-constexpr
edited yesterday
max66
38.2k74471
38.2k74471
asked 2 days ago
Aart StuurmanAart Stuurman
1,001827
1,001827
1
Hmm, the body of aif constexpr
will only be evaluated if the expression in theif constexpr
is true at compile time. Is that what you are looking for?
– Jesper Juhl
2 days ago
1
But what if the test in the if constexpr([test]) is not evaluatable at compile time?
– Aart Stuurman
2 days ago
5
Maybe you can do something withstd::is_constant_evaluated
?
– 0x5453
2 days ago
en.cppreference.com/w/cpp/language/if
– Jesper Juhl
2 days ago
2
@AartStuurman: What isdo_stuff
that it can run at compile time or runtime, but itself should not beconstexpr
? Wouldn't it make more sense to just make it aconstexpr
function, and pass it the value ofget_data
as a parameter?
– Nicol Bolas
2 days ago
|
show 3 more comments
1
Hmm, the body of aif constexpr
will only be evaluated if the expression in theif constexpr
is true at compile time. Is that what you are looking for?
– Jesper Juhl
2 days ago
1
But what if the test in the if constexpr([test]) is not evaluatable at compile time?
– Aart Stuurman
2 days ago
5
Maybe you can do something withstd::is_constant_evaluated
?
– 0x5453
2 days ago
en.cppreference.com/w/cpp/language/if
– Jesper Juhl
2 days ago
2
@AartStuurman: What isdo_stuff
that it can run at compile time or runtime, but itself should not beconstexpr
? Wouldn't it make more sense to just make it aconstexpr
function, and pass it the value ofget_data
as a parameter?
– Nicol Bolas
2 days ago
1
1
Hmm, the body of a
if constexpr
will only be evaluated if the expression in the if constexpr
is true at compile time. Is that what you are looking for?– Jesper Juhl
2 days ago
Hmm, the body of a
if constexpr
will only be evaluated if the expression in the if constexpr
is true at compile time. Is that what you are looking for?– Jesper Juhl
2 days ago
1
1
But what if the test in the if constexpr([test]) is not evaluatable at compile time?
– Aart Stuurman
2 days ago
But what if the test in the if constexpr([test]) is not evaluatable at compile time?
– Aart Stuurman
2 days ago
5
5
Maybe you can do something with
std::is_constant_evaluated
?– 0x5453
2 days ago
Maybe you can do something with
std::is_constant_evaluated
?– 0x5453
2 days ago
en.cppreference.com/w/cpp/language/if
– Jesper Juhl
2 days ago
en.cppreference.com/w/cpp/language/if
– Jesper Juhl
2 days ago
2
2
@AartStuurman: What is
do_stuff
that it can run at compile time or runtime, but itself should not be constexpr
? Wouldn't it make more sense to just make it a constexpr
function, and pass it the value of get_data
as a parameter?– Nicol Bolas
2 days ago
@AartStuurman: What is
do_stuff
that it can run at compile time or runtime, but itself should not be constexpr
? Wouldn't it make more sense to just make it a constexpr
function, and pass it the value of get_data
as a parameter?– Nicol Bolas
2 days ago
|
show 3 more comments
3 Answers
3
active
oldest
votes
Here's another solution, which is more generic (applicable to any expression, without defining a separate template each time).
This solution leverages that (1) lambda expressions can be constexpr as of C++17 (2) the type of a captureless lambda is default constructible as of C++20.
The idea is, the overload that returns true
is selected when and only when Lambda{}()
can appear within a template argument, which effectively requires the lambda invocation to be a constant expression.
template<class Lambda, int=(Lambda{}(), 0)>
constexpr bool is_constexpr(Lambda) { return true; }
constexpr bool is_constexpr(...) { return false; }
template <typename base>
class derived
{
// ...
void execute()
{
if constexpr(is_constexpr({ base::get_data(); }))
do_stuff<base::get_data()>();
else
do_stuff(base::get_data());
}
}
Intriguing solution... this way you get the same result of my custom type traits but more synthetically and, above all, the exact expression verified (base::get_data()
) is embedded in the argument and not hard-coded as in my solution. Very nice. I have to remember it.
– max66
yesterday
I am accepting this, because it is an answer to the a generic case of the question. max66 answer is also very useful(in non-c++2a cases), but requires repetition for every usage :)
– Aart Stuurman
yesterday
add a comment |
Not exactly what you asked (I've developer a custom type trait specific for a get_value()
static method... maybe it's possible to generalize it but, at the moment, I don't know how) but I suppose you can use SFINAE and make something as follows
#include <iostream>
#include <type_traits>
template <typename T>
constexpr auto icee_helper (int)
-> decltype( std::integral_constant<decltype(T::get_data()), T::get_data()>{},
std::true_type{} );
template <typename>
constexpr auto icee_helper (long)
-> std::false_type;
template <typename T>
using isConstExprEval = decltype(icee_helper<T>(0));
template <typename base>
struct derived
{
template <std::size_t I>
void do_stuff()
{ std::cout << "constexpr case (" << I << ')' << std::endl; }
void do_stuff (std::size_t i)
{ std::cout << "not constexpr case (" << i << ')' << std::endl; }
void execute ()
{
if constexpr ( isConstExprEval<base>::value )
do_stuff<base::get_data()>();
else
do_stuff(base::get_data());
}
};
struct foo
{ static constexpr std::size_t get_data () { return 1u; } };
struct bar
{ static std::size_t get_data () { return 2u; } };
int main ()
{
derived<foo>{}.execute(); // print "constexpr case (1)"
derived<bar>{}.execute(); // print "not constexpr case (2)"
}
2
This is madness, this use of the comma operator, the long/int overload... Have an upvote. :/
– matovitch
2 days ago
@matovitch - never underestimate the power of the comma operator }:‑)
– max66
2 days ago
Will this work on platforms wheresizeof(long)
is equal tosizeof(int)
?
– Gregory Nisbet
yesterday
2
@GregoryNisbet - Yes. Because, for the language so for the compiler, they remain different types.
– max66
yesterday
add a comment |
template<auto> struct require_constant;
template<class T>
concept has_constexpr_data = requires { typename require_constant<T::get_data()>; };
This is basically what's used by std::ranges::split_view
.
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%2f55288555%2fc-check-if-statement-can-be-evaluated-constexpr%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
Here's another solution, which is more generic (applicable to any expression, without defining a separate template each time).
This solution leverages that (1) lambda expressions can be constexpr as of C++17 (2) the type of a captureless lambda is default constructible as of C++20.
The idea is, the overload that returns true
is selected when and only when Lambda{}()
can appear within a template argument, which effectively requires the lambda invocation to be a constant expression.
template<class Lambda, int=(Lambda{}(), 0)>
constexpr bool is_constexpr(Lambda) { return true; }
constexpr bool is_constexpr(...) { return false; }
template <typename base>
class derived
{
// ...
void execute()
{
if constexpr(is_constexpr({ base::get_data(); }))
do_stuff<base::get_data()>();
else
do_stuff(base::get_data());
}
}
Intriguing solution... this way you get the same result of my custom type traits but more synthetically and, above all, the exact expression verified (base::get_data()
) is embedded in the argument and not hard-coded as in my solution. Very nice. I have to remember it.
– max66
yesterday
I am accepting this, because it is an answer to the a generic case of the question. max66 answer is also very useful(in non-c++2a cases), but requires repetition for every usage :)
– Aart Stuurman
yesterday
add a comment |
Here's another solution, which is more generic (applicable to any expression, without defining a separate template each time).
This solution leverages that (1) lambda expressions can be constexpr as of C++17 (2) the type of a captureless lambda is default constructible as of C++20.
The idea is, the overload that returns true
is selected when and only when Lambda{}()
can appear within a template argument, which effectively requires the lambda invocation to be a constant expression.
template<class Lambda, int=(Lambda{}(), 0)>
constexpr bool is_constexpr(Lambda) { return true; }
constexpr bool is_constexpr(...) { return false; }
template <typename base>
class derived
{
// ...
void execute()
{
if constexpr(is_constexpr({ base::get_data(); }))
do_stuff<base::get_data()>();
else
do_stuff(base::get_data());
}
}
Intriguing solution... this way you get the same result of my custom type traits but more synthetically and, above all, the exact expression verified (base::get_data()
) is embedded in the argument and not hard-coded as in my solution. Very nice. I have to remember it.
– max66
yesterday
I am accepting this, because it is an answer to the a generic case of the question. max66 answer is also very useful(in non-c++2a cases), but requires repetition for every usage :)
– Aart Stuurman
yesterday
add a comment |
Here's another solution, which is more generic (applicable to any expression, without defining a separate template each time).
This solution leverages that (1) lambda expressions can be constexpr as of C++17 (2) the type of a captureless lambda is default constructible as of C++20.
The idea is, the overload that returns true
is selected when and only when Lambda{}()
can appear within a template argument, which effectively requires the lambda invocation to be a constant expression.
template<class Lambda, int=(Lambda{}(), 0)>
constexpr bool is_constexpr(Lambda) { return true; }
constexpr bool is_constexpr(...) { return false; }
template <typename base>
class derived
{
// ...
void execute()
{
if constexpr(is_constexpr({ base::get_data(); }))
do_stuff<base::get_data()>();
else
do_stuff(base::get_data());
}
}
Here's another solution, which is more generic (applicable to any expression, without defining a separate template each time).
This solution leverages that (1) lambda expressions can be constexpr as of C++17 (2) the type of a captureless lambda is default constructible as of C++20.
The idea is, the overload that returns true
is selected when and only when Lambda{}()
can appear within a template argument, which effectively requires the lambda invocation to be a constant expression.
template<class Lambda, int=(Lambda{}(), 0)>
constexpr bool is_constexpr(Lambda) { return true; }
constexpr bool is_constexpr(...) { return false; }
template <typename base>
class derived
{
// ...
void execute()
{
if constexpr(is_constexpr({ base::get_data(); }))
do_stuff<base::get_data()>();
else
do_stuff(base::get_data());
}
}
edited yesterday
answered yesterday
cpplearnercpplearner
5,49722342
5,49722342
Intriguing solution... this way you get the same result of my custom type traits but more synthetically and, above all, the exact expression verified (base::get_data()
) is embedded in the argument and not hard-coded as in my solution. Very nice. I have to remember it.
– max66
yesterday
I am accepting this, because it is an answer to the a generic case of the question. max66 answer is also very useful(in non-c++2a cases), but requires repetition for every usage :)
– Aart Stuurman
yesterday
add a comment |
Intriguing solution... this way you get the same result of my custom type traits but more synthetically and, above all, the exact expression verified (base::get_data()
) is embedded in the argument and not hard-coded as in my solution. Very nice. I have to remember it.
– max66
yesterday
I am accepting this, because it is an answer to the a generic case of the question. max66 answer is also very useful(in non-c++2a cases), but requires repetition for every usage :)
– Aart Stuurman
yesterday
Intriguing solution... this way you get the same result of my custom type traits but more synthetically and, above all, the exact expression verified (
base::get_data()
) is embedded in the argument and not hard-coded as in my solution. Very nice. I have to remember it.– max66
yesterday
Intriguing solution... this way you get the same result of my custom type traits but more synthetically and, above all, the exact expression verified (
base::get_data()
) is embedded in the argument and not hard-coded as in my solution. Very nice. I have to remember it.– max66
yesterday
I am accepting this, because it is an answer to the a generic case of the question. max66 answer is also very useful(in non-c++2a cases), but requires repetition for every usage :)
– Aart Stuurman
yesterday
I am accepting this, because it is an answer to the a generic case of the question. max66 answer is also very useful(in non-c++2a cases), but requires repetition for every usage :)
– Aart Stuurman
yesterday
add a comment |
Not exactly what you asked (I've developer a custom type trait specific for a get_value()
static method... maybe it's possible to generalize it but, at the moment, I don't know how) but I suppose you can use SFINAE and make something as follows
#include <iostream>
#include <type_traits>
template <typename T>
constexpr auto icee_helper (int)
-> decltype( std::integral_constant<decltype(T::get_data()), T::get_data()>{},
std::true_type{} );
template <typename>
constexpr auto icee_helper (long)
-> std::false_type;
template <typename T>
using isConstExprEval = decltype(icee_helper<T>(0));
template <typename base>
struct derived
{
template <std::size_t I>
void do_stuff()
{ std::cout << "constexpr case (" << I << ')' << std::endl; }
void do_stuff (std::size_t i)
{ std::cout << "not constexpr case (" << i << ')' << std::endl; }
void execute ()
{
if constexpr ( isConstExprEval<base>::value )
do_stuff<base::get_data()>();
else
do_stuff(base::get_data());
}
};
struct foo
{ static constexpr std::size_t get_data () { return 1u; } };
struct bar
{ static std::size_t get_data () { return 2u; } };
int main ()
{
derived<foo>{}.execute(); // print "constexpr case (1)"
derived<bar>{}.execute(); // print "not constexpr case (2)"
}
2
This is madness, this use of the comma operator, the long/int overload... Have an upvote. :/
– matovitch
2 days ago
@matovitch - never underestimate the power of the comma operator }:‑)
– max66
2 days ago
Will this work on platforms wheresizeof(long)
is equal tosizeof(int)
?
– Gregory Nisbet
yesterday
2
@GregoryNisbet - Yes. Because, for the language so for the compiler, they remain different types.
– max66
yesterday
add a comment |
Not exactly what you asked (I've developer a custom type trait specific for a get_value()
static method... maybe it's possible to generalize it but, at the moment, I don't know how) but I suppose you can use SFINAE and make something as follows
#include <iostream>
#include <type_traits>
template <typename T>
constexpr auto icee_helper (int)
-> decltype( std::integral_constant<decltype(T::get_data()), T::get_data()>{},
std::true_type{} );
template <typename>
constexpr auto icee_helper (long)
-> std::false_type;
template <typename T>
using isConstExprEval = decltype(icee_helper<T>(0));
template <typename base>
struct derived
{
template <std::size_t I>
void do_stuff()
{ std::cout << "constexpr case (" << I << ')' << std::endl; }
void do_stuff (std::size_t i)
{ std::cout << "not constexpr case (" << i << ')' << std::endl; }
void execute ()
{
if constexpr ( isConstExprEval<base>::value )
do_stuff<base::get_data()>();
else
do_stuff(base::get_data());
}
};
struct foo
{ static constexpr std::size_t get_data () { return 1u; } };
struct bar
{ static std::size_t get_data () { return 2u; } };
int main ()
{
derived<foo>{}.execute(); // print "constexpr case (1)"
derived<bar>{}.execute(); // print "not constexpr case (2)"
}
2
This is madness, this use of the comma operator, the long/int overload... Have an upvote. :/
– matovitch
2 days ago
@matovitch - never underestimate the power of the comma operator }:‑)
– max66
2 days ago
Will this work on platforms wheresizeof(long)
is equal tosizeof(int)
?
– Gregory Nisbet
yesterday
2
@GregoryNisbet - Yes. Because, for the language so for the compiler, they remain different types.
– max66
yesterday
add a comment |
Not exactly what you asked (I've developer a custom type trait specific for a get_value()
static method... maybe it's possible to generalize it but, at the moment, I don't know how) but I suppose you can use SFINAE and make something as follows
#include <iostream>
#include <type_traits>
template <typename T>
constexpr auto icee_helper (int)
-> decltype( std::integral_constant<decltype(T::get_data()), T::get_data()>{},
std::true_type{} );
template <typename>
constexpr auto icee_helper (long)
-> std::false_type;
template <typename T>
using isConstExprEval = decltype(icee_helper<T>(0));
template <typename base>
struct derived
{
template <std::size_t I>
void do_stuff()
{ std::cout << "constexpr case (" << I << ')' << std::endl; }
void do_stuff (std::size_t i)
{ std::cout << "not constexpr case (" << i << ')' << std::endl; }
void execute ()
{
if constexpr ( isConstExprEval<base>::value )
do_stuff<base::get_data()>();
else
do_stuff(base::get_data());
}
};
struct foo
{ static constexpr std::size_t get_data () { return 1u; } };
struct bar
{ static std::size_t get_data () { return 2u; } };
int main ()
{
derived<foo>{}.execute(); // print "constexpr case (1)"
derived<bar>{}.execute(); // print "not constexpr case (2)"
}
Not exactly what you asked (I've developer a custom type trait specific for a get_value()
static method... maybe it's possible to generalize it but, at the moment, I don't know how) but I suppose you can use SFINAE and make something as follows
#include <iostream>
#include <type_traits>
template <typename T>
constexpr auto icee_helper (int)
-> decltype( std::integral_constant<decltype(T::get_data()), T::get_data()>{},
std::true_type{} );
template <typename>
constexpr auto icee_helper (long)
-> std::false_type;
template <typename T>
using isConstExprEval = decltype(icee_helper<T>(0));
template <typename base>
struct derived
{
template <std::size_t I>
void do_stuff()
{ std::cout << "constexpr case (" << I << ')' << std::endl; }
void do_stuff (std::size_t i)
{ std::cout << "not constexpr case (" << i << ')' << std::endl; }
void execute ()
{
if constexpr ( isConstExprEval<base>::value )
do_stuff<base::get_data()>();
else
do_stuff(base::get_data());
}
};
struct foo
{ static constexpr std::size_t get_data () { return 1u; } };
struct bar
{ static std::size_t get_data () { return 2u; } };
int main ()
{
derived<foo>{}.execute(); // print "constexpr case (1)"
derived<bar>{}.execute(); // print "not constexpr case (2)"
}
edited 2 days ago
answered 2 days ago
max66max66
38.2k74471
38.2k74471
2
This is madness, this use of the comma operator, the long/int overload... Have an upvote. :/
– matovitch
2 days ago
@matovitch - never underestimate the power of the comma operator }:‑)
– max66
2 days ago
Will this work on platforms wheresizeof(long)
is equal tosizeof(int)
?
– Gregory Nisbet
yesterday
2
@GregoryNisbet - Yes. Because, for the language so for the compiler, they remain different types.
– max66
yesterday
add a comment |
2
This is madness, this use of the comma operator, the long/int overload... Have an upvote. :/
– matovitch
2 days ago
@matovitch - never underestimate the power of the comma operator }:‑)
– max66
2 days ago
Will this work on platforms wheresizeof(long)
is equal tosizeof(int)
?
– Gregory Nisbet
yesterday
2
@GregoryNisbet - Yes. Because, for the language so for the compiler, they remain different types.
– max66
yesterday
2
2
This is madness, this use of the comma operator, the long/int overload... Have an upvote. :/
– matovitch
2 days ago
This is madness, this use of the comma operator, the long/int overload... Have an upvote. :/
– matovitch
2 days ago
@matovitch - never underestimate the power of the comma operator }:‑)
– max66
2 days ago
@matovitch - never underestimate the power of the comma operator }:‑)
– max66
2 days ago
Will this work on platforms where
sizeof(long)
is equal to sizeof(int)
?– Gregory Nisbet
yesterday
Will this work on platforms where
sizeof(long)
is equal to sizeof(int)
?– Gregory Nisbet
yesterday
2
2
@GregoryNisbet - Yes. Because, for the language so for the compiler, they remain different types.
– max66
yesterday
@GregoryNisbet - Yes. Because, for the language so for the compiler, they remain different types.
– max66
yesterday
add a comment |
template<auto> struct require_constant;
template<class T>
concept has_constexpr_data = requires { typename require_constant<T::get_data()>; };
This is basically what's used by std::ranges::split_view
.
add a comment |
template<auto> struct require_constant;
template<class T>
concept has_constexpr_data = requires { typename require_constant<T::get_data()>; };
This is basically what's used by std::ranges::split_view
.
add a comment |
template<auto> struct require_constant;
template<class T>
concept has_constexpr_data = requires { typename require_constant<T::get_data()>; };
This is basically what's used by std::ranges::split_view
.
template<auto> struct require_constant;
template<class T>
concept has_constexpr_data = requires { typename require_constant<T::get_data()>; };
This is basically what's used by std::ranges::split_view
.
answered 2 days ago
cpplearnercpplearner
5,49722342
5,49722342
add a comment |
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%2f55288555%2fc-check-if-statement-can-be-evaluated-constexpr%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
1
Hmm, the body of a
if constexpr
will only be evaluated if the expression in theif constexpr
is true at compile time. Is that what you are looking for?– Jesper Juhl
2 days ago
1
But what if the test in the if constexpr([test]) is not evaluatable at compile time?
– Aart Stuurman
2 days ago
5
Maybe you can do something with
std::is_constant_evaluated
?– 0x5453
2 days ago
en.cppreference.com/w/cpp/language/if
– Jesper Juhl
2 days ago
2
@AartStuurman: What is
do_stuff
that it can run at compile time or runtime, but itself should not beconstexpr
? Wouldn't it make more sense to just make it aconstexpr
function, and pass it the value ofget_data
as a parameter?– Nicol Bolas
2 days ago