1. Forum
  2. Usenet
  3. COMP.LANG.C++.MODERATED

  • Templated Overloaded Operator

    From Adi Shavit@21:1/5 to All on Wed Apr 27 13:08:58 2016
    { edited by mod to shorten lines to ~70 characters. -mod }

    Hi,

    The following code (http://ideone.com/e.js/6pTF0n) works fine:

    #include <iostream>

    struct A
    {
    int v = 3;
    };


    namespace Foo
    {
    template <int k=11> // note the default value of 11
    int operator+(A const& rhs, A const& lhs)
    {
    return rhs.v + lhs.v + k;
    }
    }

    using Foo::operator+; // will use k == 11


    using namespace std;
    int main()
    {

    A a1, a2;

    cout << a1 + a2 << endl;

    return EXIT_SUCCESS;
    }


    The templated overloaded operator+ is brought into ADL scope with the
    `using` clause and when used the default template value of 11 is used
    to produce 3+3+11 = 17.

    My question is how do I set a different k value, presumable where the
    using clause is, so that the + syntax remains unchanged?

    Thanks!
    Adi


    --
    [ See http://www.gotw.ca/resources/clcm.htm for info about ]
    [ comp.lang.c++.moderated. First time posters: Do this! ]

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Adi Shavit@21:1/5 to Adi Shavit on Wed Apr 27 17:12:54 2016
    { quoted server banner and signature redacted by mod. -mod }

    Obviously, the example below is a contrived for simplicity. The operator in
    my
    actual code makes domain-specific sense.
    Essentially what I am trying to achieve a policy-based design for operators where the template parameter k is a policy-related value.

    In the code I want to keep the original `cout` line unchanged and only
    change the way the operator function behaves when brought into scope.

    Adi


    On Wednesday, April 27, 2016 at 9:10:10 PM UTC+3, Adi Shavit wrote:
    { edited by mod to shorten lines to ~70 characters. -mod }

    Hi,

    The following code (http://ideone.com/e.js/6pTF0n) works fine:

    #include <iostream>

    struct A
    {
    int v = 3;
    };


    namespace Foo
    {
    template <int k=11> // note the default value of 11
    int operator+(A const& rhs, A const& lhs)
    {
    return rhs.v + lhs.v + k;
    }
    }

    using Foo::operator+; // will use k == 11


    using namespace std;
    int main()
    {

    A a1, a2;

    cout << a1 + a2 << endl;

    return EXIT_SUCCESS;
    }


    The templated overloaded operator+ is brought into ADL scope with the
    `using` clause and when used the default template value of 11 is used
    to produce 3+3+11 = 17.

    My question is how do I set a different k value, presumable where the
    using clause is, so that the + syntax remains unchanged?

    Thanks!


    --
    [ See http://www.gotw.ca/resources/clcm.htm for info about ]
    [ comp.lang.c++.moderated. First time posters: Do this! ]

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Adi Shavit@21:1/5 to All on Thu Apr 28 15:01:24 2016
    Further digging shows that something like: `using Foo::operator+<42>`
    will not work. This is due to ISO C++ Standard 7.3.3.5:
    "A using-declaration shall not name a template-id."

    Is there some way around this?


    I managed to mostly get what I wanted by using a templated
    trait class and selectively typedefing it. See it in action here: <http://coliru.stacked-crooked.com/a/3c56e10fbb5a1d06>

    More details here: <http://stackoverflow.com/a/36911214/135862>


    --
    [ See http://www.gotw.ca/resources/clcm.htm for info about ]
    [ comp.lang.c++.moderated. First time posters: Do this! ]

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Adi Shavit@21:1/5 to All on Thu Apr 28 06:30:51 2016
    Essentially what I am trying to achieve a policy-based design for
    operators
    where the template parameter k is a policy-related value.

    In the code I want to keep the original `cout` line unchanged and only
    change the way the operator function behaves when brought into scope.


    Further digging shows that something like: `using Foo::operator+<42>`
    will not work. This is due to ISO C++ Standard 7.3.3.5:
    "A using-declaration shall not name a template-id."

    Is there some way around this?

    Adi


    --
    [ See http://www.gotw.ca/resources/clcm.htm for info about ]
    [ comp.lang.c++.moderated. First time posters: Do this! ]

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to Adi Shavit on Sun May 8 17:10:31 2016
    On 4/27/16 3:08 PM, Adi Shavit wrote:
    { edited by mod to shorten lines to ~70 characters. -mod }

    Hi,

    The following code (http://ideone.com/e.js/6pTF0n) works fine:

    #include <iostream>

    struct A
    {
    int v = 3;
    };


    namespace Foo
    {
    template <int k=11> // note the default value of 11
    int operator+(A const& rhs, A const& lhs)
    {
    return rhs.v + lhs.v + k;
    }
    }

    using Foo::operator+; // will use k == 11


    using namespace std;
    int main()
    {

    A a1, a2;

    cout << a1 + a2 << endl;

    return EXIT_SUCCESS;
    }


    The templated overloaded operator+ is brought into ADL scope with the
    `using` clause and when used the default template value of 11 is used
    to produce 3+3+11 = 17.

    My question is how do I set a different k value, presumable where the
    using clause is, so that the + syntax remains unchanged?

    Thanks!
    Adi


    maybe something like:

    namespace Foo2
    {
    template <int k=13>
    int operator+(A const& rhs, A const& lhs) {
    return Foo::operator+<k>(rhs, lhs);
    }
    }

    using Foo2::operator+;


    --
    [ See http://www.gotw.ca/resources/clcm.htm for info about ]
    [ comp.lang.c++.moderated. First time posters: Do this! ]

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)