{"id":6520,"date":"2023-02-26T21:51:26","date_gmt":"2023-02-26T21:51:26","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/covariant-return-type\/"},"modified":"2023-06-26T08:51:45","modified_gmt":"2023-06-26T08:51:45","slug":"covariant-return-type","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/covariant-return-type\/","title":{"rendered":"Covariant Return Type"},"content":{"rendered":"

The Covariant Return Type of a member function allows an overriding member function to return a narrower<\/em> type. This is particularly useful when you implement the Prototype Pattern<\/a>.<\/p>\n

<\/p>\n

 <\/p>\n

\"ClassIdioms\"<\/p>\n

I used the Covariant Return Type in my previous posts without explaining it. Let’s change this.<\/p>\n

Covariant Return Type<\/h2>\n

Let me start with the naive implementation.<\/p>\n

The Naive Version<\/h3>\n

The following program covariantReturnType.cpp<\/code> applies the Prototype Pattern<\/a>.<\/p>\n

<\/p>\n

\n
\/\/ covariantReturnType.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n\r\nclass<\/span> Window<\/span>{                                  \/\/ (1)<\/span><\/em>\r\n public<\/span>:<\/span>                \r\n    virtual<\/span> Window*<\/span> clone() { \r\n        return<\/span> new<\/span> Window(*<\/span>this<\/span>);\r\n    }\r\n    virtual<\/span> std::<\/span>string getName() const<\/span> {\r\n        return<\/span> \"Window\"<\/span>;\r\n    }                       \r\n    virtual<\/span> ~<\/span>Window() {};\r\n};\r\n\r\nclass<\/span> DefaultWindow<\/span>:<\/span> public<\/span> Window {          \/\/ (2)<\/span><\/em>\r\n     DefaultWindow*<\/span> clone() override { \r\n        return<\/span> new<\/span> DefaultWindow(*<\/span>this<\/span>);\r\n    } \r\n    std::<\/span>string getName() const<\/span> override {\r\n        return<\/span> \"DefaultWindow\"<\/span>;\r\n    }   \r\n};\r\n\r\nclass<\/span> FancyWindow<\/span>:<\/span> public<\/span> Window {           \/\/ (3)<\/span><\/em>\r\n    FancyWindow*<\/span> clone() override { \r\n        return<\/span> new<\/span> FancyWindow(*<\/span>this<\/span>);\r\n    } \r\n    std::<\/span>string getName() const<\/span> override {\r\n        return<\/span> \"FancyWindow\"<\/span>;\r\n    }   \r\n};\r\n                \r\nWindow*<\/span> cloneWindow<\/span>(Window&<\/span> oldWindow) {    \/\/ (4)<\/span><\/em>                \r\n    return<\/span> oldWindow.clone();\r\n}\r\n  \r\nint<\/span> main<\/span>() {\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n    Window window;\r\n    DefaultWindow defaultWindow;\r\n    FancyWindow fancyWindow;\r\n\r\n    const<\/span> Window*<\/span> window1 =<\/span> cloneWindow(window);\r\n    std::<\/span>cout <<<\/span> \"window1->getName(): \"<\/span> <<<\/span> window1-><\/span>getName() <<<\/span> '\\n'<\/span>;\r\n\r\n    const<\/span> Window*<\/span> defaultWindow1 =<\/span> cloneWindow(defaultWindow);\r\n    std::<\/span>cout <<<\/span> \"defaultWindow1->getName(): \"<\/span> <<<\/span> defaultWindow1-><\/span>getName() <<<\/span> '\\n'<\/span>;\r\n\r\n    const<\/span> Window*<\/span> fancyWindow1 =<\/span> cloneWindow(fancyWindow);\r\n    std::<\/span>cout <<<\/span> \"fancywindow1->getName(): \"<\/span> <<<\/span> fancyWindow1-><\/span>getName() <<<\/span> '\\n'<\/span>;\r\n  \r\n    delete<\/span> window1;\r\n    delete<\/span> defaultWindow1;\r\n    delete<\/span> fancyWindow1;\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n  \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The interface-class Window<\/code> (line 1) has a virtual clone <\/code>function. The clone<\/code> function returns a copy of itself. The derived classes such as DefaultWindow<\/code> (line 2) and FancyWindow<\/code> (line 3) also return a copy of itself. The function cloneWindow<\/code> (line 4) uses the virtual member function and creates clones of the incoming windows. Additionally, I implemented a virtual getName<\/code> function to visualize the virtual dispatch.<\/p>\n
The output of the program is as expected.<\/p>\n
\"covariantReturnType\"<\/p>\n
Did you happen to notice the use of the Covariant Return Type in this example? Window<\/code>‘s virtual clone member function returns a Window<\/code> pointer, but DefaultWindow<\/code>‘s virtual clone member function a DefaultWindow<\/code> pointer, and FancyWindow<\/code>*s virtual clone member function a FancyWindow<\/code> pointer. This means the return type is covariant:  If a derived class member function returns a more-derived type than its overridden base class member function, the derived class return type is called covariant. <\/strong><\/p>\n
Additionally, there is a small observation I want to share. Although DeaultWindow<\/code>‘s and FancyWindows<\/code>‘s virtual member functions clone<\/code> are private, the function cloneWindow<\/code> (line 4) can invoke them. The reason is simple: The member function cloneWindow uses the public interface of the interface-class Window<\/code>.<\/p>\n
I called this implementation naive. Why?<\/p>\n
Ownership Semantics<\/h3>\n
In general, you don’t know the implementation of the clone<\/code> function. clone<\/code> returns a pointer to a window<\/code>. Pointers have, by design, a flaw. They model two completely different semantics: ownership and borrowing.<\/strong><\/p>\n