Ir para o conteúdo

Última atualização：2026-10-12

Funções virtuais puras e classes abstratas em C++

Sobre o autor:

Conta oficial do WeChat:

wechat

1.Funções virtuais puras e classes abstratas

Uma função virtual pura (ou função abstrata) em C++ é uma função virtual que não implementamos! Basta declará-la! Declara-se uma função virtual pura atribuindo 0 na declaração! 

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

  • Função virtual pura: uma função virtual sem corpo
  • Classe abstrata: uma classe que contém funções virtuais puras

Uma classe abstrata só pode ser usada como classe base para derivar novas classes; não é possível criar objetos de uma classe abstrata; ponteiros e referências de classe abstrata -> objetos de classes derivadas da classe abstrata!

Exemplos de código: abstract_base.h, pure_virtual.cpp

2.Implementando uma classe abstrata

Dentro de uma classe abstrata: é possível chamar funções virtuais puras dentro de funções membro, mas não é possível usar funções virtuais puras dentro do construtor/destrutor.

Se uma classe é derivada de uma classe abstrata, ela só se torna não abstrata quando implementa todas as funções virtuais puras da classe base. 

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

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

Exemplo de código: abstract.cpp

3.Pontos importantes

  • Uma função virtual pura torna uma classe abstrata 

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

private:
     int x; 
};

  • Ponteiros e referências do tipo de uma classe abstrata 

    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; 
}

  • Se não sobrescrevermos a função virtual pura na classe derivada, a classe derivada também se tornará abstrata 

    // Derived为抽象类
class Derived: public Base 
{ 
public: 
//    void show() {}
};

  • Classes abstratas podem ter construtores 

    // 抽象类
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; }
};

  • Construtores não podem ser funções virtuais, mas destrutores podem ser destrutores virtuais 

    // 抽象类
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;}
};

    Quando um ponteiro da classe base aponta para um objeto da classe derivada e o objeto é excluído, podemos querer que o destrutor apropriado seja chamado. Se o destrutor não for virtual, somente o destrutor da classe base será chamado.

4.Exemplo completo

A classe abstrata é herdada e implementada pela classe derivada!

Exemplo de código: derived_full.cpp

Tópicos relacionados

Comentários