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
andPlayer
. - Both might need health, position, and movement logic.
- You could create a base class called
Character
, and haveEnemy
andPlayer
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 remainpublic
in the derived class;protected
members stayprotected
. -
protected inheritance: All
public
andprotected
members becomeprotected
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!

Hot AI Tools

Undress AI Tool
Undress images for free

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics

C STL is a set of general template classes and functions, including core components such as containers, algorithms, and iterators. Containers such as vector, list, map, and set are used to store data. Vector supports random access, which is suitable for frequent reading; list insertion and deletion are efficient but accessed slowly; map and set are based on red and black trees, and automatic sorting is suitable for fast searches. Algorithms such as sort, find, copy, transform, and accumulate are commonly used to encapsulate them, and they act on the iterator range of the container. The iterator acts as a bridge connecting containers to algorithms, supporting traversal and accessing elements. Other components include function objects, adapters, allocators, which are used to customize logic, change behavior, and memory management. STL simplifies C

In C, cin and cout are used for console input and output. 1. Use cout to read the input, pay attention to type matching problems, and stop encountering spaces; 3. Use getline(cin, str) when reading strings containing spaces; 4. When using cin and getline, you need to clean the remaining characters in the buffer; 5. When entering incorrectly, you need to call cin.clear() and cin.ignore() to deal with exception status. Master these key points and write stable console programs.

FunctionhidinginC occurswhenaderivedclassdefinesafunctionwiththesamenameasabaseclassfunction,makingthebaseversioninaccessiblethroughthederivedclass.Thishappenswhenthebasefunctionisn’tvirtualorsignaturesdon’tmatchforoverriding,andnousingdeclarationis

volatile tells the compiler that the value of the variable may change at any time, preventing the compiler from optimizing access. 1. Used for hardware registers, signal handlers, or shared variables between threads (but modern C recommends std::atomic). 2. Each access is directly read and write memory instead of cached to registers. 3. It does not provide atomicity or thread safety, and only ensures that the compiler does not optimize read and write. 4. Constantly, the two are sometimes used in combination to represent read-only but externally modifyable variables. 5. It cannot replace mutexes or atomic operations, and excessive use will affect performance.

There are mainly the following methods to obtain stack traces in C: 1. Use backtrace and backtrace_symbols functions on Linux platform. By including obtaining the call stack and printing symbol information, the -rdynamic parameter needs to be added when compiling; 2. Use CaptureStackBackTrace function on Windows platform, and you need to link DbgHelp.lib and rely on PDB file to parse the function name; 3. Use third-party libraries such as GoogleBreakpad or Boost.Stacktrace to cross-platform and simplify stack capture operations; 4. In exception handling, combine the above methods to automatically output stack information in catch blocks

To call Python code in C, you must first initialize the interpreter, and then you can achieve interaction by executing strings, files, or calling specific functions. 1. Initialize the interpreter with Py_Initialize() and close it with Py_Finalize(); 2. Execute string code or PyRun_SimpleFile with PyRun_SimpleFile; 3. Import modules through PyImport_ImportModule, get the function through PyObject_GetAttrString, construct parameters of Py_BuildValue, call the function and process return

To deal with endianness issues in C, we need to clarify platform differences and take corresponding conversion measures. 1. To determine the system byte order, you can use simple functions to detect whether the current system is a little-endian; 2. When manually exchanging byte order, general conversion can be achieved through bit operations, but standard APIs such as ntohl() and htonl() are recommended; 3. Use cross-platform libraries such as Boost or absl to provide conversion interfaces, or encapsulate macros that adapt to different architectures by themselves; 4. When processing structures or buffers, you should read and convert fields by field to avoid direct reinterpret_cast structure pointer to ensure data correctness and code portability.

MRO is a mechanism for determining the order of method calls in Python multi-inheritance, which is based on C3 linearization algorithm. 1.MRO is viewed through class name.mro() or help (class name); 2. C3 algorithm ensures that subclasses remain monotonic in front of the parent class and avoid cyclic dependencies; 3. super() calls the next class method in MRO order, rather than directly the parent class; 4. When instantiating D(B, C) the output order is Dinit, Binit, Cinit, Ainit; 5. It is recommended to avoid manually modifying MRO, reducing complex multi-inheritance, prioritizing combinations, and rational use of Mixin classes. Mastering MRO can improve code stability and predictability.
