AULA 3 - Programação II - Graduação
Modificado de [C++ como programar, Deitel & Deitel] e de [C++ Absoluto, Savitch]
Programação orientada a objetos
Linguagem Orientada a Objetos: combinação, em um único registro, de dados e funções que vão operar nestes dados – CLASSES.
- Campos das classes: MEMBROS ou ATRIBUTOS.
- Funções: FUNÇÕES-MEMBRO ou MÉTODOS.
A programação orientada a objetos (POO) encapsula dados (atributos) e funções (métodos) em pacotes chamados classes.
Uma classe é como a planta de uma casa. A partir da planta, o construtor pode construir uma casa. A partir de uma classe, o programador pode construir um objeto.
- OBJETOS (instâncias) são “variáveis” de um determinado tipo de Classe.
Uma planta pode ser reutilizada muitas vezes para se fazer muitas casas. Uma classe pode ser reutilizada muitas vezes para se criar muitos objetos.
As classes têm a propriedade de ocultação de informações. Isso significa que, embora os objetos da classe possam saber como comunicar-se uns com os outros, através de interfaces bem-definidas, normalmente não é permitido às classes saber como as outras classes são implementadas. Os detalhes da implementação são escondidos dentro das próprias classes.
ENCAPSULAMENTO: tornar a classe independente/autônoma e manter sigilo sobre as características da mesma.
Como encapsular? ⇒ Permitindo apenas às funções-membro da classe alterar/atribuir valores aos membros do objeto!
Em C e outras linguagem procedurais, a programação tende a ser orientada a funções, enquanto que em C++ a programação é orientada a objetos.
Definição de uma classe
class Nome_Classe
{private:
Declarações MembrosPrivados;
DeclaraçõesMetodosPrivados( );
public:
Declarações MembrosPúblicos;
DeclaraçõesMetodosPúblicos( );
protected:
Declarações MembrosProtegidos;
DeclaraçõesMetodosProtegidos( );
};
Não se faz inicialização explícita de atributos na declaração da Classe*. Contra-ex: public int x = 0;
Especificadores de Acesso:
- Membros e Métodos Privados – private : podem ser acessados APENAS por outros métodos do mesmo objeto ou a funções friend da classe;
- Membros e Métodos Públicos – public : são acessíveis em todos os lugares onde a classe estiver acessível (escopo da classe);
- Membros e Métodos Protegidos – protected : são acessíveis pelas classes derivadas (através de herança);
outros:
- Published (Borland C++ Builder);
- internal (MS VC)...
Exemplo:
class Retangulo // declaração da classe
{ private:
int base, altura; // Dados membros privados
public:
void Inic(int b, int h) // método de inicialização
{ base = b; altura = h; }
void ImprimeSaida( ) // método que imprime área
{ cout << “\nBase = “ << base << “ Altura=“ << altura;
cout << “\nÁrea = “ << (base*altura);
}
};
Observação: métodos definidos dentro da definição da classe → Métodos Inline.
Quando optar-se pela definição externa: no corpo da classe usa-se o protótipo do método. Ex:
void Inic(int b, int h);
E no corpo do método:
tipo NomeClasse :: NomeMétodo( )
{ ...
}
Assim:
1 class Retangulo // declaração da classe
2 { private: int base, altura;
3 public:
4 void Inic(int b, int h); // método de inicialização
5 void ImprimeSaida( ); // método que imprime área
6 };
7
8 void Retangulo::Inic(int b, int h)
9 { base = b; altura = h; }
10
11 void Retangulo::ImprimeSaida()
12 { cout << “\nBase = “ << base << “ Altura=“ << altura;
13 cout << “\nÁrea = “ << (base*altura);}
Note que:
Os métodos de uma classe acessam DIRETAMENTE os atributos (não é preciso passá-los como argumentos)!!
Implementando uma classe simples - DiadoAno
Como exemplo, vamos ilustrar o processo de implementação de um tipo abstrato relacionado com datas, e atributos e ações que lhe digam respeito.
Os campos membros dos objetos são chamados de atributos, ou membros de dados e as ações são chamadas de métodos ou funções-membro.
Tipos contendo membros de dados e funções membro são definidos em C++ utilizando-se a palavra-chave class.
Ex:
class DiadoAno{
public:
void Mostra();
private:
int dia; //1-31
int mes; //1-12
int ano; //0-2017
};
A definição da classe começa com a palavra reservada class. O nome da classe, DiadoAno, segue a palavra-chave.
O corpo da classe é delimitado pelas chaves ({ e }) e termina com o ponto e vírgula (;).
Esta classe possui um método PÚBLICO (public), Mostra() e três atributos PRIVADOS (private), dia, mes e ano.
Os modificadores public: e private: são chamados de especificadores de acesso a membros.
Quaisquer atributos ou métodos declarados depois do especificador de acesso a membros public (e antes do próximo especificador) são acessíveis onde quer que o programa tenha que acessar um objeto da classe DiadoAno.
Quaisquer atributos ou métodos declarados depois do especificador de acesso a membros private (e antes do próximo especificador) são acessíveis somente a métodos da própria classe DiadoAno.
Isto significa que um programa usuário da classe não poderá acessar diretamente um atributo private, mas apenas através de um método público.
Um exemplo de utilização desta classe seria o programa C++ abaixo (CodeBlocks):
1 #include <iostream>
2 using namespace std;
3
4 class DiadoAno
5 { public:
6 void Mostra();
7 private:
8 int dia; //1-31
9 int mes; //1-12
10 int ano; //0-2017
11 };
12
13 int main()
14 { DiadoAno hoje;
15 hoje.Mostra();
16 return 0;
17 }
18
19 void DiadoAno::Mostra()
20 {
21 cout << "Informe o dia (1-31)" << endl;
22 cin >> dia;
23 cout << "Informe o mes (1-12)" << endl;
24 cin >> mes;
25 cout << "Informe o ano (0-2017)" << endl;
26 cin >> ano;
27 cout<< "Hoje \202 dia: " << dia << "/" << mes << "/" << ano <<"\n";
28 }
Note como funciona a definição de um método da classe (linhas 19 a 28).
A saída do programa será:
Note que os atributos privados só podem ser acessados pelo método Mostra().
Este foi chamado, tranquilamente, na função externa à classe main(), na linha 15.
Mas se vc tentar acessar também um dos atributos, como dia, na função main(), o compilador dará erro:
Adicionando funcionalidades
A classe DiadoAno não tem muita sofisticação e proteção contra erros. E uma das filosofias da POO é, justamente, que as classes sejam unidades de código as mais autônomas possível.
Assim, é necessário acrescentar funcionalidades à classe, de forma a torná-la completa e menos sensível a erros.
Por exemplo, o método VerificaData() permite checar se a data digitada é válida.
1 #include <iostream>
2 using namespace std;
3
4 class DiadoAno
5 { public:
6 void Mostra();
7 private:
8 int dia; //1-31
9 int mes; //1-12
10 int ano; //0-2017
11 void VerificaData();
12 };
13
14 int main()
15 { DiadoAno hoje;
16 hoje.Mostra();
17 return 0;
18 }
19
20 void DiadoAno::Mostra()
21 {
22 cout << "Informe o dia (1-31)" << endl;
23 cin >> dia;
24 cout << "Informe o mes (1-12)" << endl;
25 cin >> mes;
26 cout << "Informe o ano (0-2017)" << endl;
27 cin >> ano;
28 cout<< "/" << mes << "/" << ano <<"\n";
29 }
30
31 void DiadoAno::VerificaData()
32 { if(dia <1 || dia>31)
33 cout<< "\nErro no dia fornecido!!! Entre com um valor entre 1 e 31";
34 else
35 cout << "Hoje \202 dia: " << dia ;
36 if(mes<1 || mes >> 12)
37 cout<< "\nErro no mes fornecido!!! Entre com um valor entre 1 e 12";
38 else
39 { switch(mes)
40 { case 1: cout << " de Janeiro "; break;
41 case 2: cout << " de Fevereiro "; break;
42 case 3: cout << " de Março "; break;
43 case 4: cout << " de Abril "; break;
44 case 5: cout << " de Maio "; break;
45 case 6: cout << " de Junho "; break;
46 case 7: cout << " de Julho "; break;
47 case 8: cout << " de Agosto "; break;
48 case 9: cout << " de Setembro "; break;
49 case 10: cout << " de Outubro "; break;
50 case 11: cout << " de Novembro "; break;
51 case 12: cout << " de Dezembro "; break;
52 }
53 }
54 if (ano <0 || ano > 2017)
55 cout<< "\nErro no ano fornecido!!! Entre com um valor entre 0 e 2017";
56 else
57 cout << "de " << ano << ".\n\n";
58 }
EXERCÍCIOS:
- Expanda a classe DiadoAno para que, que após inicializada, esta possa também verificar o número máximo de dias no mês.
- Um ano bissexto é aquele que é divisível por 4, mas não por 100, OU que é divisível por 400 (ou seja, obedece à expressão: (!(ano%4)&&(ano%100)) || (!(ano%400)). Expanda a classe DiadoAno de forma que ela imprima também se o ano fornecido é bissexto ou não.
- Expanda novamente DiadoAno, para que esta informe também a idade atual do usuário, referente à data fornecida.
Programação orientada a eventos
Necessidade surgiu com demanda por ambientes amigáveis, gráficos - Windows
Execução não-linear de códigos e sob demanda:
- interrupções externas,
- interrrupções do usuário ou
- interrupções do sistema.
Evento – mudança de estado do objeto, disparada pelo usuário e associado ao tempo e à interfaces com o usuário, normalmente.
É a maneira pela qual os programas com interface visual interagem com o usuário.
Em programação visual no Visual C++ (MSVC), os objetos gráficos são chamados de Controles. Um exemplo simples de controle é o formulário, Form, que é a janela padrão do Windows.
A classe System.Windows.Controls do MSVC fornece classes para criar elementos, chamados de Controles, os quais habilitam um usuário a interagir com uma aplicação.
Alguns destes controles contidos na lista System.Windows.Controls estão disponíveis na biblioteca Silverlight (multiplataforma), em tempo de execução, enquanto outras estão disponíveis na biblioteca Silverlight SDK (Software Development Kit):
Outros controles são:
- Botão - Button;
- Quadro de texto - TextBox;
- Quadro de texto formatado - RichTextBox;
- Figura - Image;
- Quadro de Checagem - CheckBox;
- Quadro de Lista - ListBox;
- Quadro de Seleção - ComboBox;
- Abrir Janela de Diálogo - OpenFileDialog;
- etc.
Lista completa de controles Silverlight SDK
Toda programação orientada a eventos começa com o formulário. Você pode incluir quantos formulários quiser, mas um sempre vai ser o principal.
O Visual C++ Express 2008
Pode ser baixado no link:
Visual C++ Express - versão gratuita
O aplicativo tem este ícone:
E este aspecto, quando iniciado:
Seleciona-se "File > New > Project".
Na janela aberta, dá-se um nome pro projeto e escolhe-se "Windows Form Application".
O MSVC vai abrir algo do tipo:
Para acessar a biblioteca de Controles, clique no menu View > Toolbox.
Exemplo:
Como primeiro exemplo, vamos criar uma aplicação que inicialmente apenas abre um form e maximiza-o.
Proceda como explicado acima e crie um novo projeto: primeiro.sln (a extensão refere-se a Solution, que é como o MSVC chama os projetos).
Agora, vamos alterar as propriedades deste form.
Na janela Properties localize a propriedade Text. Substitua o valor "Form 1" por "Meu Primeiro Programa".
Depois, localize a propriedade Window State e altere-a para "Maximized".
Agora, é só compilar seu programa (Menu Build Solution, ou tecla F7) e rodá-lo (Menu Start Debugging, ou tecla F5, ou seta verde na barra de Ferramentas).
O código obtido será:
OBSERVAÇÃO → "primeiro" é o nome do Projeto.
#pragma once
namespace primeiro {
using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;
public ref class Form1 : public System::Windows::Forms::Form
{
public:
Form1(void)
{
InitializeComponent();
}
protected:
~Form1()
{
if (components)
{
delete components;
}
}
private:
System::ComponentModel::Container ^components;
#pragma region Windows Form Designer generated code
void InitializeComponent(void)
{
this->SuspendLayout();
this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);
this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
this->ClientSize = System::Drawing::Size(284, 261);
this->Name = L"Form1";
this->Text = L"Meu Primeiro Programa";
this->WindowState = System::Windows::Forms::FormWindowState::Maximized;
this->Load += gcnew System::EventHandler(this, &Form1::Form1_Load);
this->ResumeLayout(false);
}
#pragma endregion
private: System::Void Form1_Load(System::Object^ sender, System::EventArgs^ e) {
}
};
}
EXERCÍCIO:
Implementação simplificada do método CutToClipboard
- Coloca o foco no objeto da classe TextBox e espera o usuário selecionar um texto e clicar o botão.
- Quando o usuário terminar de selecionar o texto (evento MouseUp) copia o texto selecionado (propriedade SelectedText do objeto TextBox) para a variável temporária aux, ou para o ClipBoard;
- Quando o usuário pressionar o botão “Limpar”, limpa o texto do quadro de textos e muda o texto do botão para “Desfazer”;
- Se o usuário tornar a pressionar o botão, faz o texto do quadro ser igual ao conteúdo da variável temporária aux e retorna o texto do botão para “Limpar”.