inheritance section revisited

Author: Oguzhan Katli

inc/advanced_cpp_topics.h

@@ -2,10 +2,11 @@
 #include "playground_organizer.hpp"
 
 // Inheritance
-CREATE_ELEMENT(FriendUsageExample);
 CREATE_ELEMENT(InheritanceUsageExample);
+CREATE_ELEMENT(InheritanceAccessControl);
 CREATE_ELEMENT(DiamondProblemExample);
 CREATE_ELEMENT(VirtualDestructorUsage);
+CREATE_ELEMENT(FriendUsageExample);
 
 // Smart Pointers
 CREATE_ELEMENT(MallocUsageExample);

main.cpp

@@ -12,6 +12,7 @@ int main(int argc, char *argv[]) {
  po.builder()
  // Inheritance
  .Add<InheritanceUsageExample>()
+ .Add<InheritanceAccessControl>()
  .Add<DiamondProblemExample>()
  .Add<VirtualDestructorUsage>()
  .Add<FriendUsageExample>()

src/1-Inheritance/inheritance_usage.cpp

@@ -97,18 +97,86 @@ void getCircleFromShape(Shape* shape)
 
 ELEMENT_CODE(InheritanceUsageExample) 
 {
- std::vector<Shape*> shapes {
- new Circle(5),
- new Rectangle(3, 5),
- new Triangle(12, 3, 30)
- };
+ std::vector<std::unique_ptr<Shape>> shapes;
+ shapes.emplace_back(new Circle(5));
+ shapes.emplace_back(new Rectangle(3, 5));
+ shapes.emplace_back(new Triangle(12, 3, 30));
 
  auto total_area = std::reduce(begin(shapes),
  end(shapes),
  0.f,
- [](float area, Shape* shape) {
+ [](float area, auto& shape) {
  return area + shape->getArea();
  });
  std::cout << "total area of all shapes are " << std::fixed << total_area << "\n";
+}
+
+
+// inheritance access control
+
+class base
+{
+public:
+ base() {
+ static auto print_once = [&] {
+ std::cout << "class can access all of its members "
+ "no matter access control\n";
+ std::cout << "private var: " << private_var << "\n";
+ std::cout << "protected var: " << protected_var << "\n";
+ std::cout << "public var: " << public_var << "\n";
+ return true;
+ } ();
+ }
+public:
+ int public_var{ 1 };
+protected:
+ int protected_var{ 2 };
+private:
+ int private_var{ 3 };
+};
+
+class public_derived 
+ : public base { };
+
+class protected_derived 
+ : protected base { };
+
+class private_derived
+ : private base { 
+public:
+ private_derived() {
+ std::cout << "derived classes can access protected and "
+ "public base variables inside of class\n";
+ // std::cout << "private var: " << private_var << "\n";
+ std::cout << "base protected var: " << protected_var << "\n";
+ std::cout << "base public var: " << public_var << "\n";
+ }
+};
+
+ELEMENT_CODE(InheritanceAccessControl)
+{
+ base b;
+ public_derived pd;
+ protected_derived pro_d;
+ private_derived priv_d;
+ std::cout << "access to base class variables from "
+ "derived class instances depends on inheritance type\n";
+
+ std::cout << "when an inheritance marked as protected; all public "
+ "members of base goes to protected inside of derived class\n";
+
+ std::cout << "when an inheritance made as private then members of base "
+ "goes to private inside of derived class\n";
+//pd.public_var;
+//pd.protected_var;
+//pd.private_var;
+//
+//pro_d.public_var;
+//pro_d.protected_var;
+//pro_d.private_var;
+// 
+//priv_d.public_var;
+//priv_d.protected_var;
+//priv_d.private_var;
 
 }