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
    2 days ago













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

    – cpplearner
    2 days ago











  • Okay, how about this one?

    – Lightness Races in Orbit
    2 days ago
















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
    2 days ago













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

    – cpplearner
    2 days ago











  • Okay, how about this one?

    – Lightness Races in Orbit
    2 days ago














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 2 days ago









lukeglukeg

1,7961826




1,7961826













  • Does the proposal answer your question?

    – Lightness Races in Orbit
    2 days ago













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

    – cpplearner
    2 days ago











  • Okay, how about this one?

    – Lightness Races in Orbit
    2 days ago



















  • Does the proposal answer your question?

    – Lightness Races in Orbit
    2 days ago













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

    – cpplearner
    2 days ago











  • Okay, how about this one?

    – Lightness Races in Orbit
    2 days ago

















Does the proposal answer your question?

– Lightness Races in Orbit
2 days ago







Does the proposal answer your question?

– Lightness Races in Orbit
2 days ago















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

– cpplearner
2 days ago





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

– cpplearner
2 days ago













Okay, how about this one?

– Lightness Races in Orbit
2 days ago





Okay, how about this one?

– Lightness Races in Orbit
2 days ago












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 2 days ago









        BarryBarry

        180k19312572




        180k19312572






























            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

            If I really need a card on my start hand, how many mulligans make sense? [duplicate]

            Alcedinidae

            Can an atomic nucleus contain both particles and antiparticles? [duplicate]