Última actualización：2026-10-12

Funciones virtuales puras y clases abstractas en C++¶

Sobre el autor:¶

Cuenta pública personal de WeChat:

wechat

1. Funciones virtuales puras y clases abstractas¶

Una función virtual pura (o función abstracta) en C++ es una función virtual que no implementamos. ¡Solo la declaramos! Una función virtual pura se declara asignando 0 en su declaración.

// 抽象类
Class A {
public: 
    virtual void show() = 0; // 纯虚函数
    /* Other members */
};

* Función virtual pura: una función virtual sin cuerpo de función. * Clase abstracta: una clase que contiene funciones virtuales puras.

Una clase abstracta solo puede utilizarse como clase base para derivar nuevas clases; no se pueden crear objetos de una clase abstracta, y los punteros y referencias a la clase abstracta -> deben apuntar a objetos de clases derivadas de la clase abstracta.

Ejemplos de código: abstract_base.h y pure_virtual.cpp

2. Implementar una clase abstracta¶

Dentro de una clase abstracta: en las funciones miembro se puede llamar a una función virtual pura, pero dentro del constructor/destructor no se puede utilizar una función virtual pura.

Si una clase deriva de una clase abstracta, debe implementar todas las funciones virtuales puras de la clase base para poder convertirse en una clase no abstracta.

// A为抽象类
class A {
public:
    virtual void f() = 0;  // 纯虚函数
    void g(){ this->f(); }
    A(){}  // 构造函数
};

class B : public A{
public:
    void f(){ cout<<"B:f()"<<endl;}  // 实现了抽象类的纯虚函数
};

Ejemplo de código: abstract.cpp

3. Puntos importantes¶

Una función virtual pura convierte una clase en una clase abstracta

// 抽象类至少包含一个纯虚函数
class Base{
public: 
    virtual void show() = 0; // 纯虚函数
    int getX() { return x; } // 普通成员函数

private:
     int x; 
};

Punteros y referencias de tipo clase abstracta

class Derived : public Base { 
public: 
    void show() { cout << "In Derived \n"; } // 实现抽象类的纯虚函数
    Derived(){} // 构造函数
}; 

int main(void) 
{ 
    //Base b;  // error! 不能创建抽象类的对象
    //Base *b = new Base(); error!

    Base *bp = new Derived(); // 抽象类的指针和引用 -> 由抽象类派生出来的类的对象
    bp->show();
    return 0; 
}

Si no sobrescribimos la función virtual pura en la clase derivada, la clase derivada también se convierte en una clase abstracta
```
// Derived为抽象类
class Derived: public Base 
{ 
public: 
//    void show() {}
}; 
```

Una clase abstracta puede tener constructor

// 抽象类
class Base { 
    protected: 
        int x; 
    public: 
        virtual void fun() = 0; 
        Base(int i) { x = i; }  // 构造函数
}; 
// 派生类
class Derived: public Base 
{ 
    int y; 
public: 
    Derived(int i, int j) : Base(i) { y = j; } // 构造函数
    void fun() { cout << "x = " << x << ", y = " << y; }
};

El constructor no puede ser virtual, mientras que el destructor sí puede ser un destructor virtual

// 抽象类
class Base  {
public:
    Base(){ cout << "Constructor: Base" << endl; }
    virtual ~Base(){ cout << "Destructor : Base" << endl; }

    virtual void func() = 0;
};

class Derived: public Base {
public:
    Derived(){ cout << "Constructor: Derived" << endl; }
    ~Derived(){ cout << "Destructor : Derived" << endl;}

    void func(){cout << "In Derived.func()." << endl;}
};

Cuando un puntero a la clase base apunta a un objeto de la clase derivada y se elimina el objeto, puede que queramos que se llame al destructor apropiado. Si el destructor no es virtual, solo se llamará al destructor de la clase base.

4. Ejemplo completo¶

¡Las clases abstractas se implementan a través de la herencia por parte de las clases derivadas!

Ejemplo de código: derived_full.cpp