Introdução à classe abstrata em C ++
Uma classe é um tipo de dados definido pelo usuário e possui seus próprios membros e funções de dados. Os membros e funções podem ser usados criando um objeto ou instância dessa classe. A memória é alocada para uma classe somente quando um objeto é criado.
Quando queremos derivar alguns comportamentos ou características de uma classe para outra, usamos o conceito de herança. Este é o método de herdar poucas propriedades da classe pai (classe base) para a classe filho (classe derivada).
Na implementação e herança da classe, quando queremos definir as mesmas funções na classe base e na classe derivada, usamos a palavra-chave 'virtual' junto com a função da classe base. Essa função 'virtual' especifica que a mesma função é redefinida ou substituída na classe derivada.
Uma classe abstrata é uma classe com função virtual pura. Agora, o que é uma função virtual pura? Uma função virtual pura é uma função virtual que não possui corpo e é atribuída como 0. Esse tipo de função é implementado quando precisamos de uma função, mas atualmente não sabemos qual é sua função. Essa função precisa ser implementada ou definida na classe derivada. Caso contrário, a classe derivada também se tornará uma classe abstrata.
Uma função virtual pura é definida da seguinte maneira:
função void virtual () = 0;
Exemplo de classe abstrata em C ++
Aqui, discutimos o exemplo da classe abstrata em C ++ com detalhes:
#include
using namespace std;
class Sample_Class (
int a = 5;
public:
virtual void sample_func() = 0;
void print_func() (
cout << a;
)
);
class Derived_Class : public Sample_Class (
public:
void sample_func() (
cout << "pure virtual function is implemented";
)
);
int main() (
Derived_Class d_object;
d_object.sample_func();
)
Resultado:
Aqui Sample_Class é a classe base e Derived_Class é derivado do Sample_Class. Uma função virtual pura chamada sample_func () é declarada na classe base. É atribuído a 0, o que significa que não possui ninguém e nada é implementado dentro da função. Assim, a classe base tornou-se uma classe abstrata, pois possui uma função virtual pura. Inicialmente, quando o Derived_Class é derivado da classe base, ele também se torna uma classe abstrata. Mas na classe derivada, a classe sample_func () é definida, o que impede que a classe derivada se torne uma classe abstrata. Quando o objeto de classe derivada é criado e a função é chamada, obteremos a saída impressa como 'a função virtual pura é implementada'.
Uma classe abstrata não pode ser instanciada, o que significa que não podemos criar uma instância ou objeto para uma classe abstrata. O objeto não pode ser criado porque a classe não está totalmente implementada. Na verdade, é uma base para uma classe que é implementada totalmente mais tarde. Mas ponteiros ou referências podem ser criados para uma classe abstrata. Esse ponteiro pode ser usado para chamar as funções de classe derivada. Uma classe abstrata pode ter outros membros de dados e funções semelhantes à implementação normal da classe, juntamente com uma função virtual pura.
O ponto acima pode ser explicado através do programa abaixo
class Class1 (
int a;
public:
virtual void func1() = 0;
void func2() (
cout << "base class";
)
);
class Class2 : public Class1 (
public:
void func1() (
cout << "func1 in derived class";
)
);
int main() (
Class1 b; //---------- > this line will cause an error
//Class1 *b = new Class2(); //---------- > pointer can be created, so this line is correct
// b -> func1();
)
Resultado:
Aqui obteremos um erro, pois um objeto não pode ser criado para a classe abstrata.
Em vez disso, a 2ª e a 3ª linha de código podem ser implementadas, um ponteiro pode ser criado e pode ser usado para chamar a função de classe derivada.
Aqui, na função acima Class1 é a classe base e, como possui uma função virtual pura (func1), tornou-se uma classe abstrata. Class2 é derivado da classe pai Class1. O func1 é definido na classe derivada. Na função principal, quando tentamos criar um objeto do tipo classe base, obteremos um erro, pois os objetos não podem ser criados para a classe abstrata. Enquanto que, quando tentamos criar um ponteiro do tipo de classe base, ele será criado com sucesso e podemos apontar para a classe derivada. Esse ponteiro pode ser usado para chamar a função de classe derivada.
Uma classe abstrata pode ter um construtor semelhante à implementação normal da classe. No caso do destruidor, podemos declarar um destruidor virtual puro. É importante ter um destruidor para excluir a memória alocada para a classe. O destruidor virtual puro é um destruidor atribuído a 0, mas deve ser definido pela mesma classe, pois o destruidor geralmente não é substituído.
Exemplo de implementação do construtor e destruidor da Classe Abstrata em C ++
Aqui, discutimos o exemplo da classe abstrata em C ++ com detalhes:
class Base (
public:
int a;
virtual void func1() = 0;
// Constructor
Base(int i) (
a = i;
)
// Pure Virtual destructor
virtual ~Base() = 0;
);
// Pure virtual destructor is defined
Base :: ~Base() (
cout << "Pure virtual destructor is defined here" << endl;
)
class Derived : public Base (
int b;
public:
// Constructor of derived class
Derived(int x, int y) : Base(y) ( b = x; )
// Destructor of derived class
~Derived() (
cout << "Derived class destructor" << endl;
)
//Definition for pure virtual function
void func1() (
cout << "The value of a is " << a << " and b is " << b << endl;
)
);
int main() (
Base *b = new Derived(5, 10);
b->func1();
delete b;
)
Saída :
Aqui, no exemplo acima, a classe Base é uma classe abstrata com função virtual pura func1 (), um construtor e um destruidor virtual puro. A função virtual pura é definida na classe derivada, impedindo a classe derivada de se tornar uma classe abstrata. O destruidor virtual puro é definido pela classe Base fora da classe. Se quisermos definir a função de membro de uma classe fora da classe, o operador de resolução do escopo deve ser usado como mostrado no exemplo. Um ponteiro do tipo de classe base é criado e apontado para a classe derivada. Quando o destruidor é chamado usando 'delete', primeiro o destruidor de classe derivado é chamado e, em seguida, o destruidor de classe base é chamado.
Conclusão
Portanto, para compilar tudo sobre uma classe abstrata, podemos dizer que a classe abstrata é uma classe com uma função virtual pura. Essa função virtual pura deve ser definida na classe derivada; caso contrário, a classe derivada também se tornará uma classe abstrata. O objeto não pode ser criado para a classe abstrata, mas pode ser criado um ponteiro que pode ser apontado para a classe derivada.
Artigos recomendados
Este é um guia para a classe abstrata em C ++. Aqui discutimos a introdução à classe abstrata, bem como a implementação do construtor e destruidor em C ++, juntamente com seu exemplo. Você também pode consultar os seguintes artigos para saber mais:
- Classe abstrata em Python
- Classe abstrata em Java
- Construtor e Destrutor em C ++
- Substituindo em C ++
- Substituindo em Java
- Os 11 principais recursos e vantagens do C ++