terça-feira, 8 de fevereiro de 2011

Criando o primeiro objeto em C++

Olá aprendizes de programação em C++!

Este artigo foi totalmente dedicado a você, que não sabe muito sobre C++. Aqui vou demonstrar como desenvolver e programar a sua primeira classe em C++ e a partir dela criar seu primeiro objeto! Importante dizer que aqui eu suponho que você ao menos saiba o que é C++ e o que é um objeto. Pelo menos você precisa ter em mente os conceitos básicos comuns a todas as linguagens de programação orientadas a objetos como classe, objeto, atributo e método. Sabendo isso, você está pronto pra programar seu primeiro gambiarra objeto em C++.

Mas vamos por partes: começaremos com a especificação da classe, depois partimos para a análise da classe, então criaremos a classe do objeto e só então criaremos o tão almejado objeto a partir desta classe. Por fim, criaremos um pequeno programa de teste, só para testar algumas instâncias e ver como tudo funciona. Tudo explicadinho nos mínimos detalhes, pra você não se perder. Chega de papo furado? Vamos lá, então!


Especificando a classe


Pra esse exemplo mísero, especificaremos uma classe extremamente básica, mas funcional. Ou seja, ela inclui tudo o que qualquer outra classe costuma ter. Aqui vamos só pensar no objetivo dessa classe. Tudo bem que aqui é so um exemplo, mas é bom você já ir se acostumando a pensar muito bem no motivo pelo qual você pretende desenvolver uma nova classe em C++ ao invés de reutilizar alguma outra que já exista por aí. Mas esse papo de reutilização é outra história (fica pra próxima, kkk)...

Essa nossa classe de exemplo representará um relógio. É, simples assim. Um relógio que marca as horas, minutos e segundos, só isso, nada mais, nada menos. O usuário dessa classe vai poder inicializar o relógio com hora, minuto e segundo padrão (zerados), ou passar a hora, minuto e segundo através de parâmetros no momento da inicialização. Depois de criados os objetos, o usuário poderá ajustar a hora, minuto e segundo a qualquer momento. Para ajustar o horário do relógio, o usuário poderá ajustar hora, minuto e segundo separadamente ou então ajustar todos os valores de uma só vez. Além disso, o usuário poderá a qualquer momento consultar a hora, minuto e segundo.

Repare a especificação da classe acima. Daí já podemos retirar todas as informações necessárias para começar a programar (análise), e em seguida, transformaremos todo esse raio em código C++ (desenvolvimento). Parece mágica, não? Não. Isso é engenharia de software.


Analisando a classe


- O relógio tem hora, minuto e segundo. Daí concluímos que: hora, minuto e segundo serão os atributos da classe.

- O relógio permite inicializar hora, minuto e segundo com valores padrão (zerados) ou através de parâmetros. Como você já deve saber (lembre-se que isso é conceito básico de programação orientada a objeto), o que permite inicializar um objeto são os construtores da classe. Daí concluímos que: a classe terá dois construtores, um padrão e um sobrecarregado.

- O relógio permite ajustar hora, minuto e segundo separadamente ou todos os valores simultaneamente. Como você já deve saber, o que permite ajustar valores de objetos são os "setters" ou métodos de configuração ou seja lá como quizer chamar, dá tudo na mesma. Daí concluímos que: teremos que adicionar quatro métodos - um para ajustar hora, outro para ajustar minuto, outro para ajustar segundo; e outro para ajustar hora, minuto e segundo simultaneamente.

- O relógio permite consultar hora, minuto e segundo. Como você já deve saber, o que permite consultar valores de objetos são os "getters" ou métodos de consulta ou seja lá como quizer chamar, dá tudo na mesma. Daí concluímos que: teremos que adicionar mais três métodos - um para consultar hora, outro para consultar minuto, e outro para consultar segundo.

Eis a classe, especificada e analisada. Já temos tudo pronto para a transformação mágica! Ou melhor, a transformação programática desse raio todo em código C++. Vamos lá?


Codificando a classe


Agora chegou a parte mais fácil. Sim, a codificação é mamão com açúcar depois de todo esse raio de especificação e análise. Você pensa o quê? Que programação é só sentar na frente do computador e começar a digitar abobrinha? Não, não, não, não, NÃO! Programação é só uma pequena parte do processo de desenvolvimento de sistemas. Então vá se acostumando e prepare-se porque depois da faculdade só vem a complicar cada dia mais, e mais, e mais (e eu que nem sequer cursei faculdade, tsc tsc tsc)...

Antes de começar a digitação, lembre-se de uma prática recomendadíssima! Em C++, é muito recomendável dividir os arquivos de definição de classe dos arquivos de implementação. Isto na prática significa, em bom português: você define a classe em um arquivo de extensão .h chamado de "cabeçalho", e implementa ela (programa ela) em outro arquivo separado de extensão .cpp chamado de "arquivo de implementação". Portanto, aqui vou separar duas listagens, a primeira é o cabeçalho e a segunda é a implementação. Vamos lá, CONTROL-C + CONTROL-V nessa listagem!


Arquivo de cabeçalho - relogio.h


#ifndef _RELOGIO_H_
#define _RELOGIO_H_

class Relogio
{
private:

int hora;
int minuto;
int segundo;

public:

Relogio();
Relogio( int, int, int );

int get_hora() { return hora; }
int get_minuto() { return minuto; }
int get_segundo() { return segundo; }

void set_hora( int );
void set_minuto( int );
void set_segundo( int );

void set_relogio( int, int, int );
};

#endif


Arquivo de implementação - relogio.cpp


#include "relogio.h"

Relogio::Relogio()
{
set_relogio( 0, 0, 0 );
}

Relogio::Relogio( int h, int m, int s )
{
set_relogio( h, m, s );
}

void Relogio::set_hora( int h )
{
if ( h > 0 && h < 24 )
hora = h;
else
hora = 0;
}

void Relogio::set_minuto( int m )
{
if ( m > 0 && m < 60 )
minuto = m;
else
minuto = 0;
}

void Relogio::set_segundo( int s )
{
if ( s > 0 && s < 60 )
segundo = s;
else
segundo = 0;
}

void Relogio::set_relogio( int h, int m, int s )
{
set_hora( h );
set_minuto( m );
set_segundo( s );
}


Agora que já definimos e implementamos a classe, basta usarmos um programinha para testar algumas instâncias da gambiarra do objeto. Vamos lá?


Testando a gambiarra o objeto


Aqui eu escrevi um programinha para instanciar dois objetos do tipo Relógio e testar o funcionamento deles. Um dos objetos eu inicializei de forma padrão, ou seja, invoquei o construtor sem parâmetros. O outro eu inicializei usando o construtor sobrecarregado, que requer a passagem de três valores, o primeiro indica a hora, o segundo indica os minutos e o terceiro indica os segundos. Confira na listagem a seguir:


#include "iostream"

#include "relogio.h"

using namespace std;

int main()
{
Relogio relogio1;
Relogio relogio2( 21, 30, 0 );

cout << "Relogio 1 = "
<< relogio1.get_hora() << ":"
<< relogio1.get_minuto() << ":"
<< relogio1.get_segundo() << endl;

cout << "Relogio 2 = "
<< relogio2.get_hora() << ":"
<< relogio2.get_minuto() << ":"
<< relogio2.get_segundo() << endl;

getchar();

return 0;
}


Agora você já pode testar. Compile o teste.cpp usando o seu compilador (Use o GCC, faça me o favor, né!) e veja a mágica de C++ diante dos seus olhinhos de noite serena!



E aí gostaram? Mande as dúvidas.