APOSTILA de

ANÁLISE E PROGRAMAÇÃO ORIENTADA A OBJETOS

SUMÁRIO

PROGRAMAÇÃO ESTRUTURADA E PROGRAMAÇÃO ORIENTADA A OBJETOS... 1

Programação estruturada ..................................................................................................................... 1

Baseia-se em: ........................................................................................................................................... 1
Vantagens: ............................................................................................................................................... 1
Desvantagens: .......................................................................................................................................... 1

Programação Orientada a Objetos ........................................................................................................ 1

Baseia-se em: ........................................................................................................................................... 1
Vantagens: ............................................................................................................................................... 1
Desvantagens: .......................................................................................................................................... 1

Conceitos da Programação Orientada a Objetos ................................................................................... 4

Abstração: ................................................................................................................................................ 4
Objetos:.................................................................................................................................................... 4
Classe: ...................................................................................................................................................... 4
Encapsulamento: ..................................................................................................................................... 6
Herança: ................................................................................................................................................... 6
Polimorfismo:........................................................................................................................................... 9
Um resumo: ........................................................................................................................................... 10

Análise e UML ......................................................................................................................................11

Associação: ............................................................................................................................................ 12
Agregação: ............................................................................................................................................. 12
Composição: .......................................................................................................................................... 12
Dependência: ......................................................................................................................................... 13

LINGAGUEM C++ .................................................................................................................. 14

Os comandos básicos em C e C++ são: .................................................................................................. 14
Em Linguagem C, o programa ficaria da seguinte forma: ...................................................................... 15
Em linguagem C++: ................................................................................................................................ 15
Usando função: ...................................................................................................................................... 16
Usando classes: ...................................................................................................................................... 17
Outro exemplo: ...................................................................................................................................... 17

BIBLIOGRAFIA ...................................................................................................................... 22
 FIGURAS
FIGURA 1 ............................................................................................................................................................................. 1
FIGURA 2 ............................................................................................................................................................................. 2
FIGURA 3 ............................................................................................................................................................................. 2
FIGURA 4 ............................................................................................................................................................................. 2
FIGURA 5 ............................................................................................................................................................................. 3
FIGURA 6 ............................................................................................................................................................................. 3
FIGURA 7 ............................................................................................................................................................................. 5
 PROGRAMAÇÃO ESTRUTURADA E PROGRAMAÇÃO
ORIENTADA A OBJETOS
Programação estruturada
Baseia-se nos procedimentos e funções, mantendo o foco nas ações do programa e
em como uma tarefa deve ser executada. Serve para ajudar a controlar o fluxo de execução de
um programa.

Baseia-se em:
Sequência: quando uma tarefa é executada uma após a outra.
Decisão: quando um código, a partir de um teste lógico, é executado ou não.
Laço: quando um código, a partir de um teste lógico, é repetido por n vezes.
Vantagens:
Fácil de entender, por isso, é usada nos cursos iniciais de programação.
Fluxo de execução mais eficaz.
Tem uma execução mais rápida. Para problemas simples é a melhor solução.
Desvantagens:
Os códigos são confusos.
Não há definição de tarefas e, por isso, não há reuso de código.
Não é usado em grandes projetos.

Estrutura de Estrutura de Estrutura de

sequência decisão laço

Figura 1

Programação Orientada a Objetos

Trata-se em resolver problemas complexos através de códigos de sistemas de
software.
Baseia-se em:
Classes, Objetos, Métodos e Atributos.
Vantagens:
Melhor distribuição do código.
Reutilização do código.
Desvantagens:
A compreensão é mais difícil.
O desempenho do código é inferior à programação estruturada.
E pode ser confusa na aplicação dos conceitos de orientação a objetos.

1
 Figura 2

Programação estruturada: Programação orientada a objetos:

foco em sistemas foco em objeto

Programa Classe

Processos Atributos
Dados
Operações

Figura 3

Programa Estruturado Programa Orientado a Objetos

Dados Funções Dados Funções

Classe

Figura 4

2
 Programação Estruturada Programação Orientada a Objetos
Método
Dados do ...
objeto
Procedimento Método

Procedimento Método
Dados do ...
Procedimento objeto
Dados gerais Método
. .
. .
. .

Procedimento Método
Dados do
...
objeto
Método

Figura 5

Na programação estruturada tem-se os procedimentos do programa implementados

de forma a abranger todos os dados da aplicação. Na programação orientada a objetos, tem-se os
métodos que são aplicados diretamente ao seu objeto.
Na programação orientada a objetos, a execução é feita ordenada e sequencial, uma
linha após a outra, sem desvios, tendo assim, melhor desempenho. Como os computadores de
hoje possuem bons processamentos, a programação orientada a objetos não se preocupa em ter
grande desempenho e, sim, em representar o sistema computacional mais próximo possível do
real.
Assim, a programação orientada a objeto é um sistema de ‘objetos’ que interagem
entre si. Cada objeto é capaz de receber, de processar e de enviar dados, de forma independente.
Assim, o acesso aos dados acontece somente quando a ação é associada ao objeto em questão.

Objeto 2
Objeto 3
Objeto 1

Objeto 5 Objeto 4

Figura 6

Breve comparação entre programação estrutura e programação orientada a objetos:

Programação Estruturada Programação Orientada a Objetos

Procedimentos e funções Métodos
Variáveis Instâncias de variáveis
Chama os procedimentos e funções Mensagens
Definição do tipo de dados Classes
-- Herança
-- Polimorfismo

3
 Conceitos da Programação Orientada a Objetos
Abstração:
A ideia da abstração é representar um objeto real no sistema, de acordo com o que ele
irá realizar.
Por isso, a abstração é a capacidade de concentrar no essencial do programa,
considerando separadamente o contexto, priorizando a essência do problema.
O princípio da abstração é essencial para os demais conceitos da Orientação a
Objetos.

Objetos:
São a representação computacional de algo do mundo real. Assim, os objetos em um
software são, em conceito, semelhantes aos objetos reais. Assim, a abstração é importante para
transformar o real em virtual.
O objeto a ser criado precisa ter uma identidade única, que seria o seu nome, para
não ocorrer conflitos. Precisa também ter determinado as suas propriedades específicas, que
seriam suas características, representadas no programa. E, finalizando, o objeto precisa ter seus
métodos, ou seja, as ações relacionadas a ele.
Em um programa, o objeto seria uma variável.
Assim, cada objeto abstraído para o virtual, possui dados, derivados do seu estado, e
operações, derivados do seu comportamento. Ou, em outras palavras, possui atributos e
métodos.

Por exemplo:
Objeto: cachorro
Atributos: raça, nome, peso, cor, etc.
Métodos: Latir, comer, abanar o rabo, dormir, etc.

Então, objetos armazenam seu estado em DADOS.

(Atributos seriam as características do objeto)
E, objetos têm suas ações através dos OPERAÇÕES.
(Métodos seriam as funções aplicadas aos objetos)

O comportamento do objeto seria o conjunto de operações que será executado pelo

objeto.

Assim, codificar um programa de acordo com os seus objetos, permite um software

modulado, ou seja, com objetos independentes, e um software reutilizável, pois os objetos podem
ser usados em programas diferentes.
Por fim, um objeto de um programa se trata da instância de uma classe, ou seja, o seu
comportamento e estado são definidos pela classe ao qual ele se referencia. Sendo assim,
instanciar é criar um objeto, alocando um espaço na memória para poder utilizar os métodos e
atributos declarados na classe.

Classe:
São um conjunto de objetos com as mesmas características, ou seja, dados e
operações.
Na classe, os dados são chamados atributos e as operações do objeto são chamadas
de serviços. Os objetos são conhecidos como instância de uma classe.
Assim, os objetos são as instâncias de uma classe, ou seja, membros de uma classe.

4
 Figura 7

As variáveis de uma classe são os atributos e as funções são os métodos.

Assim, os atributos e métodos de uma determinada classe podem receber três
especificadores de acesso:
 private: acessível somente através das funções da própria classe.
 protected: acessível à classe e também a suas subclasses.
 public: acessível de qualquer parte do programa.

Exemplo:

Em uma classe, chamada aluno, temos os atributos matrícula, nome, data de

nascimento, curso, notas, que são os dados de cada aluno. E temos os métodos Incluir Dados,
Matricular, Alterar Dados Incluir Nota, Emitir Histórico, que são as operações do sistema para
cada aluno cadastrado. Cada aluno, assim, é um objeto.

Classe aluno
Atributos (dados de cada aluno) Métodos (operações do sistema para cada aluno)
Matrícula Incluir Dados
Nome Alterar Dados
Data de Nascimento Matricular
Curso Incluir Nota
Notas Emitir Histórico

Em C++,
class aluno{
private:
int matricula;
char nome[100];
char endereco[100];
char data_nasc[8];
int curso;
float notas[10];
public:
void IncluirDadosPessoais (int mat, char *nom, char *end, char *nas);
void Matricular (int mat, int curs);

5
 void AlterarEndereco (char *end);
void IncluirNotas (float *not);
void EmitirHistorico (void);
};

Encapsulamento:
A ideia do encapsulamento é própria da orientação a objetos, ajudando a definir esse
tipo de programação. Para evitar que os objetos de um programa orientado a objetos acessem
toda e qualquer requisição da aplicação, pode-se implementar uma segurança aos atributos e
métodos deixando-os privados ou protegidos ao uso da classe onde estão. Dessa forma, o
programa executa o que está sendo pedido, sem mostrar como a execução está sendo feita e
sem permitir que outro objeto interfira ou use essa mesma ação.
Encapsular significa esconder a estrutura de dados, consistindo na parte privada
(private), protegida (protected) e na parte pública (public).
O encapsulamento consiste na união da ação e da informação em novos tipos de
dados que sabem o que fazer, separando o serviço da sua implementação.
Assim, o encapsulamento protege os atributos de sua classe e os torna acessíveis
através dos seus métodos. Isso faz com que a modificação dos atributos de uma classe (suas
características) só seja feita pela própria classe, e não por quem executa seus métodos.
Para o encapsulamento de uma classe, os atributos devem ser definidos do tipo
private e os métodos do tipo public.

Herança:
A herança é que permite uma das grandes vantagens da programação orientada a
objetos: o reuso dos códigos. O objeto mais abaixo na hierarquia do código, não em ordem de
linhas, mas de acordo com a distribuição das classes, herda as características de os objetos
acima dele.
Uma classe pode ser extensão de outra, assim, permite-se o aproveitamento de
código, evitando a duplicação do mesmo.
As classes compartilham atributos e serviços, evitando que seja implementado um
código já existente. É um mecanismo para organização, construção e uso de classes reusáveis.
Têm-se as superclasses, que geram outras classes e as subclasses, que herdam a
partir de outras classes.
No caso da linguagem C++, ainda temos a herança múltipla, onde pode-se herdar
várias características ao mesmo tempo, ou seja, uma mesma classe pode-se derivar de várias
classes ao mesmo tempo.

Exemplo de herança:

Estrutura de classes sem herança:

Professor Aluno Funcionário

Dados Operações Dados Operações Dados Operações
Nome AtualizarEnd Nome AtualizarEnd Nome AtualizarEnd
Endereço IncluirDados Endereço IncluirDados Endereço IncluirDados
Grau AlterarGrau Matricula LerCurso Departamento LerDapart
Disciplina LerDados Curso LerDados Cargo LerDados
Nascimento AlterarDiscip Nascimento IncluirNotas Nascimento IncluirNotas
Matricular IncluirDepart

A mesma estrutura de classes, com herança:

Pessoa
Dados Operações
Nome AtualizarEnd

6
 Endereço IncluirDados
Nascimento LerDados

Professor Aluno Funcionário

Dados Operações Dados Operações Dados Operações
Grau AlterarGrau Matricula LerCurso Departamento LerDapart
Disciplina AlterarDiscip Curso IncluirNotas Cargo IncluirNotas
Matricular IncluirDepart

Em C++:

#include <string.h>
#define MAX_DISC 10
#define MAX_STR 100

//DEFINICAO DA SUPERCLASSE PESSOA

class pessoa{
private:
char nome[MAX_STR];
char endereco[MAX_STR];
char nasc[8];
public:
pessoa (const char *nom, const char *end, const char *d_nasc);
void AtualizarEndereço ( const char *end) { strcpy (endereco, end);}
void LerDadosPessoais (char *n, char *end, char *d_nasc);
}; //fim da definicao da classe pessoa
pessoa::pessoa (const char *nom, const char *end, const char *d_nasc)
{ strcpy (nome ,nom);
strcpy (endereco, end);
strcpy (nasc, d_nasc);
}
void pessoa::LerDadosPessoais (char *n, char *end, char *d_nasc)
{ strcpy (n, nome);
strcpy (end, endereco);
strcpy (d_nacs, nasc);
}

//DEFINICAO DA SUBCLASSE PROFESSOR

class professor: public pessoa{
private:
int grau;
int disciplinas[MAX_DISC];
int area;
int n_disc;
public:
professor (const char *n, const char *e, const char *dn, int g,int a );
void IncluirGrau (int g) {grau = g};
void IncluirDisciplinas (int nd, const int *disc)
{ n_disc=nd;
for(int i=0; i<n_disc; i++) disciplinas[i]=disc[i];
}
void IncluirArea (int a) {area=a;}
void LerDadosAcademicos (int *g, int *disc, int *a);

7
 }; //fim da definicao da classe professor

professor::professor (const char *n, const char *e, const char *dn, int g,int
a):pessoa(n,e,dn)
{ grau = g;
area=a;
n_disc=0;;
for (int i=0; i<MAX_DISC; i++) disciplinas[i]=0;
}
void professor:: LerDadosAcademicos (int *g, int *disc, int *a)
{
*g=grau; *a= area;
for (int i=0; i<n_disc; i++) disc[i]=disciplinas[i];
}

//DEFINICAO DA SUBCLASSE ALUNO

class aluno: public pessoa{
private:
int matricula;
int curso;
int disciplinas[MAX_DISC];
int notas[MAX_DISC];
int n_disc;
public:
aluno (const char *n, const char *e, const char *dn, int m,int c );
void Matricular (int nd, const int *d);
void IncluirNotas (const int *n) { for (int i=0; i<n_disc; i++) notas[i]=n[i];}
int LerMatricula (void) {return matricula;}
int LerCurso (void) {return curso;}
void LerNotasDisc (int *n, int *d);
} //fim da definicao da classe aluno

aluno::aluno(const char *n, const char *e, const char *dn, int m,int c):pessoa(n,e,dn)
{ matricula = m;
curso = c;
n_disc=0;
for (int i=0; i<MAX_DISC; i++) { disciplinas[i]=0; notas[i] =0;}
}

void aluno:: Matricular (int nd, const int *d);

{ n_disc = nd;
for (int i=0; i<n_disc; i++) disciplinas[i]=disc[i];
}

void aluno::LerNotasDisc (int *n, int *d)

{ int i;
for ( i=0; i<n_disc; i++)
{
n[i]=notas[i];
d[i]= disciplinas[i];
}
}

//DEFINICAO DA SUBCLASSE FUNCIONARIO

class funcionario: public pessoa{
private:
float salario;

8
 int depto;
int cargo;
public:
funcionario (const char *n, const char *e, const char *dn, float s,int d, int c );
void AlterarSalario (float s) {salario =s;}
void AlterarDepto (int d) {depto =d;}
void AlterarCargo (int c) {cargo = c;}
float LerSalario (void) {return salario;}
int LerDepto (void) {return depto;}
int LerCargo (void) {return cargo;}
} //fim da definicao da classe

funcionario::funcionario (const char *n, const char *e, const char *dn, , float s,int d, int
c):pessoa(n,e,dn)
{ salario = s;
depto = d;
cargo = c;
}

Outro exemplo, para o entendimento de classe, subclasse e herança:

Contas de banco: todas as contas de banco possuem saldo, recebem depósitos,
realizam saques, etc. E, existem diferentes tipos de contas: conta corrente e a poupança, por
exemplo. Na poupança, tem-se incluso um rendimento mensal. Este é um caso claro de herança.
Temos uma classe “Conta”. E, a criação de uma série de métodos comuns às contas dessa classe
acontece pela criação de outras classes que herdam a estrutura (atributos e métodos) da primeira.
Além disso, os métodos criados dentro das subclasses ContaCorrente e Poupança, podem sobre-
escrever os da superclasse Conta, caso tenham o mesmo nome.

Polimorfismo:
O polimorfismo permite que o interior de um método seja alterado para ser usado por
outros objetos. Assim, há a reutilização do código, mas se cria um adendo virtualizado para a
modificação necessária.
Um mesmo chamado para um método pode invocar vários métodos diferentes. É uma
consequência natural da herança.
Permite que mensagens iguais sejam enviadas a objetos que responderão
diferentemente.
Na linguagem C++, usa-se a palavra chave virtual para o polimorfismo. Assim, o
programa entenderá que não se trata de um conflito, mas de uma modificação em um método já
existente para ser usado por outro objeto.

9
Um resumo:

10
 Análise e UML
Antes de escrever o código, é necessário analisar os requisitos do projeto e projetar
uma solução satisfatória.
Uma linguagem gráfica usada para comunicação de qualquer processo de análise e
projeto orientado a objeto é a UML (Unified Modeling Language).
O diagrama de classes é uma representação de estrutura e relações das classes.
Assim, sabemos que uma classe possui atributos, métodos e relações com outras classes. O
diagrama de classes é um retângulo dividido em 3 linhas: Na primeira temos o nome da classe, no
meio os atributos e na última temos os métodos. Para a especificação do acesso, coloca-se +
para o acesso público (public), - para o acesso privado (private) e # para o acesso protegido
(protected).

Classe
-atributos
+operação()

Exemplo:

Circulo
-Raio: double
-Centro: Ponto
+Area(): double
+Circunferencia(): Double
+SetCentro(Ponto)
+SetRaio(double)

Os relacionamentos entre classes podem ser: composições, herança,

agregação/associação, dependência, interfaces.

As representações ficam da seguinte forma:

Herança:
Trata-se de uma classe, chamada de classe filha, que tem os mesmos atributos de
outra classe, classe mãe, mais alguns atributos diferentes.
Exemplo:
Um círculo possui características que o determinam como uma forma geométrica. E
também possui características próprias que o diferenciam de outras formas geométricas. Sendo
assim, há uma relação de herança, onde o círculo é subclasse de forma.
Circulo é uma subclasse de FormaGeom. E Ponto é uma subclasse de FormaGeom.

FormaGeom

+Desenhar()
+Apagar()

Circulo Ponto

A ideia é a seguinte:

11
 Classe X é uma classe Y? Se a resposta for afirmativa, pode-se considerar uma
relação herança. Se for negativa, a relação não poderá ser de herança.
Exemplos:
Suponhamos que Caminhão seja a Classe X e Automóvel seja a Classe Y
Caminhão é um Automóvel?  Relação de herança.
Suponhamos que Pessoa seja a Classe X e Automóvel seja a Classe Y
Pessoa é um Automóvel?  Não há relação de herança.

Associação:
Uma associação acontece quando as classes são independentes entre si, mas
possuem um eventual relacionamento. O importante é que não há dependência entre elas.
Exemplos:
Uma pessoa pode ser referência em uma revista. Dessa forma, pode-se considerar
que há atributos que unem essas duas classes. Porém, ambas continuam independentes uma da
outra.

Pessoa Revista

A relação entre professor e aluno é independente. Uma classe pode existe sem a
outra. Mas há uma relação entre elas quando pensamos que um aluno pode ter vários professores
e um professor pode ter vários alunos.

Agregação:
Trata-se de uma associação com exclusividade, ou seja, não há dependência, mas há
propriedade.
Exemplos:
Uma classe Pato e uma classe Lagoa são independentes entres si. Porém um pato só
pode estar em uma lagoa por vez, o que faz ele ser parte da lagoa quando ele está lá. Já a lagoa,
pode ter vários patos ao mesmo tempo, não sendo presa a nenhum deles. Sendo assim, Lagoa
contém uma instância da classe Pato. E o * significa que Lagoa possui várias instâncias de Pato.

Lagoa * Pato

A relação de um jogador com o seu time traz independência em suas classes, mas o
jogador só pode estar ligado a um time, ou seja, é propriedade dele. Enquanto o time pode ter
vários jogadores. Há, então uma relação de agregação.

Composição:
Significa que uma classe é parte da outra classe.
Exemplos:
Um círculo contém pontos. Assim, há uma relação de composição pois ponto está
contido em círculo.
Circulo contém Ponto

Circulo Ponto

Todo livro possui um autor. Pode-se criar duas classes distintas, Livro e Autor, onde
cada objeto da classe Livro irá possuir um objeto da classe Autor. Sendo assim, a classe Autor
fará parte da classe Livro, tendo uma relação de composição.

12
 Dependência:
A relação de dependência indica que os objetos de uma classe usam os serviços dos
objetos de outra classe. Quando a união é fraca, sem atributos em comum, apenas com
parâmetros de métodos, representa-se com a linha pontilhada. Assim, tem-se uma dependência
Exemplos:
Uma classe que especifica a forma de desenho de uma figura geométrica possui uma
forte relação com a classe de formas geométricas, onde esta última terá um método que depende
das especificações da Classe FormaDesenho, pois retornam esse parâmetro. Sendo assim
FormaGeo não pode ser compilada sem levar a FormaDesenho. Para existir, a Classe FormaGeo
depende da Classe FormaDesenho.

FormaGeo FormaDesenho

+Desenhar(FormaDesenho)

Uma casa, para existir, depende de uma rua. Também depende de um lote. Sem rua e
sem lote, a casa não poderá ser uma casa. Sendo assim, qualquer alteração na rua ou no lote,
afeta também a casa que está nesse lote e nessa rua.

13
 LINGAGUEM C++
Vamos implementar um programa que calcule a média de 3 variáveis.
A ideia do programa é:

Início
Declaração das variáveis que serão usadas no processo
Início do loop de quantas vezes o processo se repetirá
Leitura das variáveis de entrada
Cálculo da média
Impressão das variáveis de saída
Fim do loop de repetição
Fim do programa

Os comandos básicos em C e C++ são:

# include <iostream> Usa os códigos de c++

# include <math.h> Usa operações matemáticas
main (), void main(), int main() Função principal, identifica o programa.
{} Abre/fecha estruturas de comando (main (),if, else, for, while,
switch)
() Abre/fecha comandos específicos para as estruturas
; Fecha uma linha de comando.
int Variáveis inteiras.
float Variáveis flutuantes
char Caracteres
cout << “ ” Imprime o que está escrito entre as “ “
\n Quebra uma linha
cout << y Imprime o valor da variável y
cin >> y Insere valor a variável y
&& E
|| Ou
== Igual
!= Diferente
> Maior
< Menor
<= Menor ou igual
>= Maior ou igual
* Multiplicação
/ Divisão
% Resto da divisão
= A variável anterior recebe o valor especificado a frente
if () Condicional “se”
for () Loop “para”
do --------------------- while() Loop “faça -------- enquanto”
while () Loop “enquanto”
switch () -------------- case Condicional “escolha ---- caso”
system (“pause”) Impede a janela de execução fechar de imediato
Break Para alguma execução, loop ou condicional

14
Em Linguagem C, o programa ficaria da seguinte forma:

#include <stdlib.h>
#include<stdio.h>
int main()
{
int x, y, z, a;
float media;
printf("Quantas vezes o processo se repetira? \n");
scanf("%d", &a);
for(int i=0; i<a; i++)
{
printf("\nDigite 3 valores: \n");
scanf("%d", &x);
scanf("%d", &y);
scanf("%d", &z);
media=(x+y+z)/3;
printf("\n --> A media dos 3 numeros: %f \n", media);
}
return(0);
}

Em linguagem C++:

#include<iostream>
using namespace std;
int main()
{
int x, y, z, a;
float media;
cout << "Quantas vezes o processo se repetira? ";
cin >> a;
for(int i=0; i<a; i++)
{
cout << "\nDigite 3 valores: \n";
cin >> x;
cin >> y;
cin >> z;
media=(x+y+z)/3;
cout << "\n --> A media dos 3 numeros: " << media;
}
return(0);
}

15
 Para entender melhor o código, vamos por partes:

Código Explicação
#include<iostream> Chamada das bibliotecas que contem os códigos usados no programa.
using namespace std; Declara que esse programa irá acessar códigos que fazem parte do
namespace “std”
int main() Inicia o programa principal, “main”, que retorna a um valor inteiro,
{ indicado pelo “int”.
int x, y, z, a; Declaração das variáveis de entrada e saída que serão usadas no
float media; do programa. “Int” e “float” correspondem ao tipo de variável
(número inteiro e real, respectivamente)
cout << "Quantas vezes o Comando de saída, ou seja, que imprime na tela de execução do
processo se repetira? "; programa a mensagem ou a variável descrita em seu processo.
cin >> a; Comando de entrada, ou seja, na variável o valor digitado pelo
usuário.
for(int i=0; i<a; i++) Início do loop de repetição, usando o comando “for”
{
cout << "\nDigite 3 valores: Processo de execução da operação do programa. Ou seja, há a
\n"; inserção de 3 números nas variáveis especificadas, a conta
cin >> x; aritmética da média e a impressão do resultado na tela.
cin >> y;
cin >> z;
media=(x+y+z)/3;
cout << "\n --> A media dos 3
numeros: " << media;
} Fecha o loop de repetição
return(0); Finaliza o programa principal, indicando o valor 0 como valor de
} retorno, caso tudo ocorra bem na execução do código.

Usando função:

#include<iostream>
using namespace std;
void CalculaMedia (int x, int y, int z)
{
float media;
media=(x+y+z)/3;
cout << "\n A media desses 3 numeros = " << media;
}
int main()
{
int x, y, z, a;
cout << "Quantas vezes: \n";
cin >> a;
for(int i=0; i<a; i++)
{
cout << "\n Coloque 3 numero: \n";
cin >> x;
cin >> y;
cin >> z;
CalculaMedia(x,y,z);
}
return(0);
}

16
Usando classes:

#include<iostream>
using namespace std;
class media3{
private:
int x, y, z;
float media;
public:
void calculo()
{
cin >> x;
cin >> y;
cin >> z;
media=(x+y+z)/3;
cout << "A media dos 3 numeros: " << media;
}
};
int main()
{
int a;
cout << "Quantas vezes: \n";
cin >> a;
for(int i=0; i<a; i++)
{
media3 objetomedia;
objetomedia.calculo();
}
return(0);
}

Outro exemplo:

Para uma classe chamada Carro, temos o seguinte programa:

#include<iostream>
using namespace std;
class Carro {
int rodas, passageiros, malas;
public:
int TrocaRodas(int)
{
cout << "\nQuantas rodas precisam ser trocadas? ";
cin >> rodas;
return(rodas);
}
int QuantPassageiros(int)
{
cout << "\nQuantos passageiros no carro? ";
cin >> passageiros;
return(passageiros);
}
int QuantMalas(int)
{
cout << "\nQuantas malas no carro? ";
cin >> malas;
return(malas);

17
 }
};
main ()
{
int x, a;
cout << "Quantos carros? ";
cin >> a;
int vr[a], vp[a], vm[a];
for(int i=1; i<=a; i++)
{
Carro c1;
cout <<"\n -- Carro " << i << " -- ";
vr[i]=c1.TrocaRodas(x);
vp[i]=c1.QuantPassageiros(x);
vm[i]=c1.QuantMalas(x);
}
for(int i=1; i<=a; i++)
{
cout << "\n ** Para o carro " << i;
cout << "\n\nPrecisa de " << vr[i] << " roda(s) nova(s).";
cout << "\nEsta com " << vp[i] << " passageiro(s).";
cout << "\nEsta carregando " << vm[i] << " malas. \n---------------------------- \n";
}
}

Se quisermos adicionar outra classe com variáveis e funções semelhantes, o

programa ficaria da seguinte forma:

#include<iostream>
using namespace std;
class Carro {
int rodas, passageiros, malas;
public:
int TrocaRodas(int)
{
cout << "\nQuantas rodas precisam ser trocadas? ";
cin >> rodas;
return(rodas);
}
int QuantPassageiros(int)
{
cout << "\nQuantos passageiros no carro? ";
cin >> passageiros;
return(passageiros);
}
int QuantMalas(int)
{
cout << "\nQuantas malas no carro? ";
cin >> malas;
return(malas);
}
};
main ()
{
int x, a;
cout << "Quantos carros? ";
cin >> a;

18
 int vr[a], vp[a], vm[a];
for(int i=1; i<=a; i++)
{
Carro c1;
cout <<"\n -- Carro " << i << " -- ";
vr[i]=c1.TrocaRodas(x);
vp[i]=c1.QuantPassageiros(x);
vm[i]=c1.QuantMalas(x);
}
for(int i=1; i<=a; i++)
{
cout << "\n ** Para o carro " << i;
cout << "\n\nPrecisa de " << vr[i] << " roda(s) nova(s).";
cout << "\nEsta com " << vp[i] << " passageiro(s).";
cout << "\nEsta carregando " << vm[i] << " malas. \n---------------------------- \n";
}
}

É importante perceber que, tanto na classe Carro, quanto na classe Moto, têm-se
variáveis iguais e métodos iguais. Se criássemos outra classe, de Caminhão, por exemplo,
também teríamos o método TrocaRodas e QuantPassageiros e as variáveis que neles são
usadas. Assim, para este programa, podemos criar uma superclasse Veículo e transformar as
classes Carro, Moto e Caminhão em subclasses. Usando somente as classes Carro e Moto para
exemplo, ficaria da seguinte forma:

#include<iostream>
using namespace std;
#include<stdlib.h>
class Veiculo{
int rodas, passageiros;
public:
int TrocaRodas(int)
{
cout << "\nQuantas rodas precisam ser trocadas? ";
cin >> rodas;
return(rodas);
}
int QuantPassageiros(int)
{
cout << "\nQuantos passageiros no carro? ";
cin >> passageiros;
return(passageiros);
}
};
class Carro: public Veiculo {
int malas;
public:
int QuantMalas(int)
{
cout << "\nQuantas malas no carro? ";
cin >> malas;
return(malas);
}
};
class Moto: public Veiculo{
int classificacao;
public:

19
 int ClassificacaoMoto(int)
{
cout << "\nDe 1 a 10, classifique a sua moto: ";
cin >> classificacao;
return(classificacao);
}
};
main ()
{
int x, a, menu;
Carro c1;
Moto m1;
cout << "Quantos cadastros? ";
cin >> a;
int vr[a], vp[a], vm[a], vcl[a];
do{
cout << "\nEscolha: Carro (1) ou Moto (2) ou Finalizar (0) --> ";
cin >> menu;
switch(menu)
{
case 1:
for(int i=1; i<=a; i++)
{
cout <<"\n -- Carro " << i << " -- ";
vr[i]=c1.TrocaRodas(x);
vp[i]=c1.QuantPassageiros(x);
vm[i]=c1.QuantMalas(x);
}
for(int i=1; i<=a; i++)
{
cout << "\n ** Para o carro " << i;
cout << "\n\nPrecisa de " << vr[i] << " roda(s) nova(s).";
cout << "\nEsta com " << vp[i] << " passageiro(s).";
cout << "\nEsta carregando " << vm[i] << " malas. \n;
}
break;
case 2:
for(int i=1; i<=a; i++)
{
cout <<"\n -- Moto " << i << " -- ";
vr[i]=m1.TrocaRodas(x);
vp[i]=m1.QuantPassageiros(x);
vcl[i]=m1.ClassificacaoMoto(x);
}
for(int i=1; i<=a; i++)
{
cout << "\n ** Para a moto " << i;
cout << "\n\nPrecisa de " << vr[i] << " roda(s) nova(s).";
cout << "\nEsta com " << vp[i] << " passageiro(s).";
cout << "\nTem nota " << vcl[i] << "\n ";
}
break;
case 0:
cout << "Finalizando...........";
return(0);
default:
cout << "Numero invalido. Inicie novamente.";

20
 break;

}
system("pause");
system("cls");
} while(menu!=0);
}

A declaração da subclasse se faz da seguinte forma: class Carro: public Veiculo, ou

seja, Carro é uma subclasse de Veículo.

21
 BIBLIOGRAFIA

DEITEL, H. M.; DEITEL, P. J. C++: como programar. ed. São Paulo: Pearson
Education, 2009.
MIZRAHI, Victorine Viviane. Treinamento em Linguagem C++: módulo 1. ed. São
Paulo: Pearson Prentice Hall, 2006.
____. Treinamento em Linguagem C++: módulo 2. ed. São Paulo: Pearson Prentice
Hall, 2009.

22