Calling Base Class Functions in C++

Inheritance allows classes in C++ to reuse and extend code from existing base classes. An important capability enabled by inheritance is calling base class functions from overriding derived class methods. This provides polymorphism, customization, and code reuse.

As a full-stack and C++ expert, I have applied base/derived class relationships across various projects. In this comprehensive guide, I will cover when and how to call base functions correctly to follow best practices.

Real-World Use Cases

Here are some common use cases from large-scale software engineering where calling the base class function is useful:

1. Wrapper Classes

Wrapper or adapter classes are used to extend functionality of existing classes. For example, a DebugVector wrapper over std::vector to add debugging capabilities:

class DebugVector : public std::vector {
public:
  // Overrides with extra debugging
  void push_back(int element) {

    // Call base method first
    std::vector::push_back(element); 

    print("Pushed element: " + std::to_string(element));
  }
};

This leverages base vector functionality and builds more logic around it.

2. Class Libraries

In class library design, base classes define interfaces while derived classes provide specialized implementations.

For example, an Animal base class and Cat, Dog derived classes. speak() may be virtual in base, overridden by derived classes, but still accessed as Animal::speak().

This separation of interface vs implementation via base/derived classes is a major benefit.

3. Game Engines

Game engines like Unity use base classes to define common behavior. Derived classes add specialized logic – like separate classes for NPC characters vs playable characters.

The base methods still get reused and called by overrides when logical.

4. GUI Toolkits

GUI frameworks utilize base visual classes like buttons, inputs, panels etc. Specialized controls override base functionality but still leverage base logic for event handling, rendering and layout management.

Decoupling Base and Derived Classes

An important best practice when allowing base class calls is loose coupling between base and derived classes.

The derived class should not make assumptions about internal details of the base class by relying excessively on calling base methods. This reduces dependencies and stability.

Consider this poorly coupled design:

class Base {
private:
   int data;

public:
   int getData() { return data; }    
};

class Derived : public Base {   
  void process() {
    int x = Base::getData(); 
    // ... many operations on Base‘s private data
  }   
};

Derived heavily depends on base‘s private data, accessing it via the public getter. This couples the classes together. Changes in Base would break Derived.

Instead, keep coupling loose:

class Base {
  // Hide private data   
  public:
    int getProcessedData() {
      // internal processing
      return processed; 
    }
}

class Derived : public Base  {
  void process() {  
    // Only rely on exposed base functionality   
    int x = Base::getProcessedData();
  }  
};

Now, Derived only relies on Base‘s public interface, allowing the base class internals to change freely without affecting children subclasses.

Virtual Functions and Polymorphism

A core use case for calling base functions is overriding virtual functions to enable polymorphism.

Polymorphism allows a derived class object to be referenced via a base class reference:

Shape* shape = new Circle(); // Shape reference, Circle object

When virtual functions in the base class are called via the reference, the derived class‘s overridden version is called:

shape->draw(); // Calls Circle::draw()

This dynamic dispatch to overridden functionality is polymorphism.

To call the base version explicitly instead, use scoping:

shape->Shape::draw(); // Calls Shape::draw() 

Well-designed class hierarchies take advantage of this polymorphism for cleaner code. Checks for object types and explicit downcasting is avoided.

For example:

void renderShapes(Shape** shapes, int count) {

  for(int i=0; i < count; i++) {
    // Render each shape    
    shapes[i]->draw(); // Dynamic polymorphic dispatch  
  }
} 

This cleanly renders collections of different shapes avoiding type checks.

Accessibility of Base Class Functions

For a derived class to call base class functions, the base member should be declared protected or public. private base members are not accessible.

For example:

class Base {
public:
  void method1();

private:
  void method2();  
};

class Derived: public Base {
  void test() {
    Base::method1(); // Okay  
    Base::method2(); // Error, cannot access private
  }
};

Protected members offer a middle ground with accessibility in child classes but not outside code.

In addition, non-virtual functions resolve statically, so accessibility rules apply at compile time based on the reference type:

class Base {
public:
  void method1(); // Non-virtual 
}

class Derived: public Base {
  void test(Base* base) {
    base->method1(); // Okay, Base reference  
  }  
}; 

Derived d;
Base* b = &d;
b->method1(); // Error! Base reference but Derived object

Here method1() is non-virtual, so which function resolves depends on the compile-time reference type Base*, not actual underlying object type. This causes the access check to fail incorrectly.

Making methods virtual postpones resolution until runtime based on actual objects, avoiding this issue.

Design Considerations and Best Practices

Here are some key points to consider when designing class hierarchies allowing base member access:

• Prefer composition over inheritance when possible – Inheritance couples classes strongly since children rely on parent class internals. Composition via interfaces leads to lower coupling
• Avoidprotected data – Exposes unnecessary detail to subclasses leading to coupling
• Virtual vs non-virtual base methods – Non-virtual methods lock subclasses into base class implementation due to static linkage. Use virtual methods for polymorphism when child classes need to customize logic
• Narrow vs wide interfaces – Wide base classes with many functions lead to bloated subclasses and dependencies. Aim for narrow interfaces with focused functionality

Studies on modern C++ codebases reveal average inheritance depth of 0-1 across most projects, indicating composition is preferred over deep inheritance trees today due to lower coupling.

Conclusion

Calling base class functions is an essential technique enabled by inheritance. It leads to reusable code and polymorphism. However, care should be taken to balance this with loose class coupling.

By understanding access rules, virtual vs non-virtual methods and modern design guidelines, engineers can employ base/derived class relationships cleanly for maintainable and flexible object-oriented programs.