Jump to content

Turbine o seu Perfil

Confira a atualização e participe do clube!
Clique e saiba mais

Junte-se ao Clube de Membros VIP

Tenha destaque e diversos benefícios!
Confira Aqui

Acesse nosso Discord

Conheça nossos canais interativos
Confira Aqui
Notícia
  • Adquira já o seu VIP!
Sign in to follow this  
#include <Aprendiz.h>

c++ Classes e objetos em C++ - Definições simples.

Recommended Posts

1- Necessário conhecimento básico da linguagem c++, paciência e bom ânimo.

2- Tópico criado no intuito de passar as definições mais básicas sobre o assunto, para ajudar quem está nesta etapa e assim como foi cmg, sofre para compreender alguns principios.

3 - Não registrado coisas sobre polimorfismo, herança e etc.

4 - Pouco uso de termos técnicos.

5 - Se achar algum erro, fique a vontade para corrigir!

POO - Programação Orientada a Objetos

 

Mas o que diabos é isso? Ouvimos/lemos por aí, c++ é orientado a objetos. Mas no começo, c e c++ parecem exatamente a mesma coisa quando não se entende o que são objetos.

O que diferencia c de c++ é isso, objetos.

Qual o primeiro passo para ter um objeto?

R: Classes.

 

Classes são estruturas de dados, semelhantes à struct do c, porém com mais recursos e possibilidades.

 

Como criar uma classe em c++

 

Class classe_de_alunos {
int idade;
string nome;
}

 

Isso é uma classe. Uma classe bem simples, que poderia ser substituída por struct. Até aí, quase não há diferença.

 

Você pode, assim como nas structs, declarar se um membro da classe é privado ou publico. Por bom costume, em programas grandes se usa as variaveis em modo privado. Somente as funções-membros da classe a que pertencem poderão "vê-las", não todas. Ex:

 



Class classe_de_alunos {
private:
int idade;
string nome;
public:
void receber_aluno();
}

void alunos_bons();

...
}

a função receber_aluno() poderia manipular os endereços privados da classe, já alunos_bons() não poderiam, pois não foi feita/implementada como membro da classe a que pertencem as variáveis.

 

 

 

Dito isso, podemos agora praticar o que aprendemos até aqui:

 

Class classe_de_alunos {
private:
  int idade; 
  string nome;
public:
  void receber_alunos(string nome, int idade)
{
this->nome = nome;
this->idade = idade;
}

 

Usamos parametros para alocar algum valor nas variaveis-membro da classe, pois são privadas e não poderiam ser alteradas de fora da classe. Por isso, trazemos para dentro da classe o valor desejado, através dos parametros, para só então armazená-los nas variaveis-membro da classe. Usamos "this->" para literalmente "apontar" que estamos nos referindo a variavel de DENTRO da classe, e não aos parametros. Ex: o nome da variavel-membro é nome, mas o "nome" do parâmetro também é "nome", então se escrevermos nome=nome, o compilador não entende e não altera as variaveis-membro da classe.

 

podemos, e devemos, fazer o que fizemos acima, da seguinte forma :

 



Class classe_de_alunos {
private:
int idade;
string nome;
public:
void receber_aluno(string nome, int idade);
}

void classe_de_alunos::receber_aluno(string nome, int idade)
{
this-> idade = idade;
this->nome = nome;
}

 

Mas o que diabos foi isso?

 

Void class_de_alunos::receber_aluno(string nome, int idade) : o que declaramos dentro da classe foi o "protótipo" da nossa função, por boa prática, implementamos ela fora da classe. Basta apenas colocar o tipo dela e o nome da classe a que ela pertence antes das instruções que o compilador entende que vc está falando dela. Void é o tipo da função que declaramos dentro da classe, classe_de_alunos classe de onde esto tirando a função, e receber_aluno(string nome, int idade) função que eu criei dentro da classe. Entendeu? Necessário o uso do :: entre o nome da classe e o da função.

 

feito tudo isso, nos falta agora uma função que nos mostre o que tem dentro das variaveis-membro após a execução da função(método) "receber_alunos".

vamos então criar algo que nos mostre o que tem nelas.

 

 void mostrar()
 {
     cout << nome <<endl;
     cout << idade;
 }
};

Neste caso não há a necessidade de especificar com o uso do this-> qual é a variável membro, pois não há parâmetros.

 

nossa classe ficou assim :

 

class classe_de_alunos {
private:
  int idade;
  string nome;
public:
  void receber_alunos(string nome, int idade)
{
this->nome = nome;
this->idade = idade;
}
 void mostrar()
 {
     cout << nome <<endl;
     cout << idade;
 }
};

 

ou, por questão de FACILIDADE de manutenção e até mesmo por estética, limpeza, podemos fazer da outra forma, com apenas os protótipos dentro e as instruções fora:

 

#include <iostream>

using namespace std;

class classe_de_alunos {
private:
  int idade;
  string nome;
public:
  void receber_alunos(string nome, int idade);
 void mostrar();
};

void classe_de_alunos::receber_alunos(string nome, int idade)
{
this->nome = nome;
this->idade = idade;
}

void classe_de_alunos::mostrar()
 {
     cout << nome <<endl;
     cout << idade;
 }

int main()
{
}

Nota: as classes e suas respectivas funções DEVEM ser definidas e implementadas ANTES do main, logo no incio do código.

 

O objeto

 

int main()
{
  classe_de_alunos meusAlunos;    // instanciação de objeto ( criação do objeto, instancia, instanciar, são termos técnicos que podemos simplificar como" criar "  )
}

 

aí está o nosso objeto: meusAlunos.

Como vamos entender isso? Qual é a relação entre os dois? Pq uma classe não é um objeto propriamente dito?

Para facilitar, você pode entender dessa forma:

 

a classe é a PLANTA da casa, ou seja, todo o desenho dela, a maquete, as medidas, etc. E meusAlunos, é um casa construída a partir daquela maquete.

Classe é uma planta, e o objeto é a casa que saiu dessa planta.

Classe representa todos os tipos de carro, e o FIAT UNO é o objeto que saiu desse tipo.

Todo carro tem rodas, farol, janelas, motor. Todo objeto que seja carro, terá esse padrão: rodas, farol, janelas, motor, etc.

Classe é um TIPO de relógio, e o objeto criado a partir desse tipo é um ROLEX.

Todo relógio tem ponteiros, e marca as horas. Todo objeto do tipo relógio tem ponteiros e marca as horas.

 

ou seja, Classe_de_alunos é um TIPO, Uma Planta, um Molde, meusAlunos é um objeto que tem todos esses atributos e funções que especificamos em Classe_de_alunos.

 

Usando nosso objeto.

 

para usar nosso objeto, vamos usar o nome dele, no caso meusAlunos, seguido de . (ponto) e o nome da função dele que queremos usar.

 


int main()
{
string nome;
int idade;
classe_de_alunos meusAlunos; /// Objeto do tipo classe_de_alunos. Objeto nos moldes de classe_de_alunos. Casa feita através da planta classe_de_alunos.
cout <<"Digite o nome do aluno: ";
getline(cin, nome);
cout <<"Digite a idade do aluno: ";
cin >> idade;
meusAlunos.receber_alunos(nome, idade)

 

usamos nossa função receber_alunos, especificada lá dentro da classe. Agora, essa função pertence ao nosso objeto meusAlunos e a qualquer outro que criemos a partir da classe classe_de_alunos.

Passamos nossos valores por parametro, aí nossa função fez o que mandamos, guardou os valores dos parametros nas variaveis-membro da nossa classe. Agora vamos pedir para ver como ficaram lá dentro do nosso objeto:

 

meusAlunos.mostrar();

 

lembra que especificamos dentro da nossa classe que quando um objeto quisesse chamar essa funçao, ela retornaria nossas variaveis? pois é isso que ela fará, irá retornar o que guardamos lá dentro.

 

int main()
{
   string nome;
   int idade;
   classe_de_alunos meusAlunos;
   cout <<"Digite o nome: ";
   getline(cin, nome);
   cout <<"Digite a idade: ";
   cin >> idade;
   meusAlunos.receber_alunos(nome, idade);
   meusAlunos.mostrar();
   return 0;
}

 

Você pode criar várias casas a partir de uma única planta, correto? A mesma coisa com objetos. Você pode criar vários a partir de uma classe, e um existirá independente do outro. Os comodos da casa serão todos iguais, o que mudará é o que guardamos lá dentro dela. nossos objetos tbm serão todos iguais, o que mudará será os dados que guardaremos dentro deles.

 

2 - Construtores, o método set e o método get

 

Já sabemos o que é uma classe e como usá-la, porém existem ainda muitas definições para explorar, tentarei expor aqui o mais primordial para se fazer uma classe digna e com respeito.

 

Construtores:

Construtor é o que vai construir a casa, é quem vai colocar os tijolos, as vigas e etc.

Construtor no objeto, no entanto, é quem vai colocar DADOS dentro dele.

 

um construtor, é basicamente o exemplo que utilizamos chamado receber_aluno, só que os construtores levam, obrigatoriamente, o mesmo nome da classe. E, obrigatoriamente, não retornam nenhum tipo de valor, são sempre VOID(vazios).

Outra característica do construtor é que, ele sempre se auto-executará logo que o objeto for criado.

 

vamos usar a nossa função receber_aluno e transformá-la num construtor.

 

void receber_alunos(string nome, int idade); // Antiga função, não construtora
      classe_de_alunos(string nome, int idade); // Nova função, construtora, já podemos descartar a antiga, que apenas nos serviu de exemplo básico  

 

aí está o nosso construtor, em verde.

o implementamos da mesma forma que a outra função, só alteramos o nome e deixamos o retorno vazio, não há necessidade nem de colocar o "void" antes.

 

classe_de_alunos::classe_de_alunos(string nome, int idade)
{
this->nome = nome;
this->idade = idade;
}

 

este é o nosso construtor. Como falamos, ele será sempre executado automaticamente logo que criamos o objeto, então, podemos criar nosso objeto só quando já tivermos nossos parametros prontos.

 

nossa alteração ficou assim no final:

 

#include <iostream>

using namespace std;

class classe_de_alunos {
private:
   int idade;
   string nome;
public:
  classe_de_alunos(string nome, int idade);
 void mostrar();
};

classe_de_alunos::classe_de_alunos(string nome, int idade)
{
this->nome = nome;
this->idade = idade;
}

void classe_de_alunos::mostrar()
 {
     cout << nome <<endl;
     cout << idade;
 }

int main()
{
   string nome;
   int idade;
   cout <<"Digite o nome: ";
   getline(cin, nome);
   cout <<"Digite a idade: ";
   cin >> idade;
   classe_de_alunos alunos(nome, idade);  // note que, por ser logo de cara executado o construtor, passamos logo de cara ao criarmos o objeto os nossos parametros, caso contrário não compila.
   alunos.mostrar();
   return 0;
}

 

O get

usamos isso quando queremos saber o que tem dentro do nosso objeto. Na nossa explicação usamos a função "mostrar()", que é exatamente o dever do get. Neste caso, vamos apenas alterar o nome e teremos o nosso get.

 

void getAlunos();

 

entenda isso como, literalmente, Mostrar Alunos.

os métodos da nossa classe devem ter retorno, pois o correto, é usarmos o retorno para dar saída aos dados, usarei cout mesmo para ganharmos tempo.

 

void classe_de_alunos::getalunos()
 {
     cout << nome <<endl;
     cout << idade;
 }

 

Aí está, nosso get prontinho. Por boa prática, usamos o retorno, e não o cout, no caso teríamos que criar um get para cado dado do objeto. getNome e getIdade, e colocar em seus respectivos retornos "return nome;" e "return idade;"

 

O set

 

o método set é usado para ALTERAR os nossos dados. Por exemplo, desejo alterar o nome, vou escrever uma função setNome(nome); Ou seja, literalmente: "MudarNome, nome receberá(nome passado por parametro)".

 

int classe_de_alunos::setNome(string nome)
{
   this->nome = nome;  /// variavel-membro nome, recebe o conteudo passado pelo parametro nome.
}

 

isso alterará o nome, vejamos.

 


int main()
{
string nome;
int idade;
cout <<"Digite o nome: ";
getline(cin, nome);
cout <<"Digite a idade: ";
cin >> idade;
classe_de_alunos meusAlunos(nome, idade);
meusAlunos.getAlunos();
cin.ignore();
cout <<"Digite um novo nome para substituir: " <<endl;
getline(cin, nome);
meusAlunos.setNome(nome); // Altero o nome
meusAlunos.getAlunos(); // retorno os dados novamente, para conferir se foi alterado.
return 0;
}

 

então é isso, use set para alterar os dados e get para mostrar os dados.

set sempre necessitará de referência, parâmetros para fazer alterações, get nunca precisará disso para retornar os dados.

código completo dos exemplo :

 

#include <iostream>

using namespace std;
///////////////////////////////////////////////////////////////////Implementação da classe //////////////////////////////////////////////////////////////////////////////
class classe_de_alunos {
private:
   int idade;
   string nome;
public:
  classe_de_alunos(string nome, int idade);
 void getAlunos();
 int setNome(string nome);
};

classe_de_alunos::classe_de_alunos(string nome, int idade)
{
this->nome = nome;
this->idade = idade;
}

int classe_de_alunos::setNome(string nome)
{
   this->nome = nome;  /// variavel-membro nome, recebe o conteudo passado pelo parametro nome.
}

void classe_de_alunos::getAlunos()
 {
     cout << nome <<endl;
     cout << idade;
 }

/////////////////////////////////////////////////////////// Fim da implementação da classe /////////////////////////////////////////////////////////////////////////////////////////////////

int main()
{
   string nome;
   int idade;
   cout <<"Digite o nome: ";
   getline(cin, nome);
   cout <<"Digite a idade: ";
   cin >> idade;
   classe_de_alunos meusAlunos(nome, idade);
   meusAlunos.getAlunos();
   cin.ignore();
   cout <<"Digite um novo nome para substituir: " <<endl;
   getline(cin, nome);
   meusAlunos.setNome(nome);
   meusAlunos.getAlunos();
   return 0;
}

 

espero que ajude alguém, ficou uma bíblia, mas tentei expor o que eu extraí de muitas explicações chatas da internet de um modo simples, sem tanto uso de termos técnicos.

Deixo também um cadastro de alunos que fiz usando objetos, como ficou bem grande, fiz usando arquivos separados, para ficar organizado. Usei headers, cabeçalhos.

 

main.cpp

 

#include <iostream>
#include <cstdlib>
#include "alunos.h"
#include <string.h>

using namespace std;

int main()
{
   alunos aluno[30];
   int op, cont = 0, turma;
   float notas[4];
   string nome;
   int idade, matricula;
do
{
   cout<< "\tCadastro de alunos 2.0" << endl <<"\tEscolha uma das opcoes abaixo:" <<endl;
   cout <<"1- Cadastrar novo aluno" << endl <<"2- Pesquisar matricula" <<endl <<"3- Ver lista" <<endl <<"4- Alterar notas" <<endl<< "5- Sair" <<endl;
   cin >> op;
   if(op==1)
       {
           cin.ignore();
           cout <<"Digite o nome do aluno: ";
           getline(cin, nome);
           cout <<" Digite a idade do aluno: ";
           cin >> idade;
           cout <<" Digite as notas do aluno: ";
           for(int i = 0; i < 4; i++) { cin >> notas[i]; }
           cout <<" Digite a turma do aluno: ";
           cin >> turma;
           matricula = 201500+cont;
           cout <<"Matricula Gerada: " << matricula;
           aluno[cont] = alunos(nome, idade, notas, turma, matricula);
           cont++;
       }
   else if(op==2)
       {

           cout <<"Digite a matricula: ";
           cin >> matricula;
           int ii = 0;
           for( ii = 0; ii<cont; ii++)
           {
           if(aluno[ii].GetMatricula() == matricula)
               {
                   cout <<"Nome do aluno: " << aluno[ii].GetNome() <<endl;
                   cout <<"Idade do aluno: " << aluno[ii].GetIdade() <<endl;
                   cout <<"Turma do aluno: " << aluno[ii].GetTurma() <<endl;
                   for(int x=0; x<4; x++){ cout << "Nota do aluno: " << aluno[ii].GetNotas(matricula, x) <<endl; }
                   cout<<"Media do aluno: " << aluno[ii].GetMedia() <<endl;
                   ii++;
               }
           }
       }
   else if( op == 3 )
       {
               cout <<"Digite o numero da turma que deseja pesquisar: "; cin>> turma;
               cout << "Alunos da turma: " << turma;
               for (int i = 0; i < cont; i++)
               {
                   cout << aluno[i].GetLista(turma);
               }

   }
   else if(op==4)
   {
         cout <<" Digite a matricula que deseja alterar notas: ";
         cin >> matricula;
         for(int i = 0; i<cont; i++)
         {
             if(aluno[i].GetMatricula()== matricula)
             {
                 cout << "Digite as novas notas: ";
                 for(int i = 0; i < 4; i++) { cin >> notas[i]; }
                 aluno[i].SetNotas(notas);
                 cout <<" notas alteradas com sucesso ";
             }
         }
   }

}
while(op != 5);
cout << "Cadastro de alunos 2.0 - Exercicio c++ com classes e objetos encerrado.";
system("PAUSE");
}

 

 

classe.h

 

#ifndef ALUNOS_H
#define ALUNOS_H
#include <iostream>

using namespace std;


class alunos
{
   public:
       alunos();
       alunos(string nome, int idade, float notas[], int turma, int matricula);
       void SetNotas(float notas[]);
       void SetMedia(float media);
       string GetNome();
       int GetIdade();
       int GetTurma();
       float GetNotas(int matricula, int i) const;
       float GetMedia();
       int GetAlunos(int matricula) const;
       int GetMatricula();
       string GetLista(int turma) const;
       virtual ~alunos();
   protected:
   private:
       string nome;
       int idade;
       int matricula;
       float notas[4];
       float media = 0;
       int turma;
};

#endif // ALUNOS_H

 

 

classe.cpp

 

#include "alunos.h"
#include <iostream>
#include <conio.h>
#include <cstdlib>

using namespace std;

alunos::alunos()
{
   //ctor
}

alunos::~alunos()
{
   //dtor
}
/// //////////////////////////////////////////////////////////////////////////////////////////////
alunos::alunos(string nome, int idade, float notas[], int turma, int matricula )               ///
{                                                                                              ///
   this->nome = nome;                                                                         ///
   this->idade = idade;                                                                       ///
   for(int  i = 0; i<4; i++)                                                                  ///
   {                                                                                          ///
       this->notas[i] = notas[i];                                                             ///
       this->media = this->media + notas[i];                                                  ///
   }                                                                                          ///
   this->turma = turma;                                                                       ///
   this->media = this->media / 4;                                                             ///
   this->matricula = matricula;                                                               ///
}                                                                                              ///
                                                                                              ///
void alunos::SetNotas(float notas[])                                                           ///
{                                                                                              ///
   this->media = 0;                                                                           ///
   for(int  i = 0; i<4; i++)                                                                  ///
   {                                                                                          ///
       this->notas[i] = notas[i];                                                             ///
       this->media = this->media + notas[i];                                                  ///
   }                                                                                          ///
   this->media = this->media / 4;                                                             ///
}                                                                                              ///
                                                                                              ///
void alunos::SetMedia(float media)                                                             ///
{                                                                                              ///
   this->media = media;                                                                       ///
}                                                                                              ///
/// //////////////////////////////////////////////////////////////////////////////////////////////

/// ///////////////////////////////////////////Mostrando dados///////////////////////////////
string alunos::GetNome()                                                                  ///
{                                                                                         ///
       system("cls");                                                                    ///
       return this->nome;                                                                ///
}                                                                                         ///
int alunos::GetIdade()                                                             ///
{                                                                                         ///
       return this->idade;                                                               ///
}                                                                                         ///
int alunos::GetTurma()                                                              ///
{                                                                                         ///
       return this->turma;                                                               ///
}                                                                                         ///
float alunos::GetNotas(int matricula, int x) const                                        ///
{                                                                                         ///
   if(this->matricula == matricula)                                                      ///
       return this->notas[x];   ///*Importante utilizar um contador externo, para poder retornar todas as notas.
}                                                                                         ///
float alunos::GetMedia()                                                                  ///
{                                                                                         ///
   return this->media;                                                                   ///
}                                                                                         ///
int alunos::GetMatricula()                                             ///
{                                                                                         ///
       return this->matricula;                                                           ///
}                                                                                         ///
/// ////////////////////////////////////////////////////////////////////////////////////////

/// /////////////////////////////Mostrar Turma completa /////////////////////////////////
string alunos::GetLista(int turma) const
{
   if(this->turma == turma)
   {
       return this->nome;
   }
}

 

 

 

 

  • Like 1

Programming noob:coracao:

Share this post


Link to post
Share on other sites

Á mesma logica é usada em hackers , parabens e obrigado por compartilhar.


Se os outros são de tirar o chapéu , eu sou de arrancar a cabeça.

Share this post


Link to post
Share on other sites
Guest
This topic is now closed to further replies.
Sign in to follow this  

×
×
  • Create New...