What is C++20's string literal operator template?












22















What is C++20's string literal operator template? Cppreference's example in this respect is quite concise and not very clear to me:



struct A { A(const char *); auto operator<=>(const A&) const = default; };

template<A a> A operator ""_a();


In trying to understand what this feature is I've just learned that you can have numeric literal operator templates in C++, which make each digit of numerical constant be passed as a non-type argument to a template (cf. a better explanation here). Currently, literal operator templates do not work with character literals, though there are compilers extensions enabling that. I don't think C++20's string literal operator templates have anything to do with that as I've learned that proposals to extend literal operator templates to work with character literals were voted down in the commitee?










share|improve this question























  • Does the proposal answer your question?

    – Lightness Races in Orbit
    Jan 20 at 15:58













  • @LightnessRacesinOrbit That's the version that got voted down.

    – cpplearner
    Jan 20 at 16:08











  • Okay, how about this one?

    – Lightness Races in Orbit
    Jan 20 at 16:10
















22















What is C++20's string literal operator template? Cppreference's example in this respect is quite concise and not very clear to me:



struct A { A(const char *); auto operator<=>(const A&) const = default; };

template<A a> A operator ""_a();


In trying to understand what this feature is I've just learned that you can have numeric literal operator templates in C++, which make each digit of numerical constant be passed as a non-type argument to a template (cf. a better explanation here). Currently, literal operator templates do not work with character literals, though there are compilers extensions enabling that. I don't think C++20's string literal operator templates have anything to do with that as I've learned that proposals to extend literal operator templates to work with character literals were voted down in the commitee?










share|improve this question























  • Does the proposal answer your question?

    – Lightness Races in Orbit
    Jan 20 at 15:58













  • @LightnessRacesinOrbit That's the version that got voted down.

    – cpplearner
    Jan 20 at 16:08











  • Okay, how about this one?

    – Lightness Races in Orbit
    Jan 20 at 16:10














22












22








22


2






What is C++20's string literal operator template? Cppreference's example in this respect is quite concise and not very clear to me:



struct A { A(const char *); auto operator<=>(const A&) const = default; };

template<A a> A operator ""_a();


In trying to understand what this feature is I've just learned that you can have numeric literal operator templates in C++, which make each digit of numerical constant be passed as a non-type argument to a template (cf. a better explanation here). Currently, literal operator templates do not work with character literals, though there are compilers extensions enabling that. I don't think C++20's string literal operator templates have anything to do with that as I've learned that proposals to extend literal operator templates to work with character literals were voted down in the commitee?










share|improve this question














What is C++20's string literal operator template? Cppreference's example in this respect is quite concise and not very clear to me:



struct A { A(const char *); auto operator<=>(const A&) const = default; };

template<A a> A operator ""_a();


In trying to understand what this feature is I've just learned that you can have numeric literal operator templates in C++, which make each digit of numerical constant be passed as a non-type argument to a template (cf. a better explanation here). Currently, literal operator templates do not work with character literals, though there are compilers extensions enabling that. I don't think C++20's string literal operator templates have anything to do with that as I've learned that proposals to extend literal operator templates to work with character literals were voted down in the commitee?







c++ c++20 user-defined-literals






share|improve this question













share|improve this question











share|improve this question




share|improve this question










asked Jan 20 at 15:54









lukeglukeg

1,81011027




1,81011027













  • Does the proposal answer your question?

    – Lightness Races in Orbit
    Jan 20 at 15:58













  • @LightnessRacesinOrbit That's the version that got voted down.

    – cpplearner
    Jan 20 at 16:08











  • Okay, how about this one?

    – Lightness Races in Orbit
    Jan 20 at 16:10



















  • Does the proposal answer your question?

    – Lightness Races in Orbit
    Jan 20 at 15:58













  • @LightnessRacesinOrbit That's the version that got voted down.

    – cpplearner
    Jan 20 at 16:08











  • Okay, how about this one?

    – Lightness Races in Orbit
    Jan 20 at 16:10

















Does the proposal answer your question?

– Lightness Races in Orbit
Jan 20 at 15:58







Does the proposal answer your question?

– Lightness Races in Orbit
Jan 20 at 15:58















@LightnessRacesinOrbit That's the version that got voted down.

– cpplearner
Jan 20 at 16:08





@LightnessRacesinOrbit That's the version that got voted down.

– cpplearner
Jan 20 at 16:08













Okay, how about this one?

– Lightness Races in Orbit
Jan 20 at 16:10





Okay, how about this one?

– Lightness Races in Orbit
Jan 20 at 16:10












1 Answer
1






active

oldest

votes


















19














There were two separate proposals:




  • Allowing string literals as non-type template parameters (P0424)

  • Allowing class types as non-type template parameters (P0732)


The first proposal was partially merged into the second. String literals still are not valid arguments as non-type template parameters, but they are valid arguments into class types. The example from [temp.arg.nontype]/4 might help:




template<class T, T p> class X {
/* ... */
};

X<const char*, "Studebaker"> x; // error: string literal as template-argument

const char p = "Vivisectionist";
X<const char*, p> y; // OK

struct A {
constexpr A(const char*) {}
friend auto operator<=>(const A&, const A&) = default;
};

X<A, "Pyrophoricity"> z; // OK, string literal is a constructor argument to A



However, the part of the first proposal which extended the literal operators was what was merged into the second, [lex.ext]/5:




If S contains a literal operator template with a non-type template parameter for which str is a well-formed template-argument, the literal L is treated as a call of the form
operator "" X<str>()




So using this:



struct A { A(const char *); auto operator<=>(const A&) const = default; };     
template<A a> A operator ""_a() { return a; }


We can write "Hello"_a, which will be interpreted as calling operator "" _a<A("Hello")>.





Note that these rules are slightly in flux, as the defaulted <=> requirement will be changing to a defaulted == requirement as per P1185.






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%2f54278201%2fwhat-is-c20s-string-literal-operator-template%23new-answer', 'question_page');
    }
    );

    Post as a guest















    Required, but never shown

























    1 Answer
    1






    active

    oldest

    votes








    1 Answer
    1






    active

    oldest

    votes









    active

    oldest

    votes






    active

    oldest

    votes









    19














    There were two separate proposals:




    • Allowing string literals as non-type template parameters (P0424)

    • Allowing class types as non-type template parameters (P0732)


    The first proposal was partially merged into the second. String literals still are not valid arguments as non-type template parameters, but they are valid arguments into class types. The example from [temp.arg.nontype]/4 might help:




    template<class T, T p> class X {
    /* ... */
    };

    X<const char*, "Studebaker"> x; // error: string literal as template-argument

    const char p = "Vivisectionist";
    X<const char*, p> y; // OK

    struct A {
    constexpr A(const char*) {}
    friend auto operator<=>(const A&, const A&) = default;
    };

    X<A, "Pyrophoricity"> z; // OK, string literal is a constructor argument to A



    However, the part of the first proposal which extended the literal operators was what was merged into the second, [lex.ext]/5:




    If S contains a literal operator template with a non-type template parameter for which str is a well-formed template-argument, the literal L is treated as a call of the form
    operator "" X<str>()




    So using this:



    struct A { A(const char *); auto operator<=>(const A&) const = default; };     
    template<A a> A operator ""_a() { return a; }


    We can write "Hello"_a, which will be interpreted as calling operator "" _a<A("Hello")>.





    Note that these rules are slightly in flux, as the defaulted <=> requirement will be changing to a defaulted == requirement as per P1185.






    share|improve this answer




























      19














      There were two separate proposals:




      • Allowing string literals as non-type template parameters (P0424)

      • Allowing class types as non-type template parameters (P0732)


      The first proposal was partially merged into the second. String literals still are not valid arguments as non-type template parameters, but they are valid arguments into class types. The example from [temp.arg.nontype]/4 might help:




      template<class T, T p> class X {
      /* ... */
      };

      X<const char*, "Studebaker"> x; // error: string literal as template-argument

      const char p = "Vivisectionist";
      X<const char*, p> y; // OK

      struct A {
      constexpr A(const char*) {}
      friend auto operator<=>(const A&, const A&) = default;
      };

      X<A, "Pyrophoricity"> z; // OK, string literal is a constructor argument to A



      However, the part of the first proposal which extended the literal operators was what was merged into the second, [lex.ext]/5:




      If S contains a literal operator template with a non-type template parameter for which str is a well-formed template-argument, the literal L is treated as a call of the form
      operator "" X<str>()




      So using this:



      struct A { A(const char *); auto operator<=>(const A&) const = default; };     
      template<A a> A operator ""_a() { return a; }


      We can write "Hello"_a, which will be interpreted as calling operator "" _a<A("Hello")>.





      Note that these rules are slightly in flux, as the defaulted <=> requirement will be changing to a defaulted == requirement as per P1185.






      share|improve this answer


























        19












        19








        19







        There were two separate proposals:




        • Allowing string literals as non-type template parameters (P0424)

        • Allowing class types as non-type template parameters (P0732)


        The first proposal was partially merged into the second. String literals still are not valid arguments as non-type template parameters, but they are valid arguments into class types. The example from [temp.arg.nontype]/4 might help:




        template<class T, T p> class X {
        /* ... */
        };

        X<const char*, "Studebaker"> x; // error: string literal as template-argument

        const char p = "Vivisectionist";
        X<const char*, p> y; // OK

        struct A {
        constexpr A(const char*) {}
        friend auto operator<=>(const A&, const A&) = default;
        };

        X<A, "Pyrophoricity"> z; // OK, string literal is a constructor argument to A



        However, the part of the first proposal which extended the literal operators was what was merged into the second, [lex.ext]/5:




        If S contains a literal operator template with a non-type template parameter for which str is a well-formed template-argument, the literal L is treated as a call of the form
        operator "" X<str>()




        So using this:



        struct A { A(const char *); auto operator<=>(const A&) const = default; };     
        template<A a> A operator ""_a() { return a; }


        We can write "Hello"_a, which will be interpreted as calling operator "" _a<A("Hello")>.





        Note that these rules are slightly in flux, as the defaulted <=> requirement will be changing to a defaulted == requirement as per P1185.






        share|improve this answer













        There were two separate proposals:




        • Allowing string literals as non-type template parameters (P0424)

        • Allowing class types as non-type template parameters (P0732)


        The first proposal was partially merged into the second. String literals still are not valid arguments as non-type template parameters, but they are valid arguments into class types. The example from [temp.arg.nontype]/4 might help:




        template<class T, T p> class X {
        /* ... */
        };

        X<const char*, "Studebaker"> x; // error: string literal as template-argument

        const char p = "Vivisectionist";
        X<const char*, p> y; // OK

        struct A {
        constexpr A(const char*) {}
        friend auto operator<=>(const A&, const A&) = default;
        };

        X<A, "Pyrophoricity"> z; // OK, string literal is a constructor argument to A



        However, the part of the first proposal which extended the literal operators was what was merged into the second, [lex.ext]/5:




        If S contains a literal operator template with a non-type template parameter for which str is a well-formed template-argument, the literal L is treated as a call of the form
        operator "" X<str>()




        So using this:



        struct A { A(const char *); auto operator<=>(const A&) const = default; };     
        template<A a> A operator ""_a() { return a; }


        We can write "Hello"_a, which will be interpreted as calling operator "" _a<A("Hello")>.





        Note that these rules are slightly in flux, as the defaulted <=> requirement will be changing to a defaulted == requirement as per P1185.







        share|improve this answer












        share|improve this answer



        share|improve this answer










        answered Jan 20 at 16:13









        BarryBarry

        183k21320588




        183k21320588
































            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%2f54278201%2fwhat-is-c20s-string-literal-operator-template%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

            MongoDB - Not Authorized To Execute Command

            How to fix TextFormField cause rebuild widget in Flutter

            in spring boot 2.1 many test slices are not allowed anymore due to multiple @BootstrapWith