Overloading vs. specialization of function templates

Discussion in 'C++' started by Govindan, Sep 8, 2003.

  1. Govindan

    Govindan Guest

    "Dave Theese" <> wrote in message
    news:KUa7b.14665$QT5.9944@fed1read02...
    >
    > Hello all,
    >
    > I'm trying to get a grasp of the difference between specializing a

    function
    > template and overloading it. The example below has a primary template, a
    > specialization and an overload. Note that the overload is identical to

    the
    > specialization except, of course, for the missing "template <>".
    >
    > I don't know if my questions will be a bit too broad or not, but I thought
    > I'd give it shot... When is overloading preferable to specialization?

    When
    > is specialization preferable to overloading? What is the intended
    > conceptual difference between the two? Any other guidance on other things

    I
    > need to know but don't know enough yet to even ask?
    >
    > Thanks everyone - this group has been an invaluable resource to me and I
    > sure appreciate the time of those who have so generously assisted me!
    >
    > Thanks,
    > Dave
    >
    >
    > #include <iostream>
    >
    > using namespace std;
    >
    > struct foo
    > {
    > int data;
    >
    > bool operator<(const foo &rhs) const
    > {
    > return data < rhs.data;
    > }
    > };
    >
    > template <typename T>
    > const T &my_max(const T &a, const T &b)
    > {
    > cout << "Point 1" << endl;
    > return (a < b) ? b : a;
    > }
    >
    > template <>
    > const foo &my_max(const foo &a, const foo &b)
    > {
    > cout << "Point 2" << endl;
    > return (a < b) ? b : a;
    > }
    >
    > const foo &my_max(const foo &a, const foo &b)
    > {
    > cout << "Point 3" << endl;
    > return (a < b) ? b : a;
    > }
    >
    > int main()
    > {
    > foo a = {5};
    > foo b = {10};
    >
    > // Yields "Point 3" as non-templates are
    > // preferred.
    > cout << my_max(a, b).data << endl;
    >
    > return 0;
    > }
    >
    >



    I am not so clear about your question but here goes. I am using simple
    examples
    to explain the concepts.

    Use composition ( has-a relationship,embedded objects ) over inheritance
    (i.e specialisation of a base class).
    If there are many related classes differing in the parameters only by the
    type, then use templates.
    Use operator or function overloading as a last resort.
    As an example the sign plus can mean binary addition eg 4 + 7 or string
    concatenation or adding
    two graphic figures together depending on your program or class.
    Thus in this case the plus sign token is an overloaded operator.

    As an example for function overloading, lets say for a function
    AverageOf3Numbers(param1, param2, param3 ,...)
    where average can mean mean or median.
    The AverageOf3Numbers( totalof3Numbers) function divides the param1 by 3 to
    get the average, as in mean case;
    in the other case,the median interpretation of average, all 3 numbers are
    passed into the function as in,
    AverageOf3Numbers(3 , 5, 8) function does a integer comparison and gives 5
    as the median(average).

    That is in your class definition, there are two AverageOf3Numbers( ) methods
    declared.

    However, if you just want to have one interpreation of the meaning of
    average , as mean, but the types of the parameters differ,
    use a template.
    AverageOf3Numbers(integer1, integer2, integer3) ; AverageOf3Numbers(float1,
    float2, float3) etc
    Use a template class.
    As an example of operator-loading, You can write your own complex nos. class
    to add , subtract, divide and multiply
    complex nos. In this class, all "+", "-", "*" and "/" will be overloaded ,
    the methods will be written by you.

    First check with a C++ standard book and a STL library book before writing
    your own classes. The STL is template-based
    and already has many useful methods , functions,functors you can use etc

    Regards,
    Govin
    Govindan, Sep 8, 2003
    #1
    1. Advertising

  2. Govindan

    Dave Theese Guest

    Hello all,

    I'm trying to get a grasp of the difference between specializing a function
    template and overloading it. The example below has a primary template, a
    specialization and an overload. Note that the overload is identical to the
    specialization except, of course, for the missing "template <>".

    I don't know if my questions will be a bit too broad or not, but I thought
    I'd give it shot... When is overloading preferable to specialization? When
    is specialization preferable to overloading? What is the intended
    conceptual difference between the two? Any other guidance on other things I
    need to know but don't know enough yet to even ask?

    Thanks everyone - this group has been an invaluable resource to me and I
    sure appreciate the time of those who have so generously assisted me!

    Thanks,
    Dave


    #include <iostream>

    using namespace std;

    struct foo
    {
    int data;

    bool operator<(const foo &rhs) const
    {
    return data < rhs.data;
    }
    };

    template <typename T>
    const T &my_max(const T &a, const T &b)
    {
    cout << "Point 1" << endl;
    return (a < b) ? b : a;
    }

    template <>
    const foo &my_max(const foo &a, const foo &b)
    {
    cout << "Point 2" << endl;
    return (a < b) ? b : a;
    }

    const foo &my_max(const foo &a, const foo &b)
    {
    cout << "Point 3" << endl;
    return (a < b) ? b : a;
    }

    int main()
    {
    foo a = {5};
    foo b = {10};

    // Yields "Point 3" as non-templates are
    // preferred.
    cout << my_max(a, b).data << endl;

    return 0;
    }
    Dave Theese, Sep 9, 2003
    #2
    1. Advertising

  3. Govindan

    Mike Wahler Guest

    Senthilvel Samatharman <> wrote in
    message news:...
    > Dave Theese wrote:
    >
    > > Hello all,
    > >
    > > I'm trying to get a grasp of the difference between specializing a

    function
    > > template and overloading it. The example below has a primary template,

    a
    > > specialization and an overload. Note that the overload is identical to

    the
    > > specialization except, of course, for the missing "template <>".
    > >
    > > I don't know if my questions will be a bit too broad or not, but I

    thought
    > > I'd give it shot... When is overloading preferable to specialization?

    When
    > > is specialization preferable to overloading? What is the intended
    > > conceptual difference between the two? Any other guidance on other

    things I
    > > need to know but don't know enough yet to even ask?

    >
    > I had the same question sometime back and this is the reply from Bjarne
    > Stroustrup....
    >
    > "For functions, you don't have to. Overloading will do. For classes, you

    don't
    > have an alternative. Note that when you specialize the specialzation

    doesn't
    > affect overload resolution rules, when you overload with a

    non-specialization,
    > overload resolution will prefer the non-specialization."


    Vandevoordes & Josuttis' recent book "C++ Templates"
    imo covers this and other template issues quite well.

    I must admit it will take me at least a few passes through this
    great book to absorb everything therein. :)

    http://www.josuttis.com/tmplbook/index.html

    -Mike
    Mike Wahler, Sep 9, 2003
    #3
  4. Govindan

    tom_usenet Guest

    On Mon, 8 Sep 2003 19:30:51 -0700, "Dave Theese"
    <> wrote:

    >
    >Hello all,
    >
    >I'm trying to get a grasp of the difference between specializing a function
    >template and overloading it. The example below has a primary template, a
    >specialization and an overload. Note that the overload is identical to the
    >specialization except, of course, for the missing "template <>".
    >
    >I don't know if my questions will be a bit too broad or not, but I thought
    >I'd give it shot... When is overloading preferable to specialization?


    Non-template overloads can be useful if you want the function to be
    chosen in the face of conversions and non-exact parameter matches.

    Also, because partial specialization doesn't exist for function
    templates, you have to use overloading when you need a special
    implementation for a subset of cases of a template.

    When
    >is specialization preferable to overloading?


    When you just want to provide a special implementation for a
    particular type, but don't want to effect overload resolution.

    What is the intended
    >conceptual difference between the two?


    An overload adds a new function, a specialization just specializes an
    implementation of a function you already have.

    Any other guidance on other things I
    >need to know but don't know enough yet to even ask?


    There's a bit more information here:
    http://www.gotw.ca/gotw/049.htm

    and a ludicrous amount of information about all sorts of C++ things
    here:
    http://www.gotw.ca/gotw/

    Tom
    tom_usenet, Sep 9, 2003
    #4
  5. Dave Theese wrote:

    > Hello all,
    >
    > I'm trying to get a grasp of the difference between specializing a function
    > template and overloading it. The example below has a primary template, a
    > specialization and an overload. Note that the overload is identical to the
    > specialization except, of course, for the missing "template <>".
    >
    > I don't know if my questions will be a bit too broad or not, but I thought
    > I'd give it shot... When is overloading preferable to specialization? When
    > is specialization preferable to overloading? What is the intended
    > conceptual difference between the two? Any other guidance on other things I
    > need to know but don't know enough yet to even ask?


    I had the same question sometime back and this is the reply from Bjarne
    Stroustrup....

    "For functions, you don't have to. Overloading will do. For classes, you don't
    have an alternative. Note that when you specialize the specialzation doesn't
    affect overload resolution rules, when you overload with a non-specialization,
    overload resolution will prefer the non-specialization."

    >
    >
    > Thanks everyone - this group has been an invaluable resource to me and I
    > sure appreciate the time of those who have so generously assisted me!
    >
    > Thanks,
    > Dave
    >
    > #include <iostream>
    >
    > using namespace std;
    >
    > struct foo
    > {
    > int data;
    >
    > bool operator<(const foo &rhs) const
    > {
    > return data < rhs.data;
    > }
    > };
    >
    > template <typename T>
    > const T &my_max(const T &a, const T &b)
    > {
    > cout << "Point 1" << endl;
    > return (a < b) ? b : a;
    > }
    >
    > template <>
    > const foo &my_max(const foo &a, const foo &b)
    > {
    > cout << "Point 2" << endl;
    > return (a < b) ? b : a;
    > }
    >
    > const foo &my_max(const foo &a, const foo &b)
    > {
    > cout << "Point 3" << endl;
    > return (a < b) ? b : a;
    > }
    >
    > int main()
    > {
    > foo a = {5};
    > foo b = {10};
    >
    > // Yields "Point 3" as non-templates are
    > // preferred.
    > cout << my_max(a, b).data << endl;
    >
    > return 0;
    > }
    Senthilvel Samatharman, Sep 9, 2003
    #5
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. JKop
    Replies:
    3
    Views:
    467
  2. Replies:
    10
    Views:
    593
    Shezan Baig
    Jun 14, 2005
  3. WittyGuy
    Replies:
    16
    Views:
    3,828
  4. recover
    Replies:
    2
    Views:
    799
    recover
    Jul 25, 2006
  5. flopbucket
    Replies:
    6
    Views:
    455
    Victor Bazarov
    Aug 17, 2006
Loading...

Share This Page