Classe e objeto C++ com exemplo

O que é uma classe?

Uma classe C++ combina dados e métodos para manipular os dados em um. As classes também determinam as formas dos objetos. Os dados e métodos contidos em uma classe são conhecidos como membros de classe. Uma classe é um tipo de dados definido pelo usuário. Para acessar os membros da classe, usamos uma instância da classe. Você pode ver uma classe como um blueprint para um objeto.

Uma classe ser um protótipo para uma casa. Mostra a localização e os tamanhos de portas, janelas, pisos, etc. A partir dessas descrições, podemos construir uma casa. A casa torna-se o objeto. É possível criar muitas casas a partir do protótipo. Além disso, é possível criar muitos objetos de uma classe.

Na figura acima, temos um protótipo de casa única. A partir deste protótipo, criamos duas casas com características diferentes.

Neste tutorial, você aprenderá:

O que é uma classe?
Exemplo de classe
Palavras-chave privadas e públicas
Definição do objeto
Acessando membros de dados
Funções dos membros da classe
Construtores e Destruidores

Declaração de Classe

Em C+, uma classe é definida usando a palavra-chave class. Isso deve ser seguido pelo nome da classe. O corpo da classe é então adicionado entre chaves { }.

Sintaxe:

class class-name
   {
   // data
   // functions
   };

O nome da classe é o nome a ser atribuído à classe.
Os dados são os dados da classe, normalmente declarados como variáveis.
As funções são as funções de classe.

Palavras-chave privadas e públicas

Você deve ter se deparado com essas duas palavras-chave. Eles são modificadores de acesso.

Privado:

Quando a palavra-chave private é usada para definir uma função ou classe, ela se torna privada. Esses são apenas acessíveis de dentro da classe.

Público:

A palavra-chave public, por outro lado, torna os dados/funções públicos. Estes são acessíveis de fora da classe.

Definição do objeto

Objetos são criados a partir de classes. Objetos de classe são declarados da mesma forma que as variáveis são declaradas. O nome da classe deve começar, seguido pelo nome do objeto. O objeto do tipo de classe.

Sintaxe:

class-name object-name;

O nome da classe é o nome da classe a partir da qual um objeto deve ser criado.
O nome do objeto é o nome a ser atribuído ao novo objeto.

Esse processo de criação de um objeto a partir de uma classe é conhecido como instanciação.

Acessando membros de dados

Para acessar membros públicos de uma classe, usamos o operador (.)dot. Estes são membros marcados com modificador de acesso público.

Exemplo 1:

#include <iostream>
using namespace std;
class Phone {
public:
	double cost;   
	int slots; 
};
int main() {
	Phone Y6;        
	Phone Y7;        

	Y6.cost = 100.0;
	Y6.slots = 2;

	Y7.cost = 200.0;
	Y7.slots = 2;
	cout << "Cost of Huawei Y6 : " << Y6.cost << endl;
	cout << "Cost of Huawei Y7 : " << Y7.cost << endl;

	cout << "Number of card slots for Huawei Y6 : " << Y6.slots << endl;
	cout << "Number of card slots for Huawei Y7 : " << Y7.slots << endl;

	return 0;
}

Saída:

Aqui está uma captura de tela do código:

Explicação do código :

Inclua o arquivo de cabeçalho iostream em nosso código para usar suas funções.
Incluir o namespace std em nosso código para usar suas classes sem chamá-lo.
Declare uma classe chamada Telefone.
Usando o modificador de acesso público para marcar as variáveis que estamos prestes a criar como acessíveis publicamente.
Declare o custo variável de um tipo de dados duplo.
Declare uma variável inteira chamada slots.
Fim do corpo da classe.
Chamando a função main(). A lógica do programa deve ser adicionada ao seu corpo.
Crie um objeto chamado Y6 do tipo Telefone. Isso é chamado de instanciação.
Crie um objeto chamado Y7 do tipo Telefone. Isso é chamado de instanciação.
Acesse o custo variável/membro da classe Phone usando o objeto Y6. O valor é definido como 100,0. O custo de Y6 agora está definido como 100,0.
Acesse os slots de variável/membro da classe Phone usando o objeto Y6. O valor está definido como 2. Os slots para Y6 agora estão definidos como 2.
Acesse o custo variável/membro da classe Phone usando o objeto Y7. O valor é definido como 200,0. O custo de Y7 agora está definido como 200,0.
Acesse os slots de variável/membro da classe Phone usando o objeto Y7. O valor está definido como 2. Os slots para Y7 agora estão definidos como 2.
Imprima o custo de Y6 no console junto com outro texto.
Imprima o custo de Y7 no console junto com outro texto.
Imprima o número de espaços para Y6 junto com outro texto.
Imprima o número de espaços para Y7 junto com outro texto.
O programa deve retornar um valor após a conclusão bem-sucedida.
Fim do corpo da função main().

O que é uma aula particular?

Membros de classe marcados como privados só podem ser acessados por funções definidas dentro da classe. Qualquer objeto ou função definida fora da classe não pode acessar esses membros diretamente. Um membro de classe privada só é acessado por funções de membro e amigo.

O que é uma classe protegida?

Os membros da classe marcados como protegidos têm vantagem sobre os marcados como privados. Eles podem ser acessados por funções dentro da classe de sua definição. Além disso, eles podem ser acessados de classes derivadas.

Exemplo 2:

#include <iostream>
using namespace std;
class ClassA {
public:
	void set_a(int val);
	int get_a(void);

private:
	int a;
};
int ClassA::get_a(void) {
	return a;
}
void ClassA::set_a(int val) {
	a = val;
}
int main() {
	ClassA a;
	a.set_a(20); 
	cout << "Value of a is: " << a.get_a(); 
	return 0;
}

Saída:

Aqui está uma captura de tela do código:

Explicação do código:

Inclua o arquivo de cabeçalho iostream em nosso código para usar suas funções.
Inclua o namespace std em nosso código para usar suas classes sem chamá-lo.
Crie uma classe chamada ClassA.
Use o modificador de acesso público para marcar o membro da classe a ser criado como acessível publicamente.
Crie a função chamada set_a() que recebe um valor inteiro val.
Crie uma função chamada get_a().
Use o modificador de acesso privado para marcar o membro da classe a ser criado como acessível de forma privada.
Declare uma variável inteira chamada a.
Fim do corpo da classe.
Use o nome da classe e o operador de resolução de escopo para acessar a função get_a(). Queremos definir o que a função faz quando invocada.
A função get_a() deve retornar o valor da variável a quando invocada.
Fim da definição da função get_a().
Use o nome da classe e o operador de resolução de escopo para acessar a função set_a(). Queremos definir o que a função faz quando invocada.
Atribuindo o valor da variável val à variável a.
Fim da definição da função set_a().
Chame a função main(). A lógica do programa deve ser adicionada ao corpo desta função.
Crie uma instância de ClassA e dê a ela o nome a.
Use a instância de classe acima e a função set_a() para atribuir um valor de 20 à variável a.
Imprimindo algum texto junto com o valor da variável a no console. O valor da variável a é obtido chamando a função get_a().
O programa deve retornar o valor após a conclusão bem-sucedida.
Fim do corpo da função main().

Exemplo 3:

#include <iostream>
using namespace std;
class ParentClass {
protected:
	int value;
};
class ChildClass : public ParentClass {
public:
	void setId(int x) {
		value = x;
	}
	void displayValue() {
	cout << "Value is: " << value << endl;
	}
};
int main() {
	ChildClass c;
	c.setId(21);
	c.displayValue();
	return 0;
}

Saída:

Aqui está uma captura de tela do código:

Explicação do código:

Inclua o arquivo de cabeçalho iostream em nosso código para usar suas funções.
Inclua o namespace std em nosso código para usar suas classes sem chamá-lo.
Crie uma classe chamada ParentClass.
Use o modificador de acesso protegido para marcar o membro de classe a ser criado como protegido.
Crie uma variável inteira chamada value.
Fim do corpo da classe.
Crie uma nova classe chamada ChildClass que herde a ParentClass.
Use o modificador de acesso protegido para marcar o membro de classe a ser criado como acessível a classes filhas.
Crie a função chamada setId() que recebe um valor inteiro x.
Atribuindo o valor da variável x ao valor da variável.
Fim da definição da função setId().
Crie uma função chamada displayValue().
Imprima o valor da variável chamada value no console junto com outro texto.
Fim do corpo da função displayValue().
Fim do corpo da classe chamada ChildClass.
Chame a função main(). A lógica do programa deve ser adicionada ao corpo desta função.
Crie uma instância de ChildClass e dê a ela o nome c.
Use a instância de classe acima e a função setId() para atribuir um valor de 21 à variável x.
Use a instância de classe acima para chamar a função chamada displayValue().
O programa deve retornar o valor após a conclusão bem-sucedida.
Fim do corpo da função main().

Funções dos membros da classe

As funções nos ajudam a manipular dados. As funções de membro de classe podem ser definidas de duas maneiras:

Dentro da definição da classe
Fora da definição da classe

Se uma função deve ser definida fora de uma definição de classe, devemos usar o operador de resolução de escopo (::). Isso deve ser acompanhado pelos nomes de classe e função.

Exemplo 2:

#include <iostream>
#include <string>
using namespace std;
class Guru99
{
public:
	string tutorial_name;
	int id;
	void printname();
	void printid()
	{
		cout << "Tutorial id is: "<< id;
	}
};
void Guru99::printname()
{
	cout << "Tutorial name is: " << tutorial_name;
}
int main() {
	Guru99 guru99;
	guru99.tutorial_name = "C++";
	guru99.id = 1001;
	guru99.printname();
	cout << endl;
	guru99.printid();
	return 0;
}

Saída:

Aqui está uma captura de tela do código:

Explicação do código:

Inclua o arquivo de cabeçalho iostream em nosso programa para usar suas funções.
Inclua o arquivo de cabeçalho de string em nosso programa para usar suas funções.
Inclua o namespace std em nosso código para usar suas classes sem chamá-lo.
Crie uma classe chamada Guru99.
Use o modificador de acesso público para marcar os membros da turma que estamos prestes a criar como acessíveis ao público.
Crie uma variável de string chamada tutorial_name.
Crie uma variável inteira chamada id.
Crie uma função chamada printname(). Esta função não está definida na definição da classe.
Crie uma função chamada print(). Esta função é definida dentro da definição de classe. Seu corpo foi adicionado na definição da classe.
Imprima o valor da variável id junto com outro texto no console. Observe que isso foi adicionado no corpo da função printid(). Ele só será executado quando a função printid() for chamada.
Fim do corpo da função printid().
Fim do corpo da classe Guru99.
O início da definição da função printname().
Imprima o valor da variável tutorial_name no console junto com outro texto. Observe que isso foi adicionado no corpo da função printname(). Ele só será executado quando a função printname() for chamada.
Fim da definição da função printname().
Chame a função main(). A lógica do programa deve ser adicionada ao corpo desta função.
Crie uma instância da classe Guru99 e dê a ela o nome guru99.
Use a instância acima para atribuir um valor de C++ à variável tutorial_name.
Use a instância guru99 para atribuir um valor de 1001 ao ID da variável.
Use a instância guru99 para chamar a função printname() .
Chame o comando end (end line) para imprimir uma nova linha em branco no console.
Use a instância guru99 para chamar a função printid().
O programa deve retornar o valor após a conclusão bem-sucedida.
Fim do corpo da função main().

Construtores e Destruidores

O que são Construtores?

Construções são funções especiais que inicializam objetos. Os compiladores C++ chamam um construtor ao criar um objeto. Os construtores ajudam a atribuir valores aos membros da classe. Claro, isso é depois de terem sido alocados algum espaço de memória.

O que são Destruidores?

Os destruidores, por outro lado, ajudam a destruir objetos de classe.

O nome do construtor deve ser semelhante ao nome da classe. Construtores não têm um tipo de retorno.

O construtor pode ser definido dentro ou fora do corpo da classe. Se definido fora do corpo da classe, deve ser definido com o nome da classe e o operador de resolução de escopo (::).

Exemplo 3:

#include <iostream>  
using namespace std;
class ClassA {
public:
	ClassA() {
		cout << "Class constructor called"<<endl;
	}
	~ClassA() {
		cout << "Class destructor called"<<endl;
	}
};

int main() {
	ClassA a;
	int p = 1;
		if (p) {
			ClassA b; 
		}   
}

Saída:

Aqui está uma captura de tela do código:

Explicação do código:

Inclua o arquivo de cabeçalho iostream no código para usar suas funções.
Inclua o namespace std em nosso código para usar suas classes sem chamá-lo.
Crie uma classe chamada ClassA.
Use o modificador de acesso público para marcar o membro que estamos prestes a criar como acessível publicamente.
Crie um construtor para a classe.
Texto a ser impresso no console quando o construtor é chamado. O endl é uma palavra-chave C++, que significa linha final. Move o cursor do mouse para a próxima linha.
Fim do corpo do construtor da classe.
Crie um destruidor para a classe.
Texto a ser impresso no console quando o destruidor for chamado. O endl é uma palavra-chave C++, que significa linha final. Move o cursor do mouse para a próxima linha.
Fim do corpo do destruidor.
Fim do corpo da classe.
Chame a função main(). A lógica do programa deve ser adicionada ao corpo desta função.
Crie um objeto de classe e dê a ele o nome a. O construtor será chamado.
Crie uma variável inteira chamada p e atribua a ela o valor 1.
Crie um bloco de instrução if usando a variável p.
Crie um objeto de classe e dê a ele o nome b. O destruidor será chamado.
Fim do corpo da instrução if.
Fim do corpo da função main().

Resumo:

C++ é orientado a objetos.
As classes formam os principais recursos do C++ que o tornam orientado a objetos.
Uma classe C++ combina dados e métodos para manipular os dados em um.
Uma classe é um modelo para um objeto.
As classes determinam a forma de um objeto.
Os dados e métodos contidos em uma classe são conhecidos como membros da classe.
Para acessar os membros da classe, você deve usar uma instância da classe.
Para criar uma classe, usamos a palavra-chave class.
As funções de membro da classe podem ser definidas dentro ou fora de uma classe.

Mapa na biblioteca de modelos padrão C++ (STL) com exemplo de impressão Polimorfismo C++ com Exemplo

Linguagem C