{"id":1127,"date":"2024-08-22T17:12:21","date_gmt":"2024-08-22T17:12:21","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/?page_id=1127"},"modified":"2025-01-26T18:44:50","modified_gmt":"2025-01-26T18:44:50","slug":"operator-overloading-friends","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/topics\/c-details\/classes\/operator-overloading-friends\/","title":{"rendered":"Operator Overloading & friends"},"content":{"rendered":"\n

<\/span>Operator Overloading & friends<\/span><\/h2>\n\n\n\n

<\/span>Operator Overloading<\/span><\/h3>\n\n\n\n

Now we’re ready to take a look at operator overloading<\/em>:<\/p>\n\n\n\n

    \n
  • We’ll start with perhaps the most common: assignment<\/em><\/li>\n\n\n\n
  • As we advance, we’ll see:\n
      \n
    • where and how this<\/strong> is used<\/li>\n\n\n\n
    • where temporary objects <\/em>become important<\/li>\n\n\n\n
    • and lots of other things!<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n

      <\/span>Initialization vs. Assignment<\/span><\/h3>\n\n\n\n

      It is essential to understand the difference between initialization and assignment — they are two different things!<\/em><\/p>\n\n\n\n

      <\/span>Initialization<\/em> <\/span><\/h4>\n\n\n\n

      Occurs in three contexts:<\/p>\n\n\n\n

        \n
      • definitions with initializers<\/li>\n\n\n\n
      • format function arguments<\/li>\n\n\n\n
      • function return types<\/li>\n<\/ul>\n\n\n\n

        For example:<\/p>\n\n\n\n

        Complex a(1);\t\/\/ 1-arg constructor\nComplex b = a;\t\/\/ Copy constructor\nComplex c = Complex(1,2);\n\t\t\t\t\/\/ 2-arg constructor\n\t\t\t\t\/\/ + copy constructor<\/code><\/pre>\n\n\n\n
        <\/span>Assignment<\/em><\/span><\/h4>\n\n\n\n
        Occurs in:<\/p>\n\n\n\n
          \n
        • expressions (not definitions!<\/em>) that use the =<\/strong> operator.<\/li>\n<\/ul>\n\n\n\n
          <\/span>Initialization & Initializer Lists<\/span><\/h3>\n\n\n\n
          An object of a class with:<\/p>\n\n\n\n
            \n
          • no constructors<\/em>, and<\/li>\n\n\n\n
          • no private or protected members<\/em>, and<\/li>\n\n\n\n
          • no virtual functions<\/em>, and <\/li>\n\n\n\n
          • no base classes<\/em><\/li>\n<\/ul>\n\n\n\n
            can be initialized using an initializer list<\/em>:<\/p>\n\n\n\n
            \n
            \n
            <\/path><\/path><\/svg><\/span>
            \/\/<\/span><\/span>\n\/\/  Invoice.h<\/span><\/span>\n\/\/  Initializer Lists<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/20\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Invoice_h<\/span><\/span>\n#define<\/span> Invoice_h<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>LineItem<\/span> {<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  <\/span>std<\/span>::string m_description;<\/span><\/span>\n  <\/span>int<\/span>         m_quantity;<\/span><\/span>\n  <\/span>double<\/span>      m_unit_price;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Invoice<\/span> {<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  <\/span>std<\/span>::string m_bill_to;<\/span><\/span>\n  <\/span>int<\/span>         m_item_count;<\/span><\/span>\n  LineItem    <\/span>m_item<\/span>[<\/span>20<\/span>];<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Invoice_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
            \n
            <\/path><\/path><\/svg><\/span>
            \/\/<\/span><\/span>\n\/\/  Invoice.cpp<\/span><\/span>\n\/\/  Initializer Lists<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/20\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Invoice.h"<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>LineItem<\/span>::<\/span>Print<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Line Item"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>" Description: "<\/span> << m_description << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>" Quantity:    "<\/span> << m_quantity << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>" Unit Price:  "<\/span> << m_unit_price << <\/span>std<\/span>::endl; <\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>Invoice<\/span>::<\/span>Print<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Invoice"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>" Bill To: "<\/span> << m_bill_to << <\/span>std<\/span>::endl;<\/span><\/span>\n<\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i = <\/span>0<\/span>; i < m_item_count; i++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>m_item<\/span>[i].<\/span>Print<\/span>();<\/span><\/span>\n  }<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
            Here’s a program to show how you can use an initializer list to initialize an instance of class Invoice<\/strong>:<\/p>\n\n\n\n
            \n
            \n
            <\/path><\/path><\/svg><\/span>
            \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Initializer Lists<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/20\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Invoice.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  Invoice myInvoice =<\/span><\/span>\n  { <\/span>"Fred Bloggs"<\/span>, <\/span>2<\/span>,<\/span><\/span>\n    { {<\/span>"Widgets"<\/span>, <\/span>3<\/span>, <\/span>3.50<\/span> },<\/span><\/span>\n      {<\/span>"Grommetts"<\/span>, <\/span>5<\/span>, <\/span>5.60<\/span> } }<\/span><\/span>\n  };<\/span> \/\/ Initializer list<\/span><\/span>\n  <\/span><\/span>\n  <\/span>myInvoice<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
            \n
            Here’s what the program outputs<\/p>\n\n\n\n
            Invoice\n Bill To: Fred Bloggs\nLine Item\n Description: Widgets\n Quantity:    3\n Unit Price:  3.5\nLine Item\n Description: Grommetts\n Quantity:    5\n Unit Price:  5.6\nProgram ended with exit code: 0<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
            <\/span>Initialization and Constructors<\/span><\/h3>\n\n\n\n
            An object of a class with a constructor must:<\/p>\n\n\n\n
              \n
            • be initialized<\/em>, or:<\/li>\n\n\n\n
            • have a default constructor<\/em><\/li>\n<\/ul>\n\n\n\n
              The default constructor is used for objects that are not explicitly initialized:<\/p>\n\n\n\n
              \n
              \n
              <\/path><\/path><\/svg><\/span>
              \/\/<\/span><\/span>\n\/\/  Complex.hpp<\/span><\/span>\n\/\/  Initialization & Constructors<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Complex_hpp<\/span><\/span>\n#define<\/span> Complex_hpp<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Complex<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Complex<\/span>();<\/span><\/span>\n  <\/span>Complex<\/span>(<\/span>double<\/span> <\/span>real<\/span>, <\/span>double<\/span> <\/span>imag<\/span> = <\/span>0.0<\/span>);<\/span><\/span>\n  <\/span><\/span>\n  <\/span>double<\/span> m_real, m_imag;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Complex_hpp *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
              \n
              <\/path><\/path><\/svg><\/span>
              \/\/<\/span><\/span>\n\/\/  Complex.cpp<\/span><\/span>\n\/\/  Initialization & Constructors<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Complex.hpp"<\/span><\/span>\n<\/span>\nComplex<\/span>::<\/span>Complex<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"In Default Complex constructor"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  m_real = <\/span>0.0<\/span>;<\/span><\/span>\n  m_imag = <\/span>0.0<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nComplex<\/span>::<\/span>Complex<\/span>(<\/span>double<\/span> real, <\/span>double<\/span> imag)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"In Default Complex(real, imag) constructor"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  m_real = real;<\/span><\/span>\n  m_imag = imag;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
              \n
              \n
              Here’s a program that demonstrates when various Complex constructors are invoked:<\/p>\n\n\n\n
              <\/path><\/path><\/svg><\/span>
              \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Initialization & Constructors<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Complex.hpp"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Complex c;"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  Complex c;<\/span><\/span>\n  <\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Complex ca[10] = { 2.3, 5.4 \/*...*\/ };"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  Complex <\/span>ca<\/span>[<\/span>10<\/span>] = { <\/span>2.3<\/span>, <\/span>5.4<\/span> \/*...*\/<\/span> };<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
              \n
              … and here is what it produces:<\/p>\n\n\n\n
              Complex c;\nIn Default Complex constructor\nComplex ca[10] = { 2.3, 5.4 \/*...*\/ };\nIn Default Complex(real, imag) constructor\nIn Default Complex(real, imag) constructor\nIn Default Complex constructor\nIn Default Complex constructor\nIn Default Complex constructor\nIn Default Complex constructor\nIn Default Complex constructor\nIn Default Complex constructor\nIn Default Complex constructor\nIn Default Complex constructor\nProgram ended with exit code: 0<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
              <\/span>Initialization vs. Assignment<\/span><\/h2>\n\n\n\n
              Imagine we have a simple MyString<\/strong> class:<\/p>\n\n\n\n
              \n
              \n
              <\/path><\/path><\/svg><\/span>
              \/\/<\/span><\/span>\n\/\/  MyString.h<\/span><\/span>\n\/\/  Initialization vs. Assignment<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> MyString_h<\/span><\/span>\n#define<\/span> MyString_h<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><string.h><\/span><\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\nclass<\/span> <\/span>MyString<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>MyString<\/span>(<\/span>const<\/span> <\/span>char<\/span> <\/span>source<\/span>[])<\/span><\/span>\n  {<\/span><\/span>\n    size = <\/span>strlen<\/span>(source);<\/span><\/span>\n    p = <\/span>new<\/span> <\/span>char<\/span>[size + <\/span>1<\/span>];<\/span><\/span>\n    <\/span>strcpy<\/span>(p, source);<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>~MyString<\/span>();<\/span><\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>();<\/span><\/span>\n  <\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>size_t<\/span> size;<\/span><\/span>\n  <\/span>char<\/span>   *p;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* MyString_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
              \n
              <\/path><\/path><\/svg><\/span>
              \/\/<\/span><\/span>\n\/\/  MyString.cpp<\/span><\/span>\n\/\/  Initialization vs. Assignment<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"MyString.h"<\/span><\/span>\n<\/span>\nMyString<\/span>::~<\/span>MyString<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"deleting MyString: "<\/span> << (<\/span>void<\/span>*)p << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>delete<\/span> <\/span>[]<\/span> p;<\/span><\/span>\n}<\/span><\/span>\nvoid<\/span> <\/span>MyString<\/span>::<\/span>Print<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"MyString p = "<\/span> << (<\/span>void<\/span>*) p<\/span><\/span>\n            << <\/span>"; size = "<\/span> << size<\/span><\/span>\n            << <\/span>"; <\/span>\\"<\/span>"<\/span> << p << <\/span>"<\/span>\\"<\/span>"<\/span><\/span>\n            << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
              \n
              \n
              … and test it:<\/p>\n\n\n\n
              <\/path><\/path><\/svg><\/span>
              \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Initialization vs. Assignment<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"MyString.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  MyString <\/span>s1<\/span>(<\/span>"Hello!"<\/span>);<\/span><\/span>\n  MyString <\/span>s2<\/span>(<\/span>"Goodbye"<\/span>);<\/span><\/span>\n<\/span>\n  <\/span>std<\/span>::cout << <\/span>"s1: "<\/span>; <\/span>s1<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"s2: "<\/span>; <\/span>s2<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span><\/span>\n  s1 = s2;<\/span>    \/\/ Assign s2 to s1<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"s1: "<\/span>; <\/span>s1<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"s2: "<\/span>; <\/span>s2<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
              \n
              Here is what it produces:<\/p>\n\n\n\n
              s1: MyString p = 0x600000008030; size = 6; \"Hello!\"\ns2: MyString p = 0x600000008040; size = 7; \"Goodbye\"\n\ns1: MyString p = 0x600000008040; size = 7; \"Goodbye\"\ns2: MyString p = 0x600000008040; size = 7; \"Goodbye\"\ndeleting MyString: 0x600000008040\ndeleting MyString: 0x600000008040\nmalloc: *** error for object 0x600000008040: pointer being freed was not allocated<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
              So what happened?<\/p>\n\n\n\n
              The assignment operation worked, right? After all, we didn’t get a compiler error, right?<\/p>\n\n\n\n
              But what happened in the destructor?<\/p>\n\n\n\n
                \n
              • We have an attempt to do double deallocation<\/em>!<\/li>\n\n\n\n
              • We also didn\u2019t deallocate something we should have<\/em>!<\/li>\n<\/ul>\n\n\n\n
                Besides, how did the assignment get accomplished, in the first place?<\/em><\/strong><\/p>\n\n\n\n
                The problems arose because:<\/p>\n\n\n\n
                  \n
                • The compiler automatically generated an assignment operator<\/em>.<\/li>\n\n\n\n
                • The generated assignment operator did a memberwise (‘shallow’) copy<\/em>.<\/em>\n
                    \n
                  • In other words, it copied the first level elements of the class, but not what the pointers pointed to.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                    To solve the problem for this class, we must write our own assignment operator<\/em>.<\/p>\n\n\n\n
                    <\/span>The Assignment Operator<\/span><\/h3>\n\n\n\n
                    Here is an example of an assignment, for a class T<\/strong>:<\/p>\n\n\n\n
                    T one, two;\none = two;\n<\/code><\/pre>\n\n\n\n
                    An assignment operator is a special class member function<\/em> that, for a class T<\/strong>, looks like:<\/p>\n\n\n\n
                    T &operator=(const T &rhs);<\/strong><\/code><\/pre>\n\n\n\n
                    Note:<\/p>\n\n\n\n
                      \n
                    • The right hand side<\/em> of the assignment is the const T &rhs<\/strong> <\/strong>argument.<\/li>\n\n\n\n
                    • The left hand side<\/em> of the assignment is *this<\/strong> <\/strong>.<\/li>\n<\/ul>\n\n\n\n
                      The return type<\/em> is T &<\/strong> <\/strong>, to support:<\/p>\n\n\n\n
                      one = two = three;<\/strong><\/code><\/pre>\n\n\n\n
                      which is equivalent to:<\/p>\n\n\n\n
                      one.operator=(two.operator=(three))<\/strong><\/code><\/pre>\n\n\n\n
                      Got that?<\/strong> <\/p>\n\n\n\n
                      <\/span>Implementing an Assignment Operator<\/span><\/h3>\n\n\n\n
                      \n
                      \n
                      So, to fix the problem, we add an explicit assignment operator to the class:<\/p>\n\n\n\n
                      <\/path><\/path><\/svg><\/span>
                      \/\/<\/span><\/span>\n\/\/  MyString.h<\/span><\/span>\n\/\/  Initialization vs. Assignment<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> MyString_h<\/span><\/span>\n#define<\/span> MyString_h<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><string.h><\/span><\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\nclass<\/span> <\/span>MyString<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>MyString<\/span>(<\/span>const<\/span> <\/span>char<\/span> <\/span>source<\/span>[])<\/span><\/span>\n  {<\/span><\/span>\n    size = <\/span>strlen<\/span>(source);<\/span><\/span>\n    p = <\/span>new<\/span> <\/span>char<\/span>[size + <\/span>1<\/span>];<\/span><\/span>\n    <\/span>strcpy<\/span>(p, source);<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>~MyString<\/span>();<\/span><\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  \/\/ Explicit assignment operator<\/span><\/span>\n  <\/span>MyString<\/span> <\/span>&<\/span>operator=<\/span>(<\/span>const<\/span> <\/span>MyString<\/span> <\/span>&<\/span>s<\/span>);<\/span><\/span>\n  <\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>size_t<\/span> size;<\/span><\/span>\n  <\/span>char<\/span>   *p;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* MyString_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                      \n
                      <\/path><\/path><\/svg><\/span>
                      \/\/<\/span><\/span>\n\/\/  MyString.cpp<\/span><\/span>\n\/\/  Initialization vs. Assignment<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"MyString.h"<\/span><\/span>\n<\/span>\nMyString<\/span>::~<\/span>MyString<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"deleting MyString: "<\/span> << (<\/span>void<\/span>*)p << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>delete<\/span> <\/span>[]<\/span> p;<\/span><\/span>\n}<\/span><\/span>\nvoid<\/span> <\/span>MyString<\/span>::<\/span>Print<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"MyString p = "<\/span> << (<\/span>void<\/span>*) p<\/span><\/span>\n            << <\/span>"; size = "<\/span> << size<\/span><\/span>\n            << <\/span>"; <\/span>\\"<\/span>"<\/span> << p << <\/span>"<\/span>\\"<\/span>"<\/span><\/span>\n            << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Explicit assignment operator<\/span><\/span>\nMyString<\/span> <\/span>&<\/span>MyString<\/span>::<\/span>operator=<\/span>(<\/span>const<\/span> <\/span>MyString<\/span> <\/span>&<\/span>s<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"MyString assignment operator"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>if<\/span> (<\/span>this<\/span> != &s)<\/span>  \/\/ Beware of x = x !!! WHY??<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>"deleting: "<\/span><\/span>\n              << (<\/span>void<\/span> *)p << <\/span>std<\/span>::endl;<\/span><\/span>\n    <\/span>delete<\/span> <\/span>[]<\/span> p;<\/span><\/span>\n    p = <\/span>new<\/span> <\/span>char<\/span>[(size = <\/span>s<\/span>.<\/span>size<\/span>) + <\/span>1<\/span>];<\/span><\/span>\n    <\/span>strcpy<\/span>(p, <\/span>s<\/span>.<\/span>p<\/span>);<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>return<\/span> *<\/span>this<\/span>;<\/span>  \/\/ Important!  WHY??<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
                      \n
                      \n
                      … and with no changes to the test program:<\/p>\n\n\n\n
                      <\/path><\/path><\/svg><\/span>
                      \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Initialization vs. Assignment<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"MyString.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  MyString <\/span>s1<\/span>(<\/span>"Hello!"<\/span>);<\/span><\/span>\n  MyString <\/span>s2<\/span>(<\/span>"Goodbye"<\/span>);<\/span><\/span>\n<\/span>\n  <\/span>std<\/span>::cout << <\/span>"s1: "<\/span>; <\/span>s1<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"s2: "<\/span>; <\/span>s2<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span><\/span>\n  s1 = s2;<\/span>    \/\/ Assign s2 to s1<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"s1: "<\/span>; <\/span>s1<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"s2: "<\/span>; <\/span>s2<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                      \n
                      Here is what it now produces:<\/p>\n\n\n\n
                      s1: MyString p = 0x60000000c040; size = 6; \"Hello!\"\ns2: MyString p = 0x60000000c050; size = 7; \"Goodbye\"\n\nMyString assignment operator\ndeleting: 0x60000000c040\ns1: MyString p = 0x60000000c040; size = 7; \"Goodbye\"\ns2: MyString p = 0x60000000c050; size = 7; \"Goodbye\"\ndeleting MyString: 0x60000000c050\ndeleting MyString: 0x60000000c040\nProgram ended with exit code: 0<\/code><\/pre>\n\n\n\n
                      Voila!<\/p>\n\n\n\n
                      No double deallocation! All instances deallocated properly!<\/p>\n<\/div>\n<\/div>\n\n\n\n
                      In this way, the assignment operator may be overloaded for a class.<\/em><\/p>\n\n\n\n
                      <\/span>Other Operators<\/span><\/h2>\n\n\n\n
                      You can overload the following operators in C++:<\/p>\n\n\n\n
                      +<\/td>–<\/td>*<\/td>\/<\/td>%<\/td>^<\/td>&<\/td>|<\/td>~<\/td><\/tr>
                      !<\/td>=<\/td><<\/td>><\/td>+=<\/td>-=<\/td>*=<\/td>\/=<\/td>%=<\/td><\/tr>
                      ^=<\/td>&=<\/td>|=<\/td><<<\/td>>><\/td><<=<\/td>>>=<\/td>==<\/td>!=<\/td><\/tr>
                      <=<\/td>>=<\/td>&&<\/td>||<\/td>++<\/td>—<\/td>,<\/td>->*<\/td>-><\/td><\/tr>
                      ()<\/td>[]<\/td>new<\/td>delete<\/td>new[]<\/td>delete[]<\/td><\/td><\/td><\/td><\/tr><\/tbody><\/table>
                      Where () is the function call operator, and [] is the subscript operator.<\/figcaption><\/figure>\n\n\n\n
                      You can overload both the unary and binary forms of the following operators:<\/p>\n\n\n\n
                      +<\/td>–<\/td>*<\/td>&<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
                      You cannot overload the following operators:<\/p>\n\n\n\n
                      .<\/td>.*<\/td>::<\/td>?:<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
                      Operator functions are not usually called directly, but they can be, using the following syntax:<\/p>\n\n\n\n
                      Complex z = a.operator+(b);<\/strong><\/code><\/pre>\n\n\n\n
                      Here are its restrictions:<\/p>\n\n\n\n
                        \n
                      • An overloaded operator may not have default arguments<\/em>.<\/li>\n\n\n\n
                      • The operators for built-in types may not be overridden<\/em>.<\/li>\n\n\n\n
                      • You cannot introduce an operator that is not already part of C++<\/em>.<\/li>\n\n\n\n
                      • You cannot change the precedence or the associativity<\/em> of the operators.<\/li>\n<\/ul>\n\n\n\n
                        <\/span>Unary and Binary Operators<\/span><\/h3>\n\n\n\n
                        A unary operator<\/em> ‘@<\/strong>‘ (the @<\/strong> represents the actual operator) may be declared:<\/p>\n\n\n\n
                        As a non-static member function taking zero arguments<\/em>:<\/p>\n\n\n\n
                        x.operator@()<\/strong><\/code><\/pre>\n\n\n\n
                        As a non-member function taking one argument<\/em>:<\/p>\n\n\n\n
                        operator@(x)<\/strong><\/code><\/pre>\n\n\n\n
                        A binary operator<\/em> ‘@<\/strong>‘ may be declared:<\/p>\n\n\n\n
                          \n
                        • As a non-static member function taking one argument<\/em>:<\/li>\n<\/ul>\n\n\n\n
                          x.operator@(y)<\/strong><\/code><\/pre>\n\n\n\n
                            \n
                          • As a non-member function taking two arguments<\/em>:<\/li>\n<\/ul>\n\n\n\n
                            operator@(x,y)<\/strong><\/code><\/pre>\n\n\n\n
                            When a non-static member function<\/em> is used, no user-defined conversions will be applied to <\/em>x<\/em><\/strong> for matching purposes<\/em>. 
                            They will be applied for non-member functions.<\/em><\/p>\n\n\n\n
                            <\/span>Member or Non-Member Operator?<\/span><\/h3>\n\n\n\n
                            Here’s how to decide whether to use a member or non-member operator overload:<\/p>\n\n\n\n
                              \n
                            • Do you have access to the source for the class, and can you change it? (i.e. does it belong to you alone?)\n
                                \n
                              • If not, the operator must be a non-member function<\/em>.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                              • If the operator is one of:    = <\/strong> <\/strong>[] <\/strong> <\/strong>() <\/strong> <\/strong>-><\/strong>\n
                                  \n
                                • It must be a member function<\/em>.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                • If it’s a non-member function<\/em>:\n
                                    \n
                                  • it can’t use this<\/strong>, explicitly or implicitly.<\/li>\n\n\n\n
                                  • it has no access to the private parts of the class (but see later…) <\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                  • If it’s a member-function<\/em>:\n
                                      \n
                                    • implicit conversions will not be applied to the left-hand side operand<\/em>.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                                      Here, operator-<\/strong> is a non-member:<\/p>\n\n\n\n
                                      \n
                                      \n
                                      Here’s an example of an operator-<\/strong> implementation as a non-member<\/em>:<\/p>\n\n\n\n
                                      <\/path><\/path><\/svg><\/span>
                                      \/\/<\/span><\/span>\n\/\/  Point.h<\/span><\/span>\n\/\/  Member or Non-Member Operator<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Point_h<\/span><\/span>\n#define<\/span> Point_h<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Location<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Location<\/span>(<\/span>int<\/span> <\/span>xvalue<\/span>, <\/span>int<\/span> <\/span>yvalue<\/span>);<\/span><\/span>\n  <\/span><\/span>\n  <\/span>int<\/span> x, y;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Point<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Point<\/span>(<\/span>int<\/span> <\/span>xvalue<\/span>, <\/span>int<\/span> <\/span>yvalue<\/span>);<\/span><\/span>\n  <\/span>Point<\/span>(<\/span>const<\/span> <\/span>Location<\/span> <\/span>&<\/span>loc<\/span>);<\/span><\/span>\n  <\/span><\/span>\n  <\/span>int<\/span> x, y;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n\/\/ non-member function (reverses the y coordinate)<\/span><\/span>\nextern<\/span> <\/span>Point<\/span> <\/span>operator-<\/span>(<\/span>const<\/span> <\/span>Point<\/span> <\/span>&<\/span>rhs<\/span>);<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Point_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                      \n
                                      <\/path><\/path><\/svg><\/span>
                                      \/\/<\/span><\/span>\n\/\/  Point.cpp<\/span><\/span>\n\/\/  Member or Non-Member Operator<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Point.h"<\/span><\/span>\n<\/span>\nLocation<\/span>::<\/span>Location<\/span>(<\/span>int<\/span> xvalue, <\/span>int<\/span> yvalue)<\/span><\/span>\n{<\/span><\/span>\n  x = xvalue;<\/span><\/span>\n  y = yvalue;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nPoint<\/span>::<\/span>Point<\/span>(<\/span>int<\/span> xvalue, <\/span>int<\/span> yvalue)<\/span><\/span>\n{<\/span><\/span>\n  x = xvalue;<\/span><\/span>\n  y = yvalue;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nPoint<\/span>::<\/span>Point<\/span>(<\/span>const<\/span> Location &loc)<\/span><\/span>\n{<\/span><\/span>\n  x = <\/span>loc<\/span>.<\/span>x<\/span>; y = <\/span>loc<\/span>.<\/span>y<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ non-member function (reverses the y-coordinate)<\/span><\/span>\nPoint<\/span> <\/span>operator-<\/span>(<\/span>const<\/span> <\/span>Point<\/span> <\/span>&<\/span>rhs<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>return<\/span> <\/span>Point<\/span>(<\/span>rhs<\/span>.<\/span>x<\/span>, -<\/span>rhs<\/span>.<\/span>y<\/span>);<\/span> \/\/ Reverse y coordinate<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
                                      \n
                                      \n
                                      … and a test program:<\/p>\n\n\n\n
                                      <\/path><\/path><\/svg><\/span>
                                      \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Member or Non-Member Operator<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Point.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  Location <\/span>loc<\/span>(<\/span>50<\/span>, <\/span>25<\/span>);<\/span><\/span>\n  Point <\/span>p<\/span>(-loc);<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"p.(x,y): ("<\/span> << <\/span>p<\/span>.<\/span>x<\/span><\/span>\n            << <\/span>','<\/span> << <\/span>p<\/span>.<\/span>y<\/span> << <\/span>')'<\/span><\/span>\n            << <\/span>std<\/span>::endl;<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                      \n
                                      which produces the following output:<\/p>\n\n\n\n
                                      p.(x,y): (50,-25)\nProgram ended with exit code: 0<\/code><\/pre>\n\n\n\n
                                      In other words, it did what it was supposed to do – reverse the value of the y coordinate.<\/p>\n<\/div>\n<\/div>\n\n\n\n
                                      Now, let’s implement operator-<\/strong> as a member<\/em>:<\/p>\n\n\n\n
                                      \n
                                      \n
                                      Here’s an example of an operator-<\/strong> implementation as a member:<\/p>\n\n\n\n
                                      <\/path><\/path><\/svg><\/span>
                                      \/\/<\/span><\/span>\n\/\/  Point.h<\/span><\/span>\n\/\/  Member or Non-Member Operator<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Point_h<\/span><\/span>\n#define<\/span> Point_h<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Location<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Location<\/span>(<\/span>int<\/span> <\/span>xvalue<\/span>, <\/span>int<\/span> <\/span>yvalue<\/span>);<\/span><\/span>\n  <\/span><\/span>\n  <\/span>int<\/span> x, y;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Point<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Point<\/span>(<\/span>int<\/span> <\/span>xvalue<\/span>, <\/span>int<\/span> <\/span>yvalue<\/span>);<\/span><\/span>\n  <\/span>Point<\/span>(<\/span>const<\/span> <\/span>Location<\/span> <\/span>&<\/span>loc<\/span>);<\/span><\/span>\n  <\/span><\/span>\n  <\/span>Point<\/span> <\/span>operator-<\/span>();<\/span> \/\/ member function<\/span><\/span>\n  <\/span><\/span>\n  <\/span>int<\/span> x, y;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Point_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                      \n
                                      <\/path><\/path><\/svg><\/span>
                                      \/\/<\/span><\/span>\n\/\/  Point.cpp<\/span><\/span>\n\/\/  Member or Non-Member Operator<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Point.h"<\/span><\/span>\n<\/span>\nLocation<\/span>::<\/span>Location<\/span>(<\/span>int<\/span> xvalue, <\/span>int<\/span> yvalue)<\/span><\/span>\n{<\/span><\/span>\n  x = xvalue;<\/span><\/span>\n  y = yvalue;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nPoint<\/span>::<\/span>Point<\/span>(<\/span>int<\/span> xvalue, <\/span>int<\/span> yvalue)<\/span><\/span>\n{<\/span><\/span>\n  x = xvalue;<\/span><\/span>\n  y = yvalue;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nPoint<\/span>::<\/span>Point<\/span>(<\/span>const<\/span> Location &loc)<\/span><\/span>\n{<\/span><\/span>\n  x = <\/span>loc<\/span>.<\/span>x<\/span>; y = <\/span>loc<\/span>.<\/span>y<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ member function (reverses the y-coordinate)<\/span><\/span>\nPoint<\/span> <\/span>Point<\/span>::<\/span>operator-<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>return<\/span> <\/span>Point<\/span>(x, -y);<\/span> \/\/ Reverse y coordinate<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
                                      \n
                                      \n
                                      … and the exact same test program:<\/p>\n\n\n\n
                                      <\/path><\/path><\/svg><\/span>
                                      \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Member or Non-Member Operator<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Point.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  Location <\/span>loc<\/span>(<\/span>50<\/span>, <\/span>25<\/span>);<\/span><\/span>\n  Point <\/span>p<\/span>(-loc);<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"p.(x,y): ("<\/span> << <\/span>p<\/span>.<\/span>x<\/span><\/span>\n            << <\/span>','<\/span> << <\/span>p<\/span>.<\/span>y<\/span> << <\/span>')'<\/span><\/span>\n            << <\/span>std<\/span>::endl;<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                      \n
                                      Now gives a compile time error at line 14<\/p>\n\n\n\n
                                      main.cpp:14:11 Invalid argument type 'Location' to unary expression\n<\/code><\/pre>\n\n\n\n
                                      In other words, a member function implementation does not work for this case.<\/p>\n<\/div>\n<\/div>\n\n\n\n
                                      For unary<\/em> operators, this can be a good thing!  So:<\/p>\n\n\n\n
                                      Recommendation: implement unary operators as member functions, if possible.<\/em><\/strong><\/p>\n\n\n\n
                                      For binary operators, it depends on whether you wish the left-hand operand<\/em> to be subject to conversion:<\/p>\n\n\n\n
                                      Complex c;\nc += 5;<\/strong>\t\t\t\t    \/\/ Convert c?\n\nComplex d = c + 1.0;\nComplex e = 1.0 + c<\/strong>;\t\/\/ Convert 1.0?\n<\/code><\/pre>\n\n\n\n
                                      <\/span>Summary of Recommendations<\/span><\/h3>\n\n\n\n
                                      Operator<\/th>Recommendation<\/th><\/tr><\/thead>
                                      All unary operators<\/td>member<\/em><\/td><\/tr>
                                      =   []   ()   -><\/td>must be member<\/em><\/td><\/tr>
                                      +=  -=  \/=  *=  ^=  &=
                                      |=  ~= %= >>= <<=<\/td>                                      		member<\/em><\/td><\/tr>
                                      All other binary operators<\/td>non-member<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
                                      <\/span>Why the Assignment Operator is Special<\/span><\/h3>\n\n\n\n
                                      The (binary) assignment operator, operator=<\/strong>, is special, because:<\/p>\n\n\n\n
                                        \n
                                      • It must be a (non-static) member function of its class<\/em>.<\/li>\n\n\n\n
                                      • It is the only operator that is not inherited<\/em>:
                                        “Assignment has a useful and necessary generalization across all classes (memberwise copy).  No other operator has that.  Assignment resembles constructors and destructors more than it resembles operators such as + and += .”<\/em><\/strong> <\/em>
                                        [C++ ARM, p. 335]<\/strong><\/li>\n<\/ul>\n\n\n\n
                                        If you do not write an operator=<\/strong> function for a class, the compiler will generate one for that class<\/em>.  The generated function will do a memberwise (shallow) copy<\/em>.<\/p>\n\n\n\n
                                        <\/span>Subscripting, or operator[]<\/span><\/h2>\n\n\n\n
                                        Subscripting:<\/p>\n\n\n\n
                                        mumble[5]<\/strong><\/code><\/pre>\n\n\n\n
                                        is considered to be a binary operator<\/em>. <\/em>The expression:<\/p>\n\n\n\n
                                        x[y]<\/strong><\/code><\/pre>\n\n\n\n
                                        is interpreted as:<\/p>\n\n\n\n
                                        x.operator[](y)<\/strong><\/code><\/pre>\n\n\n\n
                                        Looks a bit strange, doesn’t it?<\/p>\n\n\n\n
                                        In order for subscripting to be valid on both sides of an assignment operator:<\/p>\n\n\n\n
                                        x[5] = y[3];<\/strong><\/code><\/pre>\n\n\n\n
                                        operator[]<\/strong> must return a reference <\/em>to the appropriate type.<\/p>\n\n\n\n
                                          \n
                                        • NOTE<\/strong>: operator[]<\/strong> must be a non-static class member function<\/em>.<\/li>\n<\/ul>\n\n\n\n
                                          <\/span>Example: A Vector Class<\/span><\/h3>\n\n\n\n
                                          \n
                                          \n
                                          Here’s an example of an operator<\/strong>[] implementation as a member(required):<\/p>\n\n\n\n
                                          <\/path><\/path><\/svg><\/span>
                                          \/\/<\/span><\/span>\n\/\/  Vector.h<\/span><\/span>\n\/\/  Subscript Operator<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Vector_h<\/span><\/span>\n#define<\/span> Vector_h<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Vector<\/span> <\/span>\/\/ A vector of ints<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  \/\/ Constructors & destructors<\/span><\/span>\n  <\/span>explicit<\/span> <\/span>Vector<\/span>(<\/span>const<\/span> <\/span>int<\/span> <\/span>elements<\/span> = <\/span>10<\/span>);<\/span><\/span>\n  <\/span>Vector<\/span>(<\/span>const<\/span> <\/span>Vector<\/span> <\/span>&<\/span>source<\/span>);<\/span><\/span>\n  <\/span>Vector<\/span>(<\/span>const<\/span> <\/span>int<\/span> <\/span>source<\/span>[],<\/span><\/span>\n         <\/span>const<\/span> <\/span>int<\/span> <\/span>elements<\/span>);<\/span><\/span>\n  <\/span>~Vector<\/span>() { <\/span>delete<\/span> <\/span>[]<\/span> m_p; }<\/span><\/span>\n<\/span>\n  <\/span>int<\/span> <\/span>getElementCount<\/span>() { <\/span>return<\/span> m_elems; }<\/span><\/span>\n  <\/span><\/span>\n  \/\/ Subscript operator overload<\/span><\/span>\n  <\/span>int<\/span> <\/span>&<\/span>operator[]<\/span>(<\/span>const<\/span> <\/span>int<\/span> <\/span>i<\/span>);<\/span><\/span>\n  <\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>int<\/span> *m_p;<\/span>    \/\/ Ptr to array<\/span><\/span>\n  <\/span>int<\/span>  m_elems;<\/span>  \/\/ Alloc. count<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Vector_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                          \n
                                          <\/path><\/path><\/svg><\/span>
                                          \/\/<\/span><\/span>\n\/\/  Vector.cpp<\/span><\/span>\n\/\/  Subscript Operator<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Vector.h"<\/span><\/span>\n<\/span>\nVector<\/span>::<\/span>Vector<\/span>(<\/span>const<\/span> <\/span>int<\/span> elements)<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Allocate space for elements<\/span><\/span>\n  m_p = <\/span>new<\/span> <\/span>int<\/span>[m_elems = elements];<\/span><\/span>\n  \/\/ Set all elements to 0<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i = <\/span>0<\/span>; i < m_elems; i++)<\/span><\/span>\n    <\/span>m_p<\/span>[i] = <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nVector<\/span>::<\/span>Vector<\/span>(<\/span>const<\/span> Vector &source)<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Allocate space for elements<\/span><\/span>\n  m_p = <\/span>new<\/span> <\/span>int<\/span>[m_elems = <\/span>source<\/span>.<\/span>m_elems<\/span>];<\/span><\/span>\n  \/\/ Copy values from source elements<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i = <\/span>0<\/span>; i < m_elems; i++)<\/span><\/span>\n    <\/span>m_p<\/span>[i] = <\/span>source<\/span>.<\/span>m_p<\/span>[i];<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nVector<\/span>::<\/span>Vector<\/span>(<\/span>const<\/span> <\/span>int<\/span> source[],<\/span><\/span>\n               <\/span>const<\/span> <\/span>int<\/span> elements)<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Allocate space for elements<\/span><\/span>\n  m_p = <\/span>new<\/span> <\/span>int<\/span>[m_elems = elements];<\/span><\/span>\n  \/\/ Copy values from source elements<\/span><\/span>\n  \/\/ (assuming that source is properly sized)<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i = <\/span>0<\/span>; i < m_elems; i++)<\/span><\/span>\n    <\/span>m_p<\/span>[i] = <\/span>source<\/span>[i];<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Subscript operator overload<\/span><\/span>\nint<\/span> <\/span>&<\/span>Vector<\/span>::<\/span>operator[]<\/span>(<\/span>const<\/span> <\/span>int<\/span> <\/span>i<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  \/\/ Do bounds checking...<\/span><\/span>\n  <\/span>if<\/span> ( (i < <\/span>0<\/span>) || (i >= m_elems) )<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cerr << <\/span>"Illegal Vector index: "<\/span><\/span>\n              << i << <\/span>" (max: "<\/span><\/span>\n              << (m_elems - <\/span>1<\/span>) << <\/span>')'<\/span><\/span>\n              << <\/span>std<\/span>::endl;<\/span><\/span>\n    <\/span>exit<\/span>(<\/span>1<\/span>);<\/span>  \/\/ Abrupt exit!<\/span><\/span>\n  }<\/span><\/span>\n  \/\/ We're within bounds<\/span><\/span>\n  <\/span>return<\/span> <\/span>m_p<\/span>[i];<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
                                          \n
                                          \n
                                          … and a test program:<\/p>\n\n\n\n
                                          <\/path><\/path><\/svg><\/span>
                                          \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Subscript Operator<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/21\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Vector.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  Vector v1;<\/span><\/span>\n  Vector v2;<\/span><\/span>\n  <\/span>int<\/span> i;<\/span><\/span>\n<\/span>\n  <\/span>for<\/span> (i = <\/span>0<\/span>; i < <\/span>v1<\/span>.<\/span>getElementCount<\/span>(); i++)<\/span><\/span>\n    <\/span>v1<\/span>[i] = i;<\/span><\/span>\n  <\/span>for<\/span> (i = <\/span>0<\/span>; i < <\/span>v2<\/span>.<\/span>getElementCount<\/span>(); i++)<\/span><\/span>\n    <\/span>v2<\/span>[i] = i*i;<\/span><\/span>\n  <\/span>for<\/span> (i = <\/span>0<\/span>; i < <\/span>v1<\/span>.<\/span>getElementCount<\/span>(); i++)<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>v1<\/span>[i] << <\/span>","<\/span>;<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>for<\/span> (i = <\/span>0<\/span>; i < <\/span>v2<\/span>.<\/span>getElementCount<\/span>(); i++)<\/span><\/span>\n    <\/span>std<\/span>::cout << i << <\/span>" squared = "<\/span><\/span>\n              << <\/span>v2<\/span>[i] << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                          \n
                                          which produces the following output:<\/p>\n\n\n\n
                                          0,1,2,3,4,5,6,7,8,9,\n0 squared = 0\n1 squared = 1\n2 squared = 4\n3 squared = 9\n4 squared = 16\n5 squared = 25\n6 squared = 36\n7 squared = 49\n8 squared = 64\n9 squared = 81\nProgram ended with exit code: 0<\/code><\/pre>\n\n\n\n
                                          YAY!<\/p>\n<\/div>\n<\/div>\n\n\n\n
                                          <\/span>Function calls: operator()<\/span><\/h2>\n\n\n\n
                                          A function call:<\/p>\n\n\n\n
                                          expression(expression-list)<\/strong><\/code><\/pre>\n\n\n\n
                                          can be interpreted as a binary operator with the expression<\/strong> as the left operand and the expression-list<\/strong> as the right operand. For example:<\/p>\n\n\n\n
                                          f(x,y,z)<\/strong><\/code><\/pre>\n\n\n\n
                                          can be interpreted as:<\/p>\n\n\n\n
                                          f.operator()(x,y,z)<\/strong><\/code><\/pre>\n\n\n\n
                                          Is this syntax getting weirder, or what?<\/p>\n\n\n\n
                                          Note that operator()<\/strong> must be a non-static member function<\/em>.<\/p>\n\n\n\n
                                          <\/span>Uses for operator()<\/span><\/h3>\n\n\n\n
                                          Here’s an example. <\/p>\n\n\n\n
                                          \n
                                          \n
                                          A Matrix class that uses operator() as a convenient way of extracting a value from a matrix, given its row and column:<\/p>\n\n\n\n
                                          <\/path><\/path><\/svg><\/span>
                                          \/\/<\/span><\/span>\n\/\/  Matrix.hpp<\/span><\/span>\n\/\/  Function Call Overloads<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Dynamic matrix of double values<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/22\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Matrix_hpp<\/span><\/span>\n#define<\/span> Matrix_hpp<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Matrix<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  \/\/ Constructors<\/span><\/span>\n  <\/span>Matrix<\/span>(<\/span>int<\/span> <\/span>rows<\/span>, <\/span>int<\/span> <\/span>cols<\/span>, <\/span>double<\/span> <\/span>*<\/span>data<\/span>[] = <\/span>0<\/span>);<\/span><\/span>\n  \/\/ Destructor<\/span><\/span>\n  <\/span>~Matrix<\/span>();<\/span><\/span>\n  \/\/ Overloaded operators<\/span><\/span>\n  <\/span>Matrix<\/span>&<\/span> <\/span>operator=<\/span>(<\/span>const<\/span> <\/span>Matrix<\/span>&<\/span> <\/span>m<\/span>);<\/span><\/span>\n  <\/span>Matrix<\/span>&<\/span> <\/span>operator+=<\/span>(<\/span>Matrix<\/span>&<\/span> <\/span>m<\/span>);<\/span><\/span>\n  <\/span><\/span>\n  \/\/ overloaded function operator<\/span><\/span>\n  <\/span>double&<\/span> <\/span>operator()<\/span>(<\/span>int<\/span> <\/span>i<\/span>, <\/span>int<\/span> <\/span>j<\/span>);<\/span><\/span>\n  <\/span><\/span>\n  <\/span>int<\/span> <\/span>getRows<\/span>() { <\/span>return<\/span> m_rows; }<\/span><\/span>\n  <\/span>int<\/span> <\/span>getColumns<\/span>() { <\/span>return<\/span> m_cols; }<\/span><\/span>\n  <\/span><\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>();<\/span><\/span>\nprivate:<\/span><\/span>\n  \/\/ Copy constructor (private, and not implemented)<\/span><\/span>\n  <\/span>Matrix<\/span>(<\/span>const<\/span> <\/span>Matrix<\/span>&<\/span> <\/span>src<\/span>);<\/span><\/span>\n<\/span>\n  <\/span>int<\/span> m_cols, m_rows;<\/span><\/span>\n  <\/span>double<\/span> **m_p;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Matrix_hpp *\/<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
                                          … and a test program:<\/p>\n\n\n\n
                                          <\/path><\/path><\/svg><\/span>
                                          \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Function Call Overloads<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/22\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Matrix.hpp"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  <\/span>double<\/span> data1[] = { <\/span>1<\/span>, <\/span>2<\/span>, <\/span>3<\/span>, <\/span>4<\/span>, <\/span>5<\/span> };<\/span><\/span>\n  <\/span>double<\/span> data2[] = { <\/span>6<\/span>, <\/span>7<\/span>, <\/span>8<\/span>, <\/span>9<\/span>, <\/span>10<\/span> };<\/span><\/span>\n  <\/span>double<\/span> data3[] = { <\/span>11<\/span>, <\/span>12<\/span>, <\/span>13<\/span>, <\/span>14<\/span>, <\/span>15<\/span> };<\/span><\/span>\n  <\/span>double<\/span> *data[] = { data1, data2, data3 };<\/span><\/span>\n  <\/span><\/span>\n  Matrix <\/span>m1<\/span>(<\/span>3<\/span>, <\/span>5<\/span>, data);<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"m1 contains: "<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>m1<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"element (1,3) of m1 is: "<\/span><\/span>\n            << <\/span>m1<\/span>(<\/span>1<\/span>,<\/span>3<\/span>) << <\/span>std<\/span>::endl;<\/span><\/span>\n<\/span>\n  Matrix <\/span>m2<\/span>(<\/span>8<\/span>, <\/span>3<\/span>);<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> row = <\/span>0<\/span>; row < <\/span>m2<\/span>.<\/span>getRows<\/span>(); row++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>for<\/span> (<\/span>int<\/span> col = <\/span>0<\/span>; col < <\/span>m2<\/span>.<\/span>getColumns<\/span>(); col++)<\/span><\/span>\n    {<\/span><\/span>\n      <\/span>m2<\/span>(row, col) = row*col;<\/span><\/span>\n    }<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"m2 contains: "<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>m2<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
                                          It produces the following output:<\/p>\n\n\n\n
                                          m1 contains: \n[0]: 1 2 3 4 5\n[1]: 6 7 8 9 10\n[2]: 11 12 13 14 15\nelement (1,3) of m1 is: 9\nm2 contains: \n[0]: 0 0 0\n[1]: 0 1 2\n[2]: 0 2 4\n[3]: 0 3 6\n[4]: 0 4 8\n[5]: 0 5 10\n[6]: 0 6 12\n[7]: 0 7 14\nProgram ended with exit code: 0<\/code><\/pre>\n<\/div>\n\n\n\n
                                          \n
                                          <\/path><\/path><\/svg><\/span>
                                          \/\/<\/span><\/span>\n\/\/  Matrix.cpp<\/span><\/span>\n\/\/  Function Call Overloads<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/22\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span><assert.h><\/span><\/span>\n#include<\/span> <\/span>"Matrix.hpp"<\/span><\/span>\n<\/span>\n\/\/ Constructors<\/span><\/span>\nMatrix<\/span>::<\/span>Matrix<\/span>(<\/span>int<\/span> rows, <\/span>int<\/span> cols,<\/span><\/span>\n               <\/span>double<\/span> *data[])<\/span><\/span>\n{<\/span><\/span>\n  m_cols = cols;<\/span><\/span>\n  m_rows = rows;<\/span><\/span>\n  m_p = <\/span>new<\/span> <\/span>double<\/span>*[rows];<\/span><\/span>\n  <\/span>assert<\/span>(m_p != <\/span>0<\/span>);<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> row = <\/span>0<\/span>; row < rows; row++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>m_p<\/span>[row] = <\/span>new<\/span> <\/span>double<\/span>[cols];<\/span><\/span>\n    <\/span>assert<\/span>(<\/span>m_p<\/span>[row] != <\/span>0<\/span>);<\/span><\/span>\n    <\/span>for<\/span> (<\/span>int<\/span> col = <\/span>0<\/span>; col < cols; col++)<\/span><\/span>\n    {<\/span><\/span>\n      <\/span>if<\/span> (data != <\/span>0<\/span>)<\/span><\/span>\n        <\/span>m_p<\/span>[row][col] = <\/span>data<\/span>[row][col];<\/span><\/span>\n      <\/span>else<\/span><\/span>\n        <\/span>m_p<\/span>[row][col] = <\/span>0.0<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n  }<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Destructor<\/span><\/span>\nMatrix<\/span>::~<\/span>Matrix<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> row = <\/span>0<\/span>; row < m_rows; row++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>delete<\/span> <\/span>[]<\/span> <\/span>m_p<\/span>[row];<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>delete<\/span> <\/span>[]<\/span> m_p;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Overloaded operators<\/span><\/span>\n\/\/ =<\/span><\/span>\nMatrix<\/span>&<\/span> <\/span>Matrix<\/span>::<\/span>operator=<\/span>(<\/span>const<\/span> <\/span>Matrix<\/span>&<\/span> <\/span>src<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>if<\/span> (<\/span>this<\/span> != &src)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>int<\/span> row;<\/span><\/span>\n    \/\/ Deallocate the existing matrix<\/span><\/span>\n    <\/span>for<\/span> (row = <\/span>0<\/span>; row < m_rows; row++)<\/span><\/span>\n    {<\/span><\/span>\n      <\/span>delete<\/span> <\/span>[]<\/span> <\/span>m_p<\/span>[row];<\/span><\/span>\n    }<\/span><\/span>\n    <\/span>delete<\/span> <\/span>[]<\/span> m_p;<\/span><\/span>\n    \/\/ Allocate space for the new matrix<\/span><\/span>\n    \/\/ and copy values in from source<\/span><\/span>\n    m_cols = <\/span>src<\/span>.<\/span>m_cols<\/span>;<\/span><\/span>\n    m_rows = <\/span>src<\/span>.<\/span>m_rows<\/span>;<\/span><\/span>\n    m_p = <\/span>new<\/span> <\/span>double<\/span>*[m_rows];<\/span><\/span>\n    <\/span>for<\/span> (row = <\/span>0<\/span>; row < m_rows; row++)<\/span><\/span>\n    {<\/span><\/span>\n      <\/span>m_p<\/span>[row] = <\/span>new<\/span> <\/span>double<\/span>[m_cols];<\/span><\/span>\n      <\/span>assert<\/span>(<\/span>m_p<\/span>[row] != <\/span>0<\/span>);<\/span><\/span>\n      <\/span>for<\/span> (<\/span>int<\/span> col = <\/span>0<\/span>; col < m_cols; col++)<\/span><\/span>\n      {<\/span><\/span>\n        <\/span>m_p<\/span>[row][col] = <\/span>src<\/span>.<\/span>m_p<\/span>[row][col];<\/span><\/span>\n      }<\/span><\/span>\n    }<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>return<\/span> *<\/span>this<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ +=<\/span><\/span>\nMatrix<\/span>&<\/span> <\/span>Matrix<\/span>::<\/span>operator+=<\/span>(<\/span>Matrix<\/span>&<\/span> <\/span>rhs<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  \/\/ += only meaningful on identically sized matrices<\/span><\/span>\n  <\/span>assert<\/span>( <\/span>rhs<\/span>.<\/span>m_rows<\/span> == m_rows<\/span><\/span>\n       && <\/span>rhs<\/span>.<\/span>m_cols<\/span> == m_cols );<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> row = <\/span>0<\/span>; row < m_rows; row++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>for<\/span> (<\/span>int<\/span> col = <\/span>0<\/span>; col < m_cols; col++)<\/span><\/span>\n    {<\/span><\/span>\n      <\/span>m_p<\/span>[row][col] += <\/span>rhs<\/span>.<\/span>m_p<\/span>[row][col];<\/span><\/span>\n    }<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>return<\/span> *<\/span>this<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Overloaded function operator<\/span><\/span>\n\/\/ ()<\/span><\/span>\ndouble&<\/span> <\/span>Matrix<\/span>::<\/span>operator()<\/span>(<\/span>int<\/span> <\/span>i<\/span>, <\/span>int<\/span> <\/span>j<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>assert<\/span>( i >= <\/span>0<\/span> && i < m_rows<\/span><\/span>\n       && j >= <\/span>0<\/span> && j < m_cols);<\/span><\/span>\n  <\/span>return<\/span> <\/span>m_p<\/span>[i][j];<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Print method<\/span><\/span>\nvoid<\/span> <\/span>Matrix<\/span>::<\/span>Print<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> row = <\/span>0<\/span>; row < m_rows; row++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>'['<\/span> << row << <\/span>"]:"<\/span>;<\/span><\/span>\n    <\/span>for<\/span> (<\/span>int<\/span> col = <\/span>0<\/span>; col < m_cols; col++)<\/span><\/span>\n    {<\/span><\/span>\n      <\/span>std<\/span>::cout << <\/span>' '<\/span> << <\/span>m_p<\/span>[row][col];<\/span><\/span>\n    }<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>std<\/span>::endl;<\/span><\/span>\n  }<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n<\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
                                          <\/span>Functors<\/span><\/h3>\n\n\n\n
                                          One common use of the overloaded operator() operator is to define a class as a ‘Functor’.<\/p>\n\n\n\n
                                          A Functor class is one that is designed to act like a function.<\/p>\n\n\n\n
                                          \n
                                          \n
                                          Here’s a class that encapsulates the abs operation on an int – that is, converting an int value to its absolute value:<\/p>\n\n\n\n
                                          <\/path><\/path><\/svg><\/span>
                                          \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Function Objects ('Functors')<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/22\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\n\/\/ A class designed simply to support a function call<\/span><\/span>\n\/\/ (aka a 'function object', or 'functor')<\/span><\/span>\nclass<\/span> <\/span>AbsInt<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  \/\/ Overloaded function call operator<\/span><\/span>\n  <\/span>int<\/span> <\/span>operator()<\/span>(<\/span>int<\/span> <\/span>value<\/span>)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>return<\/span> value < <\/span>0<\/span> ? -value : value;<\/span><\/span>\n  }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  AbsInt abs;<\/span><\/span>\n  <\/span>unsigned<\/span> <\/span>int<\/span> absvalue = <\/span>abs<\/span>(-<\/span>42<\/span>);<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"absvalue = "<\/span> << absvalue << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                          \n
                                          That program produces the following output:<\/p>\n\n\n\n
                                          absvalue = 42\nProgram ended with exit code: 0<\/code><\/pre>\n\n\n\n
                                          In other words, the call to abs (the instance of AbsInt), supplying the integer value -42 has returned its absolute value, 42.<\/p>\n\n\n\n
                                          \n
                                          The C++ Standard Library uses functors quite a bit. For example, it contains several function objects in the <functional><\/code> header file.<\/p>\n\n\n\n
                                          However, be aware that this area is definitely advanced C++!<\/p>\n<\/blockquote>\n<\/div>\n<\/div>\n\n\n\n
                                          <\/span>Other Uses for operator()<\/span><\/h3>\n\n\n\n
                                          Other popular uses for operator()<\/strong> are:<\/p>\n\n\n\n
                                            \n
                                          • To implement substring capability for strings.<\/li>\n\n\n\n
                                          • As an ‘iterator’ operator, to iterate through various ‘containers’.<\/li>\n\n\n\n
                                          • As a ‘call’ operator for objects that act as functions. <\/li>\n<\/ul>\n\n\n\n
                                            The C++ Standard Template Library (STL) makes heavy use of the latter two styles.<\/p>\n\n\n\n
                                            \n
                                            We’ll be talking about the C++ Standard Template Library much later. Because it uses a number of advanced C++ features, and some advanced concepts, it takes a while to figure the STL out!<\/p>\n<\/blockquote>\n\n\n\n
                                            <\/span>The Operator: operator-><\/span><\/h2>\n\n\n\n
                                            The -><\/strong> operator is considered to be a unary<\/em> operator.<\/p>\n\n\n\n
                                            An expression:<\/p>\n\n\n\n
                                            x->m<\/strong><\/code><\/pre>\n\n\n\n
                                            is interpreted as:<\/p>\n\n\n\n
                                            (x.operator->())->m<\/strong><\/code><\/pre>\n\n\n\n
                                            for a class object of type T<\/strong> if :<\/p>\n\n\n\n
                                            T::operator->()<\/strong><\/code><\/pre>\n\n\n\n
                                            exists.<\/p>\n\n\n\n
                                            So, operator->()<\/strong> must return:<\/p>\n\n\n\n
                                              \n
                                            • a pointer to a class that has a member m<\/strong>, or:<\/li>\n\n\n\n
                                            • an object of, or reference to, a class for which operator->()<\/strong> is defined.<\/li>\n<\/ul>\n\n\n\n
                                              \n
                                              More on this later…<\/strong><\/p>\n<\/blockquote>\n\n\n\n
                                              <\/span>The Operators: operator++ and operator–<\/span><\/h2>\n\n\n\n
                                              The prefix and postfix increment and decrement operators are implemented by the functions:<\/p>\n\n\n\n
                                              operator++\noperator--<\/strong><\/code><\/pre>\n\n\n\n
                                              For example:<\/p>\n\n\n\n
                                              <\/path><\/path><\/svg><\/span>
                                              class<\/span> <\/span>Foo<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Foo<\/span> <\/span>&<\/span>operator++<\/span>();<\/span>\t   \/\/ ++a<\/span><\/span>\n  <\/span>Foo<\/span> <\/span>&<\/span>operator++<\/span>(<\/span>int<\/span>);<\/span>  \/\/ a++<\/span><\/span>\n  <\/span>Foo<\/span> <\/span>&<\/span>operator--<\/span>();<\/span>\t   \/\/ --a<\/span><\/span>\n  <\/span>Foo<\/span> <\/span>&<\/span>operator--<\/span>(<\/span>int<\/span>);<\/span>  \/\/ a--<\/span><\/span>\n  \/\/ ...  (Why return Foo & ???)<\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
                                              \n
                                              The presence of the int<\/strong> argument is C++’s way of distinguishing between the postfix and prefix versions. 
                                              The value passed in this int<\/strong> will be 0<\/strong>.<\/p>\n<\/blockquote>\n\n\n\n
                                              <\/span>The Addition Operator: operator+<\/span><\/h2>\n\n\n\n
                                              Let’s see how to override the (binary) addition operator:<\/p>\n\n\n\n
                                              \n
                                              \n
                                              Here’s a Complex class that implements the addition operator, operator+ :<\/p>\n\n\n\n
                                              <\/path><\/path><\/svg><\/span>
                                              \/\/<\/span><\/span>\n\/\/  Complex.hpp<\/span><\/span>\n\/\/  Addition Operator<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/22\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Complex_hpp<\/span><\/span>\n#define<\/span> Complex_hpp<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Complex<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Complex<\/span>(<\/span>double<\/span> <\/span>real<\/span> = <\/span>0.0<\/span>, <\/span>double<\/span> <\/span>imag<\/span> = <\/span>0.0<\/span>);<\/span><\/span>\n  <\/span>Complex<\/span> <\/span>operator+<\/span>(<\/span>const<\/span> <\/span>Complex<\/span> <\/span>&<\/span>rhs<\/span>);<\/span><\/span>\n  <\/span>~Complex<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>();<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>double<\/span> m_real, m_imag;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Complex_hpp *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                              \n
                                              <\/path><\/path><\/svg><\/span>
                                              \/\/<\/span><\/span>\n\/\/  Complex.cpp<\/span><\/span>\n\/\/  Addition Operator<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/22\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Complex.hpp"<\/span><\/span>\n<\/span>\nComplex<\/span>::<\/span>Complex<\/span>(<\/span>double<\/span> real, <\/span>double<\/span> imag)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"In constructor for "<\/span> << <\/span>this<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  m_real = real;<\/span><\/span>\n  m_imag = imag;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nComplex<\/span> <\/span>Complex<\/span>::<\/span>operator+<\/span>(<\/span>const<\/span> <\/span>Complex<\/span> <\/span>&<\/span>rhs<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Assigning values from "<\/span> << &rhs << <\/span>" to "<\/span> << <\/span>this<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>return<\/span> <\/span>Complex<\/span>(m_real + <\/span>rhs<\/span>.<\/span>m_real<\/span>,<\/span><\/span>\n                 m_imag + <\/span>rhs<\/span>.<\/span>m_imag<\/span>);<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nComplex<\/span>::~<\/span>Complex<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"In Destructor for "<\/span> << <\/span>this<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>Complex<\/span>::<\/span>Print<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Complex: ["<\/span><\/span>\n            << m_real << <\/span>", "<\/span> << m_imag << <\/span>"]"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
                                              \n
                                              \n
                                              … and a test program:<\/p>\n\n\n\n
                                              <\/path><\/path><\/svg><\/span>
                                              \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Addition Operator<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/22\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Complex.hpp"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Complex x(2.0, 3.0);"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  Complex <\/span>x<\/span>(<\/span>2.0<\/span>, <\/span>3.0<\/span>);<\/span>  \/\/ ???<\/span><\/span>\n  <\/span>x<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Complex y(1.0, 2.0);"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  Complex <\/span>y<\/span>(<\/span>1.0<\/span>, <\/span>2.0<\/span>);<\/span>  \/\/ ???<\/span><\/span>\n  <\/span>y<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Complex z;"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  Complex z;<\/span>            \/\/ ???<\/span><\/span>\n  <\/span>z<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Operations..."<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"z = y;"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  z = y;<\/span>        \/\/ ???<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"z: "<\/span>; <\/span>z<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"z = 1.0;"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  z = <\/span>1.0<\/span>;<\/span>        \/\/ ???<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"z: "<\/span>; <\/span>z<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"z = x + y;"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  z = x + y;<\/span>      \/\/ ???<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"z: "<\/span>; <\/span>z<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"z = y + 3;"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  z = y + <\/span>3.0<\/span>;<\/span>      \/\/ ???<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"z: "<\/span>; <\/span>z<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                              \n
                                              which produces the following output:<\/p>\n\n\n\n
                                              Complex x(2.0, 3.0);\nIn constructor for 0x7ff7bfeff0c0\nComplex: [2, 3]\nComplex y(1.0, 2.0);\nIn constructor for 0x7ff7bfeff0a0\nComplex: [1, 2]\nComplex z;\nIn constructor for 0x7ff7bfeff090\nComplex: [0, 0]\nOperations...\nz = y;\nz: Complex: [1, 2]\nz = 1.0;\nIn constructor for 0x7ff7bfeff080\nIn Destructor for 0x7ff7bfeff080\nz: Complex: [1, 0]\nz = x + y;\nAssigning values from 0x7ff7bfeff0a0 to 0x7ff7bfeff0c0\nIn constructor for 0x7ff7bfeff070\nIn Destructor for 0x7ff7bfeff070\nz: Complex: [3, 5]\nz = y + 3;\nIn constructor for 0x7ff7bfeff050\nAssigning values from 0x7ff7bfeff050 to 0x7ff7bfeff0a0\nIn constructor for 0x7ff7bfeff060\nIn Destructor for 0x7ff7bfeff060\nIn Destructor for 0x7ff7bfeff050\nz: Complex: [4, 2]\nIn Destructor for 0x7ff7bfeff090\nIn Destructor for 0x7ff7bfeff0a0\nIn Destructor for 0x7ff7bfeff0c0\nProgram ended with exit code: 0<\/code><\/pre>\n\n\n\n
                                              Given this, can you deduce what member functions are invoked in the program?<\/p>\n<\/div>\n<\/div>\n\n\n\n
                                              <\/span>What if we reverse the expressions of the addition?<\/span><\/h3>\n\n\n\n
                                              \n
                                              \n
                                              Here’s the test program, with an additional line at the end:<\/p>\n\n\n\n
                                              <\/path><\/path><\/svg><\/span>
                                              \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Addition Operator<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/22\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Complex.hpp"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[]) <\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Complex x(2.0, 3.0);"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  Complex <\/span>x<\/span>(<\/span>2.0<\/span>, <\/span>3.0<\/span>);<\/span>  \/\/ ???<\/span><\/span>\n  <\/span>x<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Complex y(1.0, 2.0);"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  Complex <\/span>y<\/span>(<\/span>1.0<\/span>, <\/span>2.0<\/span>);<\/span>  \/\/ ???<\/span><\/span>\n  <\/span>y<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Complex z;"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  Complex z;<\/span>            \/\/ ???<\/span><\/span>\n  <\/span>z<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Operations..."<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"z = y;"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  z = y;<\/span>        \/\/ ???<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"z: "<\/span>; <\/span>z<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"z = 1.0;"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  z = <\/span>1.0<\/span>;<\/span>        \/\/ ???<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"z: "<\/span>; <\/span>z<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"z = x + y;"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  z = x + y;<\/span>      \/\/ ???<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"z: "<\/span>; <\/span>z<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"z = y + 3;"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  z = y + <\/span>3.0<\/span>;<\/span>      \/\/ ???<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"z: "<\/span>; <\/span>z<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n<\/span>\n  z = <\/span>3.0<\/span> + y;<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                              \n
                                              Now, we get a compile-time error:<\/p>\n\n\n\n
                                              main.cpp:37:11 Invalid operands to binary expression ('double' and 'Complex')<\/code><\/pre>\n\n\n\n
                                              What’s wrong? How can we fix it?<\/p>\n<\/div>\n<\/div>\n\n\n\n
                                              <\/span>Let’s try using a non-member<\/em> function…<\/span><\/h4>\n\n\n\n
                                              \n
                                              \n
                                              Here’s a Complex class that implements the addition operator, operator+  as a non-member<\/em> function:<\/p>\n\n\n\n
                                              <\/path><\/path><\/svg><\/span>
                                              \/\/<\/span><\/span>\n\/\/  Complex.hpp<\/span><\/span>\n\/\/  Addition Operator<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/22\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Complex_hpp<\/span><\/span>\n#define<\/span> Complex_hpp<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Complex<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Complex<\/span>(<\/span>double<\/span> <\/span>real<\/span> = <\/span>0.0<\/span>, <\/span>double<\/span> <\/span>imag<\/span> = <\/span>0.0<\/span>);<\/span><\/span>\n  <\/span>~Complex<\/span>();<\/span><\/span>\n  <\/span><\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>();<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>double<\/span> m_real, m_imag;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nextern<\/span> <\/span>Complex<\/span> <\/span>operator+<\/span>(<\/span>const<\/span> <\/span>Complex<\/span> <\/span>&<\/span>lhs<\/span>,<\/span><\/span>\n                         <\/span>const<\/span> <\/span>Complex<\/span> <\/span>&<\/span>rhs<\/span>);<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Complex_hpp *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                              \n
                                              <\/path><\/path><\/svg><\/span>
                                              \/\/<\/span><\/span>\n\/\/  Complex.cpp<\/span><\/span>\n\/\/  Addition Operator<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/22\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Complex.hpp"<\/span><\/span>\n<\/span>\nComplex<\/span>::<\/span>Complex<\/span>(<\/span>double<\/span> real, <\/span>double<\/span> imag)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"In constructor for "<\/span> << <\/span>this<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  m_real = real;<\/span><\/span>\n  m_imag = imag;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Non-member operator+<\/span><\/span>\nComplex<\/span> <\/span>operator+<\/span>(<\/span>const<\/span> <\/span>Complex<\/span> <\/span>&<\/span>lhs<\/span>, <\/span>const<\/span> <\/span>Complex<\/span> <\/span>&<\/span>rhs<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Assigning values from "<\/span> << &rhs << <\/span>" to "<\/span> << &lhs << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>return<\/span> <\/span>Complex<\/span>(<\/span>lhs<\/span>.<\/span>m_real<\/span> + <\/span>rhs<\/span>.<\/span>m_real<\/span>,<\/span><\/span>\n                 <\/span>lhs<\/span>.<\/span>m_imag<\/span> + <\/span>rhs<\/span>.<\/span>m_imag<\/span>);<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nComplex<\/span>::~<\/span>Complex<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"In Destructor for "<\/span> << <\/span>this<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>Complex<\/span>::<\/span>Print<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Complex: ["<\/span><\/span>\n            << m_real << <\/span>", "<\/span> << m_imag << <\/span>"]"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
                                              \n
                                              \n
                                              But, now we have more compile-time errors:<\/p>\n\n\n\n
                                              <\/path><\/path><\/svg><\/span>
                                              \/\/<\/span><\/span>\n\/\/  Complex.cpp<\/span><\/span>\n\/\/  Addition Operator<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 8\/22\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"Complex.hpp"<\/span><\/span>\n<\/span>\nComplex<\/span>::<\/span>Complex<\/span>(<\/span>double<\/span> real, <\/span>double<\/span> imag)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"In constructor for "<\/span> << <\/span>this<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n  m_real = real;<\/span><\/span>\n  m_imag = imag;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ Non-member operator+<\/span><\/span>\nComplex<\/span> <\/span>operator+<\/span>(<\/span>const<\/span> <\/span>Complex<\/span> <\/span>&<\/span>lhs<\/span>, <\/span>const<\/span> <\/span>Complex<\/span> <\/span>&<\/span>rhs<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Assigning values from "<\/span> << &rhs << <\/span>" to "<\/span> << &lhs << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>return<\/span> <\/span>Complex<\/span>(<\/span>lhs<\/span>.<\/span>m_real<\/span> + <\/span>rhs<\/span>.<\/span>m_real<\/span>,<\/span><\/span>\n                 <\/span>lhs<\/span>.<\/span>m_imag<\/span> + <\/span>rhs<\/span>.<\/span>m_imag<\/span>);<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nComplex<\/span>::~<\/span>Complex<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"In Destructor for "<\/span> << <\/span>this<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>Complex<\/span>::<\/span>Print<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Complex: ["<\/span><\/span>\n            << m_real << <\/span>", "<\/span> << m_imag << <\/span>"]"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                                              \n
                                              Now, we get a compile-time error:<\/p>\n\n\n\n
                                              'm_real' is a private member of 'Complex'\n'm_imag' is a private member of 'Complex'<\/code><\/pre>\n\n\n\n
                                              We need to allow the non-member function to be able to access private data in the Complex class.<\/p>\n\n\n\n
                                              <\/p>\n<\/div>\n<\/div>\n\n\n\n
                                              We could make the data public, but that violates data abstraction. It’s not a good idea.<\/p>\n\n\n\n
                                              <\/span>A Class Needs its friends<\/span><\/h2>\n\n\n\n
                                              So, we’d like to write it this way, but in order to do so, it looks like we’d have to make the class’ data public!<\/p>\n\n\n\n
                                              But wait!  <\/em><\/strong>There’s a C++ feature called friends of a class<\/em>:<\/p>\n\n\n\n
                                              <\/span>What is a friend?<\/span><\/h3>\n\n\n\n
                                              A friend to a class has access to that class’ private parts<\/em>.  <\/p>\n\n\n\n
                                              A rather special relationship, and not one to be granted lightly!<\/p>\n\n\n\n
                                              A friend can be:<\/p>\n\n\n\n