An abstract class is a class containing at least one pure virtual function. It cannot be instantiated and must be inherited as a base class. The derived class needs to implement all its pure virtual functions, otherwise it will still be an abstract class. 1. Pure virtual functions are declared by virtual return type function name() = 0; and are used to define interface specifications; 2. Abstract classes are often used for unified interface design, such as area(), draw(), etc., to implement polymorphic calls; 3. Virtual destructors (such as virtual ~Shape() = default;) must be provided for abstract classes to ensure that derived class objects are correctly released through base class pointers; 4. After the derived class inherits, pure virtual functions need to be rewrite, such as Rectangle and Circle to implement area() to calculate their respective areas; 5. Different subclass objects can be managed uniformly through base class pointer arrays to achieve runtime polymorphism. This mechanism simulates Java interface-like functions in C and is an important means to separate interfaces and implement them in object-oriented design.

In C, an abstract class is a class containing at least one pure virtual function and cannot be instantiated and is usually used as a base class to define an interface.

Below is a simple C abstract class example to help you understand its usage and function.

? Example: Abstract base class of graph class

Suppose we want to design a graphics processor that supports multiple graphics (such as circles and rectangles), and each of them can calculate the area. We can define an abstract class Shape that contains a pure virtual function area() .

 #include <iostream>
#include <cmath>
using namespace std;

// Abstract base class Shape {
public:
    // Pure virtual function: no implementation, subclasses must be overridden virtual double area() const = 0;

    // Ordinary virtual destructor (recommended)
    virtual ~Shape() = default;

    // There can be a normal member function void printArea() const {
        cout << "Area: " << area() << endl;
    }
};

// Derived class: Rectangle: public Shape {
private:
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}

    // Implement the pure virtual function double area() const override {
        return width * height;
    }
};

// Derived class: Circle: public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}

    // Implement the pure virtual function double area() const override {
        return M_PI * radius * radius;
    }
};

?User Example

 int main() {
    // Shape shape; // ? Error! Abstract class cannot instantiate Shape* shapes[] = {
        new Rectangle(4.0, 5.0),
        new Circle(3.0)
    };

    for (auto s : shapes) {
        s->printArea(); // polymorphic call}

    // Remember to free memory for (auto s : shapes) {
        delete s;
    }

    return 0;
}

Output:

 Area: 20
Area: 28.2743

? Summary of key points

• Pure virtual function : declared with virtual 返回類型函數(shù)名() = 0;
• Abstract classes cannot be instantiated : they can only be inherited as base classes.
• A derived class must implement all pure virtual functions , otherwise it will become an abstract class itself.
• Virtual destructors are important : prevent undefined behavior when deleting derived class objects.

? When to use abstract classes?

• Define a unified interface (such as draw() , update() , serialize() , etc.).
• Force subclasses to provide implementations of specific functions.
• Implement polymorphism and manage different types of objects in a unified manner.

Basically that's it. Abstract classes are an important means for C to implement the idea of ??"interface" in object-oriented design. Although they do not have interface keywords like Java, similar effects can be achieved through pure virtual functions.

The above is the detailed content of C abstract class example. For more information, please follow other related articles on the PHP Chinese website!