C++ Classe e objeto com exemplo

O que é uma aula?

A C++ classe 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 da 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 modelo para um objeto.

Uma classe pode ser um protótipo para uma casa. Ela mostra a localização e as dimensões de portas, janelas, pisos, etc. A partir dessas descrições, podemos construir uma casa. A casa se torna o objeto. É possível criar várias casas a partir do protótipo. Da mesma forma, é possível criar vários objetos a partir 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.

Com a ideia de uma classe como um modelo em mente, o próximo passo é ver como ela é declarada no código.

Declaração de Classe

In C++Uma classe é definida usando a palavra-chave class. Esta deve ser seguida 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.
• O dados, são os dados da classe, normalmente declarados como variáveis.
• O funções são as funções de classe.

Ao declarar o nome e o corpo da classe, surge naturalmente a questão de quem pode usar cada membro.

Palavras-chave privadas e públicas

Você deve ter encontrado 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. Eles só são acessíveis dentro da classe.

Público:

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

Após a criação de uma classe, objetos podem ser criados a partir dela, de forma semelhante à criação de variáveis ​​a partir de um tipo de dado.

Definição do objeto

Os objetos são criados a partir de classes. Os objetos de classe são declarados de forma semelhante à declaração de variáveis. O nome da classe deve vir primeiro, seguido pelo nome do objeto. O objeto é do tipo da classe.

Sintaxe

class-name object-name;

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

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

Uma vez que um objeto é criado, seus membros públicos podem ser acessados ​​diretamente por meio de um operador simples.

Acessando Membros de Dados

Para acessar membros públicos de uma classe, usamos o operador (.)ponto. 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:

Code Explicação:

1. Inclua o arquivo de cabeçalho iostream em nosso código para usar suas funções.
2. Incluindo o namespace std em nosso código para usar suas classes sem chamá-lo.
3. Declare uma classe chamada Phone.
4. Usando o modificador de acesso público para marcar as variáveis ​​que estamos prestes a criar como acessíveis publicamente.
5. Declare o custo variável de um tipo de dados duplo.
6. Declare uma variável inteira chamada slots.
7. Fim do corpo da classe.
8. Chamando a função main(). A lógica do programa deve ser adicionada ao seu corpo.
9. Crie um objeto chamado Y6 do tipo Phone. Isso é chamado de instanciação.
10. Crie um objeto chamado Y7 do tipo Phone. Isso é chamado de instanciação.
11. Acesse o custo variável/membro da classe Phone utilizando o objeto Y6. O valor é definido como 100.0. O custo do Y6 agora está definido como 100.0.
12. Acesse os slots de variáveis/membros da classe Phone usando o objeto Y6. O valor está definido como 2. Os slots para Y6 agora estão definidos como 2.
13. Acesse o custo variável/membro da classe Phone utilizando o objeto Y7. O valor é definido como 200.0. O custo do Y7 agora está definido como 200.0.
14. Acesse os slots de variáveis/membros da classe Phone usando o objeto Y7. O valor está definido como 2. Os slots para Y7 agora estão definidos como 2.
15. Imprima o custo de Y6 no console junto com outro texto.
16. Imprima o custo de Y7 no console junto com outro texto.
17. Imprima o número de slots para Y6 junto com outro texto.
18. Imprima o número de slots para Y7 junto com outro texto.
19. O programa deve retornar um valor após a conclusão bem-sucedida.
20. Fim do corpo da função main().

Membros públicos têm acesso a código externo, mas membros privados seguem regras de acesso muito mais rigorosas.

O que é uma aula particular?

Os membros da classe marcados como privados só podem ser acessados ​​por funções definidas na 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.

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:

Code Explicação:

1. Inclua o arquivo de cabeçalho iostream em nosso código para usar suas funções.
2. Inclua o namespace std em nosso código para usar suas classes sem chamá-lo.
3. Crie uma classe chamada ClassA.
4. Use o modificador de acesso público para marcar o membro da classe a ser criado como acessível publicamente.
5. Crie a função chamada set_a() que recebe um valor inteiro val.
6. Crie uma função chamada get_a().
7. Use o modificador de acesso privado para marcar o membro da classe a ser criado como acessível de forma privada.
8. Declare uma variável inteira chamada a.
9. Fim do corpo da classe.
10. 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.
11. A função get_a() deve retornar o valor da variável a quando invocada.
12. Fim da definição da função get_a().
13. 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.
14. Atribuindo o valor da variável val à variável a.
15. Fim da definição da função set_a().
16. Chame a função main(). A lógica do programa deve ser adicionada ao corpo desta função.
17. Crie uma instância de ClassA e dê a ela o nome de a.
18. Use a instância da classe acima e a função set_a() para atribuir um valor de 20 à variável a.
19. 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().
20. O programa deve retornar o valor após a conclusão bem-sucedida.
21. Fim do corpo da função main().

Os membros protegidos situam-se entre o setor privado e o público, acrescentando uma capacidade fundamental para a herança.

O que é uma classe protegida?

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

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:

Code Explicação:

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

Além de armazenar dados, uma classe também agrupa as funções que operam sobre esses dados.

Funções de membros de classe

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

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

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

Exemplo 4

#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:

Code Explicação:

1. Inclua o arquivo de cabeçalho iostream em nosso programa para usar suas funções.
2. Inclua o arquivo de cabeçalho de string em nosso programa para usar suas funções.
3. Inclua o namespace std em nosso código para usar suas classes sem chamá-lo.
4. Crie uma classe chamada Guru99.
5. Use o modificador de acesso público para marcar os membros da classe que estamos prestes a criar como publicamente acessíveis.
6. Crie uma variável de string chamada tutorial_name.
7. Crie uma variável inteira chamada id.
8. Crie uma função chamada printname(). Esta função não está definida na definição de classe.
9. Crie uma função chamada printid(). Essa função está definida dentro da definição da classe. Seu corpo foi adicionado dentro da definição da classe.
10. Imprima o valor da variável id junto com outro texto no console. Observe que isso foi adicionado ao corpo da função printid(). Só será executado quando a função printid() for chamada.
11. Fim do corpo da função printid().
12. Fim do corpo do curso Guru99.
13. O início da definição da função printname().
14. Imprima o valor da variável tutorial_name no console junto com outro texto. Observe que isso foi adicionado ao corpo da função printname(). Só será executado quando a função printname() for chamada.
15. Fim da definição da função printname().
16. Chame a função main(). A lógica do programa deve ser adicionada ao corpo desta função.
17. Crie uma instância da classe Guru99 e dando-lhe o nome de guru99.
18. Use a instância acima para atribuir um valor de C++ para a variável tutorial_name.
19. Use a instância guru99 para atribuir um valor de 1001 à variável id.
20. Use a instância guru99 para chamar a função printname() .
21. Chame o comando end (end line) para imprimir uma nova linha em branco no console.
22. Use a instância guru99 para chamar a função printid().
23. O programa deve retornar o valor após a conclusão bem-sucedida.
24. Fim do corpo da função main().

Duas funções-membro especiais são executadas automaticamente quando um objeto é criado e quando ele é destruído.

Construtores e Destruidores

O que é um Construtor?

Construtores são funções especiais que inicializam objetos. C++ compiladores Ao criar um objeto, chama-se um construtor. Os construtores ajudam a atribuir valores aos membros da classe. Claro que isso ocorre depois que eles já receberam alguma alocação de memória.

O que é um destruidor?

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

O nome do construtor deve ser semelhante ao nome da classe. Os construtores não possuem um tipo de retorno.

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

Exemplo 5

#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:

Code Explicação:

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

Perguntas Frequentes