![\"doorSmall\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/10\/doorSmall.png\")
<\/p>\nThere are nine rules to access objects in class hierarchies. Let’s have a closer look.<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
Here are the nine rules.<\/p>\n
dynamic_cast<\/code> where class hierarchy navigation is unavoidable<\/a><\/li>\n- C.147: Use
dynamic_cast<\/code> to a reference type when failure to find the required class is considered an error<\/a><\/li>\n- C.148: Use
dynamic_cast<\/code> to a pointer type when failure to find the required class is considered a valid alternative<\/a><\/li>\n- C.149: Use
unique_ptr<\/code> or shared_ptr<\/code> to avoid forgetting to delete<\/code> objects created using new<\/code><\/a><\/li>\n- C.150: Use
make_unique()<\/code> to construct objects owned by unique_ptr<\/code>s<\/a><\/li>\n- C.151: Use
make_shared()<\/code> to construct objects owned by shared_ptr<\/code>s<\/a><\/li>\n- C.152: Never assign a pointer to an array of derived class objects to a pointer to its base<\/a><\/li>\n
- C.153: Prefer virtual function to casting<\/a><\/li>\n<\/ul>\n
Believe me. Slicing is an issue in a lot of C++ codebases.<\/p>\n
<\/span>C.145: Access polymorphic objects through pointers and references<\/a><\/span><\/h3>\nIf you access a virtual function, you don’t know which class provides the functionality; therefore, you should use a pointer or a reference. This means in the concrete example, that both d<\/span> are sliced.<\/p>\n<\/p>\n
\nstruct<\/span> B{ \r\n int<\/span> a; \r\n virtual<\/span> int<\/span> f<\/span>(); \r\n};\r\n\r\nstruct<\/span> D :<\/span> B{ \r\n int<\/span> b; \r\n int<\/span> f() override; \r\n};\r\n\r\nvoid<\/span> use<\/span>(B b)\r\n{\r\n D d;\r\n B b2 =<\/span> d; \/\/ slice<\/span>\r\n B b3 =<\/span> b;\r\n}\r\n\r\nvoid<\/span> use2<\/span>()\r\n{\r\n D d;\r\n use(d); \/\/ slice<\/span>\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
The first and the second slice cause only the B<\/span> part of D<\/span> to be copied.<\/p>\nDo you want to know more about slicing? C.67: A base class should suppress copying, and provide a virtual clone instead if \u201ccopying\u201d is desired<\/a> talks about this issue.<\/p>\nThe three next rules are about dynamic_cast<\/span>. Before I write about the dynamic_cast<\/span> let me emphasise, casts, including dynamic_cast<\/span> are used way too often. The job of the dynamic_cast is to “Safely converts pointers and references to classes up, down, and sideways along the inheritance hierarchy.” (http:\/\/en.cppreference.com\/w\/cpp\/language\/dynamic_cast<\/a>)<\/p>\n<\/p>\n<\/span>C.146: Use dynamic_cast<\/code> where class hierarchy navigation is unavoidable<\/a><\/span><\/h3>\nHere is the use case from the C++ Core Guidelines. You want to navigate in the class hierarchy.<\/p>\n
<\/p>\n
\nstruct<\/span> B { \/\/ an interface<\/span>\r\n virtual<\/span> void<\/span> f();\r\n virtual<\/span> void<\/span> g<\/span>();\r\n};\r\n\r\nstruct<\/span> D :<\/span> B { \/\/ a wider interface<\/span>\r\n void<\/span> f() override;\r\n virtual<\/span> void<\/span> h<\/span>();\r\n};\r\n\r\nvoid<\/span> user<\/span>(B*<\/span> pb)\r\n{\r\n if<\/span> (D*<\/span> pd =<\/span> dynamic_cast<\/span><<\/span>D*><\/span>(pb)) { \/\/ (1)\r\n \/\/ ... use D's interface ...<\/span>\r\n }\r\n else<\/span> {\r\n \/\/ ... make do with B's interface ...<\/span>\r\n }\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
To detect the right type for pb<\/span> (1)<\/strong> during run-time, a dynamic_cast<\/span> is necessary. If the cast fails, you will get a null pointer.<\/p>\nBecause of performance reasons, you want to make the cast at compile-time; therefore, a static_cast<\/span> is your friend. Now, you can violate the type of safety of the program.<\/p>\n<\/p>\n
\nvoid<\/span> user2<\/span>(B*<\/span> pb) \/\/ bad<\/span>\r\n{\r\n D*<\/span> pd =<\/span> static_cast<\/span><<\/span>D*><\/span>(pb); \/\/ I know that pb really points to a D; trust me<\/span>\r\n \/\/ ... use D's interface ...<\/span>\r\n}\r\n\r\nvoid<\/span> user3<\/span>(B*<\/span> pb) \/\/ unsafe<\/span>\r\n{\r\n if<\/span> (some_condition) {\r\n D*<\/span> pd =<\/span> static_cast<\/span><<\/span>D*><\/span>(pb); \/\/ I know that pb really points to a D; trust me<\/span>\r\n \/\/ ... use D's interface ...<\/span>\r\n }\r\n else<\/span> {\r\n \/\/ ... make do with B's interface ...<\/span>\r\n }\r\n}\r\n\r\nvoid<\/span> f<\/span>()\r\n{\r\n B b;\r\n user(&<\/span>b); \/\/ OK<\/span>\r\n user2(&<\/span>b); \/\/ bad error (1)<\/span>\r\n user3(&<\/span>b); \/\/ OK *if* the programmer got the some_condition check right (2)<\/span>\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
Casting a pointer to B<\/span> to a pointer to D<\/span> (1) is an error. This maybe holds for the last line (2).<\/p>\n <\/p>\n
<\/span>C.147: Use dynamic_cast<\/code> to a reference type when failure to find the required class is considered an error<\/a><\/span><\/h3>\nIf you make a dynamic_cast<\/span> to a pointer, you will get, in the case of a failure a null pointer; but if you make a dynamic_cas<\/span>t to a reference, you will get a failure. To be more specific, you will get a std::bad_cast<\/span> exception.<\/p>\n<\/p>\n
\n\/\/ badCast.cpp<\/span>\r\n\r\nstruct<\/span> A{\r\n virtual<\/span> void<\/span> f() {}\r\n};\r\nstruct<\/span> B :<\/span> A {};\r\n\r\nint<\/span> main<\/span>(){\r\n \r\n A a;\r\n B b;\r\n<\/span><\/span><\/span>\r\n B*<\/span> b1 =<\/span> dynamic_cast<\/span><<\/span>B*><\/span>(&<\/span>a); \/\/ nullptr, because 'a' is not a 'B'<\/span>\r\n B&<\/span> b2 =<\/span> dynamic_cast<\/span><<\/span>B&><\/span>(a); \/\/ std::bad_cast, because 'a' is not a 'B' <\/span>\r\n \r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
The g++-6 compiler complains about both bad dynamic_cast’<\/span>s and the run-time throws the expected exception in case of the reference.<\/p>\n![\"badCast\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/10\/badCast.png\")
<\/p>\n
<\/span>C.148: Use dynamic_cast<\/code> to a pointer type when failure to find the required class is considered a valid alternative<\/a><\/span><\/h3>\nSometimes it may be a valid option to choose an alternative code path, if the dynamic_cast<\/span> to a pointer type fails and, therefore, returns a null pointer.<\/p>\n