{"id":201,"date":"2008-04-29T20:14:19","date_gmt":"2008-04-30T04:14:19","guid":{"rendered":"http:\/\/www.learncpp.com\/?p=201"},"modified":"2023-09-11T12:40:44","modified_gmt":"2023-09-11T19:40:44","slug":"overloading-operators-and-function-templates","status":"publish","type":"post","link":"https:\/\/www.learncpp.com\/cpp-tutorial\/overloading-operators-and-function-templates\/","title":{"rendered":"21.14 — Overloading operators and function templates"},"content":{"rendered":"

In lesson 11.7 -- Function template instantiation<\/a>, we discussed how the compiler will use function templates to instantiate functions, which are then compiled. We also noted that these functions may not compile, if the code in the function template tries to perform some operation that the actual type doesn’t support (such as adding integer value 1<\/code> to a std::string<\/code>).<\/p>\n

In this lesson, we’ll take a look at a few examples where our instantiated functions won’t compile because our actual class types don’t support those operators, and show how we can define those operators so that the instantiated functions will then compile.<\/p>\n

Operators, function calls, and function templates<\/p>\n

First, let’s create a simple class:<\/p>\n

class Cents\r\n{\r\nprivate:\r\n    int m_cents{};\r\npublic:\r\n    Cents(int cents)\r\n        : m_cents { cents }\r\n    {\r\n    }\r\n\r\n    friend std::ostream& operator<< (std::ostream& ostr, const Cents& c)\r\n    {\r\n        ostr << c.m_cents;\r\n        return ostr;\r\n    }\r\n};<\/code><\/pre>\n
and define a max<\/code> function template:<\/p>\n
template <typename T>\r\nconst T& max(const T& x, const T& y)\r\n{\r\n    return (x < y) ? y : x;\r\n}<\/code><\/pre>\n
Now, let’s see what happens when we try to call max()<\/code> with object of type Cents<\/code>:<\/p>\n
#include <iostream>\r\n\r\nclass Cents\r\n{\r\nprivate:\r\n    int m_cents{};\r\npublic:\r\n    Cents(int cents)\r\n        : m_cents { cents }\r\n    {\r\n    }\r\n\r\n    friend std::ostream& operator<< (std::ostream& ostr, const Cents& c)\r\n    {\r\n        ostr << c.m_cents;\r\n        return ostr;\r\n    }\r\n};\r\n\r\ntemplate <typename T>\r\nconst T& max(const T& x, const T& y)\r\n{\r\n    return (x < y) ? y : x;\r\n}\r\n\r\nint main()\r\n{\r\n    Cents nickel{ 5 };\r\n    Cents dime{ 10 };\r\n\r\n    Cents bigger { max(nickel, dime) };\r\n    std::cout << bigger << \" is bigger\\n\";\r\n\r\n    return 0;\r\n}<\/code><\/pre>\n
C++ will create a template instance for max() that looks like this:<\/p>\n
template <>\r\nconst Cents& max(const Cents& x, const Cents& y)\r\n{\r\n    return (x < y) ? y : x;\r\n}<\/code><\/pre>\n
And then it will try to compile this function.  See the problem here?  C++ has no idea how to evaluate x < y<\/code> when x<\/code> and y<\/code> are of type Cents<\/code>!  Consequently, this will produce a compile error.<\/p>\n
To get around this problem, simply overload operator<<\/code> for any class we wish to use max<\/code> with:<\/p>\n
#include <iostream>\r\n\r\nclass Cents\r\n{\r\nprivate:\r\n    int m_cents {};\r\npublic:\r\n    Cents(int cents)\r\n        : m_cents { cents }\r\n    {\r\n    }\r\n    \r\n    friend bool operator< (const Cents& c1, const Cents& c2)\r\n    {\r\n        return (c1.m_cents < c2.m_cents);\r\n    }\r\n\r\n    friend std::ostream& operator<< (std::ostream& ostr, const Cents& c)\r\n    {\r\n        ostr << c.m_cents;\r\n        return ostr;\r\n    }\r\n};\r\n\r\ntemplate <typename T>\r\nconst T& max(const T& x, const T& y)\r\n{\r\n    return (x < y) ? y : x;\r\n}\r\n\r\nint main()\r\n{\r\n    Cents nickel{ 5 };\r\n    Cents dime { 10 };\r\n\r\n    Cents bigger { max(nickel, dime) };\r\n    std::cout << bigger << \" is bigger\\n\";\r\n\r\n    return 0;\r\n}<\/code><\/pre>\n
This works as expected, and prints:<\/p>\n
\r\n10 is bigger\r\n<\/pre>\n
Another example<\/p>\n
Let’s do one more example of a function template not working because of missing overloaded operators.<\/p>\n
The following function template will calculate the average of a number of objects in an array:<\/p>\n
#include <iostream>\r\n\r\ntemplate <typename T>\r\nT average(const T* myArray, int numValues)\r\n{\r\n    T sum { 0 };\r\n    for (int count { 0 }; count < numValues; ++count)\r\n        sum += myArray[count];\r\n\r\n    sum \/= numValues;\r\n    return sum;\r\n}\r\n\r\nint main()\r\n{\r\n    int intArray[] { 5, 3, 2, 1, 4 };\r\n    std::cout << average(intArray, 5) << '\\n';\r\n\r\n    double doubleArray[] { 3.12, 3.45, 9.23, 6.34 };\r\n    std::cout << average(doubleArray, 4) << '\\n';\r\n\r\n    return 0;\r\n}<\/code><\/pre>\n
This produces the values:<\/p>\n
\r\n3\r\n5.535\r\n<\/pre>\n
As you can see, it works great for built-in types!<\/p>\n
Now let’s see what happens when we call this function on our Cents<\/code> class:<\/p>\n
#include <iostream>\r\n\r\ntemplate <typename T>\r\nT average(const T* myArray, int numValues)\r\n{\r\n    T sum { 0 };\r\n    for (int count { 0 }; count < numValues; ++count)\r\n        sum += myArray[count];\r\n\r\n    sum \/= numValues;\r\n    return sum;\r\n}\r\n\r\nclass Cents\r\n{\r\nprivate:\r\n    int m_cents {};\r\npublic:\r\n    Cents(int cents)\r\n        : m_cents { cents }\r\n    {\r\n    }\r\n};\r\n\r\nint main()\r\n{\r\n    Cents centsArray[] { Cents { 5 }, Cents { 10 }, Cents { 15 }, Cents { 14 } };\r\n    std::cout << average(centsArray, 4) << '\\n';\r\n\r\n    return 0;\r\n}<\/code><\/pre>\n
The compiler goes berserk and produces a ton of error messages!  The first error message will be something like this:<\/p>\n
\r\nerror C2679: binary << : no operator found which takes a right-hand operand of type Cents (or there is no acceptable conversion)\r\n<\/pre>\n
Remember that average()<\/code> returns a Cents<\/code> object, and we are trying to stream that object to std::cout<\/code> using operator<<<\/code>.  However, we haven’t defined the operator<<<\/code> for our Cents<\/code> class yet.  Let’s do that:<\/p>\n
#include <iostream>\r\n\r\ntemplate <typename T>\r\nT average(const T* myArray, int numValues)\r\n{\r\n    T sum { 0 };\r\n    for (int count { 0 }; count < numValues; ++count)\r\n        sum += myArray[count];\r\n\r\n    sum \/= numValues;\r\n    return sum;\r\n}\r\n\r\nclass Cents\r\n{\r\nprivate:\r\n    int m_cents {};\r\npublic:\r\n    Cents(int cents)\r\n        : m_cents { cents }\r\n    {\r\n    }\r\n\r\n    friend std::ostream& operator<< (std::ostream& out, const Cents& cents)\r\n    {\r\n        out << cents.m_cents << \" cents \";\r\n        return out;\r\n    }\r\n};\r\n\r\nint main()\r\n{\r\n    Cents centsArray[] { Cents { 5 }, Cents { 10 }, Cents { 15 }, Cents { 14 } };\r\n    std::cout << average(centsArray, 4) << '\\n';\r\n\r\n    return 0;\r\n}<\/code><\/pre>\n
If we compile again, we will get another error:<\/p>\n
error C2676: binary += : Cents does not define this operator or a conversion to a type acceptable to the predefined operator<\/pre>\n
This error is actually being caused by the function template instance created when we call average(const Cents*, int)<\/code>.  Remember that when we call a templated function, the compiler “stencils” out a copy of the function where the template type parameters (the placeholder types) have been replaced with the actual types in the function call.  Here is the function template instance for average()<\/code> when T<\/code> is a Cents<\/code> object:<\/p>\n
template <>\r\nCents average(const Cents* myArray, int numValues)\r\n{\r\n    Cents sum { 0 };\r\n    for (int count { 0 }; count < numValues; ++count)\r\n        sum += myArray[count];\r\n\r\n    sum \/= numValues;\r\n    return sum;\r\n}<\/code><\/pre>\n
The reason we are getting an error message is because of the following line:<\/p>\n
        sum += myArray[count];<\/code><\/pre>\n
In this case, sum<\/code> is a Cents<\/code> object, but we have not defined operator+=<\/code> for Cents<\/code> objects!  We will need to define this function in order for average()<\/code> to be able to work with Cents<\/code>.  Looking forward, we can see that average()<\/code> also uses the operator\/=<\/code>, so we will go ahead and define that as well:<\/p>\n
#include <iostream>\r\n\r\ntemplate <typename T>\r\nT average(const T* myArray, int numValues)\r\n{\r\n    T sum { 0 };\r\n    for (int count { 0 }; count < numValues; ++count)\r\n        sum += myArray[count];\r\n\r\n    sum \/= numValues;\r\n    return sum;\r\n}\r\n\r\nclass Cents\r\n{\r\nprivate:\r\n    int m_cents {};\r\npublic:\r\n    Cents(int cents)\r\n        : m_cents { cents }\r\n    {\r\n    }\r\n\r\n    friend std::ostream& operator<< (std::ostream& out, const Cents& cents)\r\n    {\r\n        out << cents.m_cents << \" cents \";\r\n        return out;\r\n    }\r\n\r\n    Cents& operator+= (const Cents &cents)\r\n    {\r\n        m_cents += cents.m_cents;\r\n        return *this;\r\n    }\r\n\r\n    Cents& operator\/= (int x)\r\n    {\r\n        m_cents \/= x;\r\n        return *this;\r\n    }\r\n};\r\n\r\nint main()\r\n{\r\n    Cents centsArray[] { Cents { 5 }, Cents { 10 }, Cents { 15 }, Cents { 14 } };\r\n    std::cout << average(centsArray, 4) << '\\n';\r\n\r\n    return 0;\r\n}<\/code><\/pre>\n
Finally, our code will compile and run!  Here is the result:<\/p>\n
\r\n11 cents\r\n<\/pre>\n
Note that we didn’t have to modify average()<\/code> at all to make it work with objects of type Cents<\/code>.  We simply had to define the operators used to implement average()<\/code> for the Cents<\/code> class, and the compiler took care of the rest!<\/p>\n
\n\t\n 
\n    
<\/i><\/div>\n    
\n      
Next lesson<\/div>\n      
\n        21.x<\/span>Chapter 21 summary and quiz\n      <\/div>\n    <\/div>\n  <\/div><\/a>\n  \t\n  
\n    
<\/i><\/div>\n    
\n      
Back to table of contents<\/div>\n    <\/div>\n<\/div><\/a>\n  \t\n  
\n    
<\/i><\/div>\n    
\n      
Previous lesson<\/div>\n      
\n        21.13<\/span>Shallow vs. deep copying\n      <\/div>\n    <\/div>\n  <\/div><\/a>\n  <\/div><\/div>\n","protected":false},"excerpt":{"rendered":"
In lesson , we discussed how the compiler will use function templates to instantiate functions, which are then compiled. We also noted that these functions may not compile, if the code in the function template tries to perform some operation that the actual type doesn’t support (such as adding integer …<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[3],"tags":[12,13,14,17,15,16],"_links":{"self":[{"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/posts\/201"}],"collection":[{"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/comments?post=201"}],"version-history":[{"count":37,"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/posts\/201\/revisions"}],"predecessor-version":[{"id":15354,"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/posts\/201\/revisions\/15354"}],"wp:attachment":[{"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/media?parent=201"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/categories?post=201"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.learncpp.com\/wp-json\/wp\/v2\/tags?post=201"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}