{"id":233,"date":"2020-09-01T15:51:34","date_gmt":"2020-09-01T15:51:34","guid":{"rendered":"https:\/\/www.kindsonthegenius.com\/cplusplus\/?p=233"},"modified":"2020-09-01T15:51:34","modified_gmt":"2020-09-01T15:51:34","slug":"c-overloading","status":"publish","type":"post","link":"https:\/\/www.kindsonthegenius.com\/cplusplus\/c-overloading\/","title":{"rendered":"C++ Overloading"},"content":{"rendered":"

In this lesson we would cover C++ overloading. Precisely, you’ll learn about Function Overloading<\/em><\/strong> and Operator Overloading<\/em><\/strong>.<\/p>\n

    \n
  1. Function Overloading<\/a><\/li>\n
  2. Operator Overloading<\/a><\/li>\n<\/ol>\n

     <\/p>\n

    1. Function Overloading<\/strong><\/h4>\n

    In function overloading, two functions have the same name and exist in the same scope. However, both functions have they must have different arguments specification. In this case, we say that they are overloaded functions.<\/p>\n

    For example, all these are overloaded functions<\/p>\n

    \/\/ Example of Overloaded functions<\/span>\r\nint<\/span> getValue<\/span>() { }\r\n\r\nint<\/span> getValue<\/span>(int<\/span> x) { }\r\n\r\nfloat<\/span> getValue<\/span>(double<\/span> x) { }\r\n\r\nint<\/span> getValue<\/span>(int<\/span> x, double<\/span> y) { }\r\n<\/pre>\n
     <\/p>\n
    About return type: notice from the examples that not all overloaded functions have the same return time. The key is this: overloaded functions must have different argument. This is regardless of whether they have different return types or not.<\/p>\n
    So the code below would result in error.<\/p>\n
    \/\/Error: different return types, but same parameters<\/span>\r\ndouble<\/span> getSum<\/span>(int<\/span> a, int<\/span> b) { }\r\n\r\nfloat<\/span> getSum<\/span>(int<\/span> a, int<\/span> b) { }\r\n<\/pre>\n
    Let’s write a program to demonstrate how function overloading works.<\/p>\n
    \/\/Demonstrating function overriding<\/span>\r\n#include <iostream><\/span>\r\n\r\nusing<\/span> namespace<\/span> std;\r\n\r\nint<\/span> getTotal<\/span>(int<\/span> x, int<\/span> y, int<\/span> z) {\r\n  return<\/span> x +<\/span> y +<\/span> z;\r\n}\r\n\r\ndouble<\/span> getTotal<\/span>(double<\/span> x, double<\/span> y, int<\/span> z) {\r\n  return<\/span> x +<\/span> y;\r\n}\r\n\r\nint<\/span> main<\/span>() {\r\n  int<\/span> total1 =<\/span> getTotal(3<\/span>, 5<\/span>, 2<\/span>);\r\n\r\n  double<\/span> total2 =<\/span> getTotal(4.3<\/span>, 7.25<\/span>, 10<\/span>);\r\n\r\n  cout <<<\/span> \"First total: \"<\/span> <<<\/span> total1 <<<\/span>endl;\r\n\r\n  cout <<<\/span> \"Second total: \"<\/span> <<<\/span> total2;\r\n\r\n  return<\/span> 0<\/span>;\r\n}\r\n<\/pre>\n
    Output:<\/p>\n
    First total: 10\r\nSecond total: 11.55\r\n<\/pre>\n
    This code is quite clear, so I’m not going to go over it. However, I recommend you run it to understand how it works<\/p>\n
     <\/p>\n
    2. Operator Overloading<\/strong><\/h4>\n
    Basically, the concept of overloading is about ‘one thing being able to perform different operations’. For example, we can make existing operator perform different action.<\/p>\n
    To overload an operator, we use the keyword ‘operator’ followed by the operator we want to overload. Then in curly braces, we define the operation that need to be done. In the code below, we overload the + operator to add two Square objects.<\/p>\n
    #include <iostream><\/span>\r\nusing<\/span> namespace<\/span> std;\r\n\r\nclass<\/span> Square<\/span> {\r\n   public:<\/span>\r\n      double<\/span> getArea(void<\/span>) {\r\n         return<\/span> length *<\/span> height;\r\n      }\r\n\r\n      void<\/span> setLength( double<\/span> len ) {\r\n         length =<\/span> len;\r\n      }\r\n\r\n      void<\/span> setHeight( double<\/span> hei ) {\r\n         height =<\/span> hei;\r\n      }\r\n\r\n      \/\/ Overload + operator to add two Square objects.<\/span>\r\n      Square operator<\/span>+<\/span>(const<\/span> Square&<\/span> s) {\r\n    \t Square square;\r\n    \t square.length =<\/span> this<\/span>-><\/span>length +<\/span> s.length;\r\n    \t square.height =<\/span> this<\/span>-><\/span>height +<\/span> s.height;\r\n         return<\/span> square;\r\n      }\r\n\r\n   private:<\/span>\r\n      double<\/span> length;      \/\/ Length of a square<\/span>\r\n      double<\/span> height;      \/\/ Height of a square<\/span>\r\n};\r\n\r\nint<\/span> main<\/span>() {\r\n   Square square1;    \/\/ Declare square1<\/span>\r\n   Square square2;    \/\/ Declare square2<\/span>\r\n   Square square3;    \/\/ Declare square3<\/span>\r\n   double<\/span> area =<\/span> 0.0<\/span>; \/\/ Store area of a square<\/span>\r\n\r\n   \/\/ square 1 specification<\/span>\r\n   square1.setLength(9.0<\/span>);\r\n   square1.setHeight(12.0<\/span>);\r\n\r\n   \/\/ square 2 specification<\/span>\r\n   square2.setLength(11.0<\/span>);\r\n   square2.setHeight(6.0<\/span>);\r\n\r\n   \/\/ area of square 1<\/span>\r\n   area =<\/span> square1.getArea();\r\n   cout <<<\/span> \"Area of sueare1 : \"<\/span> <<<\/span> area <<<\/span>endl;\r\n\r\n   \/\/ area of square 2<\/span>\r\n   area =<\/span> square2.getArea();\r\n   cout <<<\/span> \"Area of square2 : \"<\/span> <<<\/span> area <<<\/span>endl;\r\n\r\n   \/\/ Add two square as follows:<\/span>\r\n   square3 =<\/span> square1 +<\/span> square2;\r\n\r\n   \/\/ area of square 3<\/span>\r\n   area =<\/span> square3.getArea();\r\n   cout <<<\/span> \"Area of square3 : \"<\/span> <<<\/span> area <<<\/span>endl;\r\n\r\n   return<\/span> 0<\/span>;\r\n}\r\n<\/pre>\n
    The program yields the following output:<\/p>\n
    Area of sueare1 :<\/span> 108<\/span>\r\nArea of square2 :<\/span> 66<\/span>\r\nArea of square3 :<\/span> 360<\/span>\r\n<\/pre>\n
    From the program above, we have overloaded the + operator to be able to add two Squares. The operation produces a third square whose length is the sum of the two given squares. Similarly, the height is the sum of the two squares being summed.<\/p>\n
    However, the following operators cannot be overloaded:<\/p>\n
      \n
    • scope resolution(::)<\/li>\n
    • pointer (*)<\/li>\n
    • dot (.)<\/li>\n
    • ternary (?:)<\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"
      In this lesson we would cover C++ overloading. Precisely, you’ll learn about Function Overloading and Operator Overloading. Function Overloading Operator Overloading   1. Function Overloading … <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[40],"class_list":["post-233","post","type-post","status-publish","format-standard","hentry","category-c-tutorials","tag-overloading"],"_links":{"self":[{"href":"https:\/\/www.kindsonthegenius.com\/cplusplus\/wp-json\/wp\/v2\/posts\/233","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.kindsonthegenius.com\/cplusplus\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.kindsonthegenius.com\/cplusplus\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/cplusplus\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/cplusplus\/wp-json\/wp\/v2\/comments?post=233"}],"version-history":[{"count":1,"href":"https:\/\/www.kindsonthegenius.com\/cplusplus\/wp-json\/wp\/v2\/posts\/233\/revisions"}],"predecessor-version":[{"id":234,"href":"https:\/\/www.kindsonthegenius.com\/cplusplus\/wp-json\/wp\/v2\/posts\/233\/revisions\/234"}],"wp:attachment":[{"href":"https:\/\/www.kindsonthegenius.com\/cplusplus\/wp-json\/wp\/v2\/media?parent=233"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/cplusplus\/wp-json\/wp\/v2\/categories?post=233"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/cplusplus\/wp-json\/wp\/v2\/tags?post=233"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}