Introdução às classes e objetos C ++

Objetos são a maior diferença entre C ++ e C. Um dos nomes mais antigos para C ++ era C com Classes.

Uma classe é uma definição de um objeto. É um tipo como int. Uma classe se assemelha a struct com apenas uma diferença: todos os membros da estrutura são públicos por padrão. Todos os membros das aulas são particulares.

Lembre-se: uma classe é um tipo, e um objeto dessa classe é apenas um variável.

Antes de podermos usar um objeto, ele deve ser criado. A definição mais simples de uma classe é:

 nome da classe {

 // membros

 }

Esta classe de exemplo abaixo modela um livro simples. Usar OOP permite abstrair o problema e pensar sobre ele, e não apenas variáveis ​​arbitrárias.

 // exemplo um

 #incluir 

 #incluir 

 livro escolar

 {

 int PageCount;

 int CurrentPage; 

 público:

 Livro (int Numpages); // Construtor

 ~ Book () {}; // Destructor

 void SetPage (int PageNumber);

 int GetCurrentPage (void);

 }; 

 Book:: Book (int NumPages) {

 PageCount = NumPages;

 }

 void Book:: SetPage (int PageNumber) {

 CurrentPage = PageNumber;

 }

 int Book:: GetCurrentPage (void) {

 return CurrentPage;

 }

 int main () {

 Livro ABook (128);

 Um livro. SetPage (56);

 std:: cout << "Página Atual" << ABook. GetCurrentPage () << std:: endl;

 retornar 0;

 }

Todo o código de livro escolar até o int Book:: GetCurrentPage (void) { A função faz parte da classe o a Principal() A função existe para tornar esse aplicativo executável.

No a Principal() função, uma variável ABook do tipo Book é criada com o valor 128. Assim que a execução chega a esse ponto, o objeto ABook é construído. Na próxima linha, o método Um livro. SetPage () é chamado e o valor 56 atribuído à variável de objeto Um livro. Pagina atual. Então cout gera esse valor chamando o Um livro. GetCurrentPage () método.

Quando a execução atinge o retornar 0; o objeto ABook não é mais necessário pelo aplicativo. O compilador gera uma chamada para o destruidor.

Tudo entre Livro escolar e a } é a declaração de classe. Esta classe tem dois membros privados, ambos do tipo int. Estes são privados porque o acesso padrão aos membros da classe é privado.

o público: diretiva diz ao compilador que acessa a partir daqui é público. Sem isso, ainda seria privado e impediria que as três linhas na função main () acessassem os membros do Abook. Tente comentar o público: alinhar e recompilar para ver os erros de compilação subsequentes.

Esta linha abaixo declara um construtor. Essa é a função chamada quando o objeto é criado pela primeira vez.

 Livro (int Numpages); // Construtor 

É chamado a partir da linha

 Livro ABook (128); 

Isso cria um objeto chamado ABook do tipo Book e chama a função Book () com o parâmetro 128.

Em C ++, o construtor sempre tem o mesmo nome que a classe. O construtor é chamado quando o objeto é criado e é onde você deve colocar seu código para inicializar o objeto.

No livro A próxima linha após o construtor, o destruidor. Ele tem o mesmo nome que o construtor, mas com um ~ (til) na frente dele. Durante a destruição de um objeto, o destruidor é chamado para arrumar o objeto e garantir que recursos como memória e identificador de arquivo usados ​​pelo objeto sejam liberados.

Lembrar- uma classe xyz possui uma função construtora xyz () e uma função destruidora ~ xyz (). Mesmo se você não declarar, o compilador os adicionará silenciosamente.

O destruidor é sempre chamado quando o objeto é finalizado. Neste exemplo, o objeto é implicitamente destruído quando sai do escopo. Para ver isso, modifique a declaração do destruidor para isso:

 ~ Book () {std:: cout << "Destrutor chamado";}; // Destructor 

Esta é uma função embutida com código na declaração. Outra maneira de inline é adicionar a palavra inline

 inline ~ Book (); // Destructor

e adicione o destruidor como uma função como esta.

 Livro embutido:: ~ Livro (vazio) { 

 std:: cout << "Destrutor chamado";

 }

Funções embutidas são dicas para o compilador para gerar código mais eficiente. Eles devem ser usados ​​apenas para pequenas funções, mas se usados ​​em locais apropriados - como no interior rotações- pode fazer uma diferença considerável no desempenho.

Melhor prática para objetos é tornar todos os dados privados e acessá-los através de funções conhecidas como funções de acessador. SetPage () e GetCurrentPage () são as duas funções usadas para acessar a variável de objeto Pagina atual.

Mudar o classe declaração para estruturar e recompilar. Ainda deve ser compilado e executado corretamente. Agora as duas variáveis Contagem de páginas e Pagina atual são acessíveis ao público. Adicione esta linha após o Book ABook (128) e ela será compilada.

 Um livro. PageCount = 9;

Se você alterar a estrutura novamente para classe e recompilar, essa nova linha não será mais compilada como Contagem de páginas agora é privado novamente.

Após o corpo da declaração da classe Book, há as quatro definições das funções de membro. Cada um é definido com o prefixo Book:: para identificá-lo como pertencente a essa classe.:: é chamado identificador de escopo. Ele identifica a função como parte da classe. Isso é óbvio na declaração de classe, mas não fora dela.

Se você declarou uma função de membro em uma classe, deve fornecer o corpo da função dessa maneira. Se você quiser que a classe Book seja usada por outros arquivos, poderá mover a declaração do book para outra cabeçalho, talvez chamado book.h. Qualquer outro arquivo pode incluí-lo com

 #include "book.h" 

Este exemplo demonstrará herança. Este é um aplicativo de duas classes com uma classe derivada de outra.

 #incluir 

 #incluir 

 classe Point

 {

 int x, y;

 público:

 Ponto (int atx, int aty); // Construtor

 inline virtual ~ Point (); // Destructor

 Draw vazio virtual ();

 }; 

 Classe Círculo: Ponto Público {

 raio int;

 público:

 Círculo (int atx, int aty, int theRadius);

 inline virtual ~ Circle ();

 Draw vazio virtual ();

 };

 Point:: Point (int atx, int aty) {

 x = atx;

 y = aty;

 }

 inline Point:: ~ Point (vazio) { 

 std:: cout << "Destrutor de ponto chamado";

 }

 void Point:: Draw (void) {

 std:: cout << "Ponto:: Desenhe o ponto em" << x << "" << y << std:: endl;

 }

 Circle:: Circle (int atx, int aty, int theRadius): Point (atx, aty) {

 raio = o raio;

 }

 Circle inline:: ~ Circle () {

 std:: cout << "Destrutor de círculo chamado" << std:: endl;

 }

 Círculo vazio:: Empate (vazio) {

 Point:: Draw ();

 std:: cout << "circle:: Draw point" << "Radius" << raio << std:: endl;

 }

 int main () {

 Círculo ACircle (10,10,5);

 Um círculo. Desenhar() ;

 retornar 0;

 }

O exemplo tem duas classes, Point e Circle, modelando um ponto e um círculo. Um ponto tem coordenadas xey. A classe Circle é derivada da classe Point e adiciona um raio. Ambas as classes incluem um Desenhar() função membro. Para manter este exemplo curto, a saída é apenas texto.

A classe Círculo é derivado do Ponto classe. Isso é feito nesta linha:

 classe Círculo: Ponto {

Como é derivado de uma classe base (Point), Circle herda todos os membros da classe.

 Ponto (int atx, int aty); // Construtor

 inline virtual ~ Point (); // Destructor

 Draw vazio virtual ();

 Círculo (int atx, int aty, int theRadius);

 inline virtual ~ Circle ();

 Draw vazio virtual ();

Pense na classe Circle como a classe Point com um membro extra (raio). Herda as funções de membro da classe base e variáveis ​​privadas x e y.

Ele não pode atribuir ou usá-los, exceto implicitamente porque eles são particulares, portanto, ele deve ser feito através da lista Inicializador do construtor Circle. Isso é algo que você deve aceitar como está por enquanto. Voltarei às listas de inicializadores em um tutorial futuro.

No construtor Circle, antes de theRadius é atribuído ao raio, a parte Point do Circle é construída por meio de uma chamada ao construtor de Point na lista de inicializadores. Esta lista é tudo entre: e {abaixo.

 Circle:: Circle (int atx, int aty, int theRadius): Ponto (atx, aty) 

Aliás, a inicialização do tipo de construtor pode ser usada para todos os tipos internos.

 int a1 (10);

 int a2 = 10;

Ambos fazem o mesmo.

Polimorfismo é um termo genérico que significa "muitas formas". Em C ++, a forma mais simples de polimorfismo é a sobrecarga de funções. Por exemplo, várias funções chamadas SortArray (arraytype) onde sortarray pode ser um matriz de ints ou dobra.

Só estamos interessados ​​na forma OOP de polimorfismo aqui, no entanto. Isso é feito criando uma função (por exemplo, Draw ()) virtual na classe base Point e, em seguida, substituindo-o no classe derivada Círculo.

Embora a função Desenhar() é virtual na classe derivada Círculo, isso não é realmente necessário - é apenas um lembrete para mim de que isso é virtual. Se a função em uma classe derivada corresponder a uma função virtual na classe base nos tipos de nome e parâmetro, ela será automaticamente virtual.

Desenhar um ponto e desenhar um círculo são duas operações muito diferentes, com apenas as coordenadas do ponto e do círculo em comum; portanto, é importante que a correta Desenhar() é chamado. Como o compilador consegue gerar código que obtém a função virtual correta será abordado em um tutorial futuro.

Um construtor é uma função que inicializa os membros de um objeto. Um construtor sabe apenas como criar um objeto de sua própria classe.

Os construtores não são herdados automaticamente entre as classes base e derivada. Se você não fornecer um na classe derivada, será fornecido um padrão, mas isso pode não fazer o que você deseja.

Se nenhum construtor for fornecido, um padrão será criado pelo compilador sem nenhum parâmetro. Sempre deve haver um construtor, mesmo que seja o padrão e vazio. Se você fornecer parâmetros a um construtor, um padrão NÃO será criado.

Alguns pontos sobre construtores:

• Construtores são apenas funções com o mesmo nome da classe.
• Os construtores têm como objetivo inicializar os membros da classe quando uma instância dessa classe é criada.
• Os construtores não são chamados diretamente (exceto através das listas de inicializadores)
• Os construtores nunca são virtuais.
• Vários construtores para a mesma classe podem ser definidos. Eles devem ter parâmetros diferentes para distingui-los.

Há muito mais para aprender sobre construtores, por exemplo, construtores padrão, atribuição e construtores de cópia. Isso será discutido na próxima lição.

Um destruidor é uma função de membro da classe que tem o mesmo nome que o construtor (e a classe), mas com um ~ (til) na frente.

 ~ Círculo ();

Quando um objeto sai do escopo ou, mais raramente, é explicitamente destruído, seu destruidor é chamado. Por exemplo, se o objeto possui variáveis ​​dinâmicas, como ponteiros, elas precisam ser liberadas e o destruidor é o local apropriado.

Diferentemente dos construtores, os destruidores podem e devem ser virtualizados se você tiver derivado classes. No Ponto e Círculo exemplo de classes, o destruidor não é necessário, pois não há trabalho de limpeza a ser feito (serve apenas como exemplo). Se houvesse variáveis ​​de membro dinâmicas (como ponteiros), isso exigiria a liberação para evitar vazamentos de memória.

Além disso, quando a classe derivada adiciona membros que precisam ser arrumados, são necessários destruidores virtuais. Quando virtual, o destruidor de classe mais derivado é chamado primeiro, depois o destruidor de seu ancestral imediato é chamado, e assim por diante, até a classe base.

No nosso exemplo,

 ~ Círculo ();

então

 ~ Point ();

O destruidor das classes base é chamado por último.

Isso completa esta lição. Na próxima lição, aprenda sobre construtores padrão, construtores de cópia e atribuição.