Inheritance in C allows a derived class to inherit properties and behaviors from a base class to promote code reuse and reduce duplication. For example, classes like Enemy and Player can inherit shared functionality such as health and movement from a base Character class. C supports single, multiple, multilevel, hierarchical, and hybrid inheritance, each with distinct use cases. Access specifiers like public, protected, and private determine member accessibility in derived classes, while constructors and destructors must be explicitly called. Derived classes can override base class functions, especially using virtual functions for runtime polymorphism, enabling dynamic method resolution based on the actual object type.

Inheritance in C is a feature that allows a class (called a derived or child class) to inherit properties and behaviors (like variables and functions) from another class (called a base or parent class). This helps avoid code duplication and makes it easier to build and maintain applications.

Why Use Inheritance?

The main reason to use inheritance is code reuse. If you have two classes that share some common functionality, instead of writing the same code twice, you can create a base class with that shared code and have both classes inherit from it.

For example:

• Imagine you're building a game and have classes like Enemy and Player.
• Both might need health, position, and movement logic.
• You could create a base class called Character, and have Enemy and Player inherit from it.

This way, if you update how movement works, you only have to change it in one place — the Character class.

Types of Inheritance

C supports several types of inheritance:

• Single inheritance: One derived class inherits from one base class.
• Multiple inheritance: One derived class inherits from two or more base classes.
• Multilevel inheritance: A derived class inherits from another derived class (like a chain).
• Hierarchical inheritance: Multiple derived classes inherit from a single base class.
• Hybrid inheritance: A mix of the above types.

Each type has its own use cases. For example, multiple inheritance can be useful but also adds complexity — especially when dealing with naming conflicts or ambiguous calls.

Access Specifiers and Inheritance

When inheriting members, the access level matters. Here's what happens depending on the inheritance mode:

• public inheritance: Members that are public in the base class remain public in the derived class; protected members stay protected.
• protected inheritance: All public and protected members become protected in the derived class.
• private inheritance: All inherited members become private in the derived class.

It’s important to remember that private members of the base class are never accessible directly in the derived class, even if the inheritance is public.

Also, constructors and destructors don’t get inherited automatically. But you can call the base class constructor from the derived class using an initialization list.

Overriding Functions

A derived class can override functions from the base class — this means providing a new implementation for a function that already exists in the parent class.

To do this:

• The function must have the same name, return type, and parameters in both classes.
• If you want to support runtime polymorphism (deciding which function to call at runtime), declare the function as virtual in the base class.

This lets you write code like:

Character* player = new Player();
player->move();  // Calls Player's move(), not Character's

Without virtual functions, the compiler decides which function to call based only on the pointer or reference type — not the actual object type.

That’s basically how inheritance works in C . It’s powerful but needs careful handling, especially with access control and overriding behavior.

The above is the detailed content of What is inheritance in C ?. For more information, please follow other related articles on the PHP Chinese website!