Apostila de Resumo Programação Orientado a Objeto

Prévia do material em texto

PROGRAMAÇÃO ORIENTADA A OBJETOS 
 
 
 
 
 
Resumo para estudo gerais de POO 
feita por Mirla Rocha de Oliveira 
Ferreira. 
 
 
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: ......................................................................................................................................... 12 
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 
 
 
 
 
1 
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. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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. 
 
Estrutura de 
sequência 
Estrutura de 
decisão 
Estrutura de 
laço 
 
2 
 
Figura 2 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 3 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 4 
 
 
 
 
 
 
Programa 
Processos 
Dados 
Classe 
Atributos 
Operações 
Programação estruturada: 
foco em sistemas 
Programação orientada a objetos: 
foco em objeto 
Dados Funções Dados Funções 
Classe 
Programa Estruturado Programa Orientado a Objetos 
 
3 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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 é feitaordenada 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. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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 
 
 
Objeto 1 
Objeto 2 
Objeto 3 
Objeto 4 Objeto 5 
Dados gerais 
Procedimento 
Procedimento 
Procedimento 
Procedimento 
. 
. 
. 
Programação Estruturada 
Dados do 
objeto 
Método 
Método 
 
Método 
 
Método 
 
... 
Programação Orientada a Objetos 
Dados do 
objeto 
. 
. 
. 
Dados do 
objeto 
... 
Método 
 
Método 
... 
 
4 
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. 
 
 
5 
 
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 
Nome 
Data de Nascimento 
Curso 
Notas 
Incluir Dados 
Alterar Dados 
Matricular 
Incluir Nota 
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); 
 
6 
 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 
Endereço 
Grau 
Disciplina 
Nascimento 
 
AtualizarEnd 
IncluirDados 
AlterarGrau 
LerDados 
AlterarDiscip 
Nome 
Endereço 
Matricula 
Curso 
Nascimento 
 
AtualizarEnd 
IncluirDados 
LerCurso 
LerDados 
IncluirNotas 
Matricular 
 
Nome 
Endereço 
Departamento 
Cargo 
Nascimento 
 
AtualizarEnd 
IncluirDados 
LerDapart 
LerDados 
IncluirNotas 
IncluirDepart 
 
 
A mesma estrutura de classes, com herança: 
 
Pessoa 
Dados Operações 
Nome AtualizarEnd 
 
7 
Endereço 
Nascimento 
IncluirDados 
LerDados 
 
 
 
 
Professor Aluno Funcionário 
Dados Operações Dados Operações Dados Operações 
Grau 
Disciplina 
 
AlterarGrauAlterarDiscip 
Matricula 
Curso 
 
LerCurso 
IncluirNotas 
Matricular 
 
Departamento 
Cargo 
 
LerDapart 
IncluirNotas 
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); 
 
8 
}; //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; 
 
9 
 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. 
 
 
 
10 
Um resumo: 
 
 
 
 
 
11 
 
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() 
 
 
 
 
 
 
 
A ideia é a seguinte: 
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. 
Circulo Ponto 
 
12 
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. 
 
 
 
 
 
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ânciasde 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 
 
 
 
 
 
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. 
 
 
Dependência: 
Lagoa Pato * 
Pessoa Revista 
Circulo Ponto 
 
13 
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. 
 
 
 
 
 
 
 
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. 
 
 
 
 
 
 
 
FormaGeo 
 
+Desenhar(FormaDesenho) 
FormaDesenho 
 
 
14 
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 
 
 
 
 
 
 
 
15 
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); 
} 
 
 
 
 
16 
 
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; 
float media; 
Declaração das variáveis de entrada e saída que serão usadas 
no do programa. “Int” e “float” correspondem ao tipo de variável 
(número inteiro e real, respectivamente) 
cout << "Quantas vezes o 
processo se repetira? "; 
Comando de saída, ou seja, que imprime na tela de execução do 
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: 
\n"; 
cin >> x; 
cin >> y; 
cin >> z; 
media=(x+y+z)/3; 
cout << "\n --> A media dos 3 
numeros: " << media; 
Processo de execução da operação do programa. Ou seja, há a 
inserção de 3 números nas variáveis especificadas, a conta 
aritmética da média e a impressão do resultado na tela. 
} 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); 
} 
 
 
17 
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); 
 
18 
 } 
}; 
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; 
 
19 
 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: 
 
20 
 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."; 
 
21 
 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. 
 
 
22 
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.