C++ check if statement can be evaluated constexprWhat are the differences between a pointer variable and a reference variable in C++?Is it possible to write a template to check for a function's existence?How can I profile C++ code running on Linux?The Definitive C++ Book Guide and ListWhy can templates only be implemented in the header file?What is the effect of extern “C” in C++?What is the “-->” operator in C++?Easiest way to convert int to string in C++Why is reading lines from stdin much slower in C++ than Python?Difference between `constexpr` and `const`

Is it allowed to activate the ability of multiple planeswalkers in a single turn?

"before" and "want" for the same systemd service?

Shouldn’t conservatives embrace universal basic income?

Did the UK lift the requirement for registering SIM cards?

Why does AES have exactly 10 rounds for a 128-bit key, 12 for 192 bits and 14 for a 256-bit key size?

How to preserve electronics (computers, iPads and phones) for hundreds of years

How much theory knowledge is actually used while playing?

Does Doodling or Improvising on the Piano Have Any Benefits?

Is there a RAID 0 Equivalent for RAM?

Will number of steps recorded on FitBit/any fitness tracker add up distance in PokemonGo?

Why Shazam when there is already Superman?

Taxes on Dividends in a Roth IRA

Can I turn my anal-retentiveness into a career?

Why is so much work done on numerical verification of the Riemann Hypothesis?

Does an advisor owe his/her student anything? Will an advisor keep a PhD student only out of pity?

Does "he squandered his car on drink" sound natural?

What does "Scientists rise up against statistical significance" mean? (Comment in Nature)

PTIJ: Why is Haman obsessed with Bose?

A Trivial Diagnosis

US tourist/student visa

Why is it that I can sometimes guess the next note?

Are Captain Marvel's powers affected by Thanos breaking the Tesseract and claiming the stone?

Has any country ever had 2 former presidents in jail simultaneously?

Can you use Vicious Mockery to win an argument or gain favours?



C++ check if statement can be evaluated constexpr


What are the differences between a pointer variable and a reference variable in C++?Is it possible to write a template to check for a function's existence?How can I profile C++ code running on Linux?The Definitive C++ Book Guide and ListWhy can templates only be implemented in the header file?What is the effect of extern “C” in C++?What is the “-->” operator in C++?Easiest way to convert int to string in C++Why is reading lines from stdin much slower in C++ than Python?Difference between `constexpr` and `const`













7















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/










share|improve this question
























  • 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
    4 hours ago











  • But what if the test in the if constexpr([test]) is not evaluatable at compile time?

    – Aart Stuurman
    4 hours ago






  • 3





    Maybe you can do something with std::is_constant_evaluated?

    – 0x5453
    4 hours ago











  • en.cppreference.com/w/cpp/language/if

    – Jesper Juhl
    4 hours ago






  • 1





    @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
    3 hours ago















7















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/










share|improve this question
























  • 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
    4 hours ago











  • But what if the test in the if constexpr([test]) is not evaluatable at compile time?

    – Aart Stuurman
    4 hours ago






  • 3





    Maybe you can do something with std::is_constant_evaluated?

    – 0x5453
    4 hours ago











  • en.cppreference.com/w/cpp/language/if

    – Jesper Juhl
    4 hours ago






  • 1





    @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
    3 hours ago













7












7








7


3






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/










share|improve this question
















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++ templates template-meta-programming constexpr c++20






share|improve this question















share|improve this question













share|improve this question




share|improve this question








edited 3 hours ago









max66

38.1k74471




38.1k74471










asked 4 hours ago









Aart StuurmanAart Stuurman

915726




915726












  • 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
    4 hours ago











  • But what if the test in the if constexpr([test]) is not evaluatable at compile time?

    – Aart Stuurman
    4 hours ago






  • 3





    Maybe you can do something with std::is_constant_evaluated?

    – 0x5453
    4 hours ago











  • en.cppreference.com/w/cpp/language/if

    – Jesper Juhl
    4 hours ago






  • 1





    @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
    3 hours 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
    4 hours ago











  • But what if the test in the if constexpr([test]) is not evaluatable at compile time?

    – Aart Stuurman
    4 hours ago






  • 3





    Maybe you can do something with std::is_constant_evaluated?

    – 0x5453
    4 hours ago











  • en.cppreference.com/w/cpp/language/if

    – Jesper Juhl
    4 hours ago






  • 1





    @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
    3 hours 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
4 hours 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
4 hours ago













But what if the test in the if constexpr([test]) is not evaluatable at compile time?

– Aart Stuurman
4 hours ago





But what if the test in the if constexpr([test]) is not evaluatable at compile time?

– Aart Stuurman
4 hours ago




3




3





Maybe you can do something with std::is_constant_evaluated?

– 0x5453
4 hours ago





Maybe you can do something with std::is_constant_evaluated?

– 0x5453
4 hours ago













en.cppreference.com/w/cpp/language/if

– Jesper Juhl
4 hours ago





en.cppreference.com/w/cpp/language/if

– Jesper Juhl
4 hours ago




1




1





@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
3 hours 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
3 hours ago












3 Answers
3






active

oldest

votes


















4














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






share|improve this answer

























  • This is madness, this use of the comma operator, the long/int overload... Have an upvote. :/

    – matovitch
    3 hours ago











  • @matovitch - never underestimate the power of the comma operator }:‑)

    – max66
    3 hours ago


















3














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







share|improve this answer

























  • 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
    13 mins ago



















2














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.






share|improve this answer






















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



    );













    draft saved

    draft discarded


















    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









    4














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






    share|improve this answer

























    • This is madness, this use of the comma operator, the long/int overload... Have an upvote. :/

      – matovitch
      3 hours ago











    • @matovitch - never underestimate the power of the comma operator }:‑)

      – max66
      3 hours ago















    4














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






    share|improve this answer

























    • This is madness, this use of the comma operator, the long/int overload... Have an upvote. :/

      – matovitch
      3 hours ago











    • @matovitch - never underestimate the power of the comma operator }:‑)

      – max66
      3 hours ago













    4












    4








    4







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






    share|improve this answer















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







    share|improve this answer














    share|improve this answer



    share|improve this answer








    edited 3 hours ago

























    answered 3 hours ago









    max66max66

    38.1k74471




    38.1k74471












    • This is madness, this use of the comma operator, the long/int overload... Have an upvote. :/

      – matovitch
      3 hours ago











    • @matovitch - never underestimate the power of the comma operator }:‑)

      – max66
      3 hours ago

















    • This is madness, this use of the comma operator, the long/int overload... Have an upvote. :/

      – matovitch
      3 hours ago











    • @matovitch - never underestimate the power of the comma operator }:‑)

      – max66
      3 hours ago
















    This is madness, this use of the comma operator, the long/int overload... Have an upvote. :/

    – matovitch
    3 hours ago





    This is madness, this use of the comma operator, the long/int overload... Have an upvote. :/

    – matovitch
    3 hours ago













    @matovitch - never underestimate the power of the comma operator }:‑)

    – max66
    3 hours ago





    @matovitch - never underestimate the power of the comma operator }:‑)

    – max66
    3 hours ago













    3














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







    share|improve this answer

























    • 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
      13 mins ago
















    3














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







    share|improve this answer

























    • 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
      13 mins ago














    3












    3








    3







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







    share|improve this answer















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








    share|improve this answer














    share|improve this answer



    share|improve this answer








    edited 1 hour ago

























    answered 1 hour ago









    cpplearnercpplearner

    5,38722341




    5,38722341












    • 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
      13 mins ago


















    • 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
      13 mins ago

















    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
    13 mins ago






    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
    13 mins ago












    2














    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.






    share|improve this answer



























      2














      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.






      share|improve this answer

























        2












        2








        2







        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.






        share|improve this answer













        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.







        share|improve this answer












        share|improve this answer



        share|improve this answer










        answered 2 hours ago









        cpplearnercpplearner

        5,38722341




        5,38722341



























            draft saved

            draft discarded
















































            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.




            draft saved


            draft discarded














            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





















































            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







            Popular posts from this blog

            Disable / Remove link to Product Items in Cart Planned maintenance scheduled April 23, 2019 at 23:30 UTC (7:30pm US/Eastern) Announcing the arrival of Valued Associate #679: Cesar Manara Unicorn Meta Zoo #1: Why another podcast?How can I limit products that can be bought / added to cart?Remove item from cartHide “Add to Cart” button if specific products are already in cart“Prettifying” the custom options in cart pageCreate link in cart sidebar to view all added items After limit reachedLink products together in checkout/cartHow to Get product from cart and add it againHide action-edit on cart page if simple productRemoving Cart items - ObserverRemove wishlist items when added to cart

            Helsingin valtaus Sisällysluettelo Taustaa | Yleistä sotatoimista | Osapuolet | Taistelut Helsingin ympäristössä | Punaisten antautumissuunnitelma | Taistelujen kulku Helsingissä | Valtauksen jälkeen | Tappiot | Muistaminen | Kirjallisuutta | Lähteet | Aiheesta muualla | NavigointivalikkoTeoksen verkkoversioTeoksen verkkoversioGoogle BooksSisällissota Helsingissä päättyi tasan 95 vuotta sittenSaksalaisten ylivoima jyräsi punaisen HelsinginSuomalaiset kuvaavat sotien jälkiä kaupungeissa – katso kuvat ja tarinat tutuilta kulmiltaHelsingin valtaus 90 vuotta sittenSaksalaiset valtasivat HelsinginHyökkäys HelsinkiinHelsingin valtaus 12.–13.4. 1918Saksalaiset käyttivät ihmiskilpiä Helsingin valtauksessa 1918Teoksen verkkoversioTeoksen verkkoversioSaksalaiset hyökkäävät Etelä-SuomeenTaistelut LeppävaarassaSotilaat ja taistelutLeppävaara 1918 huhtikuussa. KapinatarinaHelsingin taistelut 1918Saksalaisten voitonparaati HelsingissäHelsingin valtausta juhlittiinSaksalaisten Helsinki vuonna 1918Helsingin taistelussa kaatuneet valkokaartilaisetHelsinkiin haudatut taisteluissa kaatuneet punaiset12.4.1918 Helsingin valtauksessa saksalaiset apujoukot vapauttavat kaupunginVapaussodan muistomerkkejä Helsingissä ja pääkaupunkiseudullaCrescendo / Vuoden 1918 Kansalaissodan uhrien muistomerkkim

            Adjektiivitarina Tarinan tekeminen | Esimerkki: ennen | Esimerkki: jälkeen | Navigointivalikko