C++ Orientado A Objetos

C+ +
ORIENTADO A OBJETOS
FLÁVIO DE OLI VEIRA SILVA

flavio@facom.ufu.br
flavio@autoenge.com.br
C+ + Orientado a Objetos
Flávio de Oliveira Silva 1
1. INTRODUÇÃO A POO
POO – Paradigma Baseado em objetos
Paradigma – Modelo, padrão para
especificação de um problema
Paradigmas existentes na programação
de computadores: Procedimental;
Funcional; Lógico e Orientado a
Objetos(OO)
1
PROCEDIMENTAL (Algorítmica)
Computação ocorre através da execução de
instruções passo a passo. Ex: C; Pascal
int fatorial(int n)
{
int fat;
fat = 1;
if (n == 0)
return 1;
while (n >= 1){
fat = fat * n;
n = n -1;
}
return fat;
}
FUNCIONAL
Computação baseada em calculo de funções.
Ex: LISP; HASKELL
;LISP
(defun fatorial (n)
(cond
((= n 0) 1)
(t (* n (fatorial (- n 1))))
)
)
-- Haskell
fatorial :: Integer -> Integer
fatorial 0 = 1
fatorial n = n * fatorial (n - 1)
2
LÓGICA

Computação baseada em fatos e regras. Ex: Prolog

factorial(0,1).
factorial(N,X):- M is N - 1,
factorial(M,Y),
X is N * Y.
ORIENTADO A OBJETOS (OO)

Computação baseada em objetos que se

intercomunicam. Objetos contém dados e métodos.
Ex: C++; Java
public class Numero {
private long valor = 0;
public long Fatorial() {
if (valor == 0) {
return 1;
} else {
return valor*Fatorial(valor-1);
}
} C+ + Orientado a Objetos
} Flávio de Oliveira Silva 5
PARADIGMAS
Cada paradigma representa uma forma
de propor uma solução a um dado
problema.
A utilização de um ou outro paradigma
depende de vários fatores.
3
PROGRAMAÇÃO ORIENTADA A OBJETOS
Conceitos Básicos
1. OBJETO
2. MÉTODOS
3. MESSAGEM
4. CLASSE
5. CLASSIFICAÇÃO
1. GENERALIZAÇÃO
2. ESPECIALIZAÇÃO
6. HERANÇA
7. ENCAPSULAMENTO
8. POLIMORFISMO
OBJETO

Entidades que possuem dados e instruções sobre como

manipular estes dados

Os objetos estão ligado à solução do problema.

Software Gráfico – Objetos: Circulos; Linhas; etc.
Software Engenharia – Cargas Elétricas; Circuitos Elétricos; Motores; etc.
Software Comercial: Pedidos; Produtos; Clientes; etc.

Na POO a solução do problema consiste em um primeiro

momento estabelecer quais os objetos serão necessários.

Um ponto sempre contém dados relacionados ao mesmo que o

identificam – Exemplos:
Círculo – ponto_centro, raio
Linha – ponto_inicio; ponto_final
Cliente – Nome; Endereco; Telefone
Circuito Elétrico – Nome; Potência (W); Pontênia(VA)
Exemplos:
/ / criação de objetos
Circle c;
Cliente pessoa;
4
MÉTODOS
Métodos são procedimentos que determinam
como o objeto se comporta. Através dos
métodos é possível manipular os dados
contidos no objeto.
Os métodos estão ligados ao comportamento
do objeto
Exemplos:

Um círculo poderia possuir os métodos: draw;

move; getArea; getPerimeter; setCenter

Um circuito elétrico poderia ter os seguintes

métodos: setCarga; addCarga; setPotenciaW;
setPotênciaVA
MENSAGEM
Objetos se comunicam entre si através de

mensagens. Uma mensagem é uma chamada de um
método. A mensagem possui os seguintes
componentes:
Receptor – nome do objeto que irá receber a mensagem
Método – Método do receptor que será utilizado
Argumentos – I nformação adicional para a execução do
método
Exemplos
Point p(0,0), pNewCenter(2,3);
Circle c(p,3);
c.getArea(); / / Exemplo Mensagem
c.setCenter(pNewCenter); / / Exemplo
Mensagem
5
CLASSE
Classe é um agrupamento de objetos
A classe consiste nos métodos e nos dados
que um determinado objeto irá possuir.
Objetos são criados quando uma mensagem
solicitando a criação é recebida pela sua
classe.
A classe contém as informações para criar,
manipular e destruir o objeto
Um objeto é uma instância da classe.
CLASSIFICAÇÃO
Na POO classificação consiste em criar
classes a partir dos objetos envolvidos
em um determinado problema
Ex: Diferentes tipos de pessoas
interagem com um Empresa
COMPORTAMENTO CLASSE
Pessoas interessadas nos produtos ???
Pessoas que já compraram os produtos ???
Pessoas que são responsáveis por um grupo de trabalhadores ???
Pessoas responsáveis pela demonstração de produtos e sua venda ???
Trabalhadores da linha de produção ???
6
GENERALIZAÇÃO
ESPECIALIZAÇÃO
GENERALIZAÇÃO
A generalização consiste em obter similaridades entre
as várias classes e partir destas similaridades, novas
classes são definidas Estas classes são chamadas
superclasses
ESPECIALI ZAÇÃO
A especialização por sua vez consiste em observar
diferenças entre os objetos de uma mesma classe e
dessa forma novas classes são criadas. Estas classes
são chamadas subclasses.
EXEMPLO
7
HERANÇA

Herança é a capacidade de uma subclasse de

ter acesso as propriedades da superclasse
relacionada a esta subclasse.

Dessa forma as propriedades de uma classe

são propagadas de cima para baixo em um
diagrama de classes.

Neste caso dizemos que a subclasse herda as

propriedades e métodos da superclasse
HERANÇA

A relação de herança entre duas classes é uma relação da

seguinte forma: A “e um tipo de” B, onde A e B são
classes. Caso a relação entre as classes não puder ser
construída, em geral, também não se tem uma relação de
herança entre a classe A a partir da classe B.

Exemplos: Um Carro de Passeio “é um tipo de ” veículo;

Um caminhão “é um tipo de” veículo; Um círculo “é um
tipo de” uma figura geométrica; Um quadrado “é um tipo
de” figura geométrica; Um vendedor “é um tipo de”
Empregado; Um empregado “e um tipo de” pessoa.

Herança Múltipla – Uma subclasse herda características

de mais de uma classe

Exemplos: Um gerente de vendas “é um tipo” de

vendedor e “é um tipo de” gerente;
8
HERANÇA x USO

Além da relação de herança entre as classes

existe a relação de uso

HERANÇA
classe A “é um tipo de” B

USO / AGREGAÇÃO (Relação de Conteúdo)

classe C “contém” classe D”
classe C “usa” classe D”
classe C “é parte da” classe D”
Ex.: Uma placa de circuito eletrônico contém resistores;
capacitores e CIs
HERANÇA x USO
9
ENCAPSULAMENTO

Encapsulamento é um termo que indica que os dados

contidos em um objeto somente poderão ser acessados
através de seus métodos.
Dessa forma não é possível alterar os dados diretamente,
somente através de métodos. Ex: O raio somente pode ser
alterado/ recuperado pelos métodos setCenter/ getCenter.
CIRCULO
Ponto center
Raio r
getArea
getPerimeter
getCenter
getRadius
setCenter
setRadius
POLIMORFISMO

Os objetos respondem às messagens que eles

recebem através dos métodos. A mesma mensagem
pode resultar em diferentes resultados. Esta
propriedade é chamada de polimorfismo
Ex: getSalario()
Para um empregado qualquer Æ getsalario() = Salario;
Para o gerente Æ getsalario() = salario + bonificacao;
Ex: draw()
Para uma figura qualquer desenha uma forma não definida
Para o retângulo, triângulo e círculo o mesmo método
responde de uma forma diferente
10
POLIMORFISMO - Exemplo
FIGURA
draw()
?
RETÂNGULO TRIÂNGULO CÍRCULO

draw() draw() draw()
ANÁLISE ORIENTADA A OBJETOS (OOA)

Objetivo básico – Identificar classes a partir das

quais objetos serão representados como
instâncias
Envolve as seguintes tarefas

Identificação de Objetos

Especificação de Atributos

Definição de métodos

Comunicações entre objetos

Em uma especificação:

NOMES são potenciais objetos

VERBOS são potenciais métodos
11
ANÁLISE ORIENTADA A OBJETOS (OOA)

IDENTIFICAÇÃO DE OBJETOS – CRITÉRIOS

1. RETENÇÃO DE INFORMAÇÃO – Objeto deve
guardar informação que será utilizada pelo sistema
2. SERVIÇOS NECESSÁRIOS – Conjunto de operações
identificáveis que podem mudar o valor de seus
atributos
3. MÚLTIPLOS ATRIBUTOS – Objeto deve conter mais
de um atributo
4. ATRIBUTOS COMUNS – Conjunto de atributos deve
ser aplicado a todos os objetos
5. OPERAÇÕES COMUNS – Conjunto de operações
devem ser aplicáveis a todos os objetos.
6. REQUISITOS ESSENCI AIS – Entidades externas que
aparecem no espaço problema que consomem e/ ou
produzem informação
RESUMO:
ANÁLISE E PROJETO ORIENTADO A OBJETOS
Os seguintes passos são necessários para a solução de um
problema utilizando a programação orientada a objetos

ENTENDER O PROBLEMA

IDENTIFICAR OS OBJETOS / CLASSES

ESPECIFICAR OS ATRI BUTOS (DADOS) DOS OBJETOS

Quais dados são necessários para descrever o objeto?

DEFINIR OS MÉTODOS(PROCEDIMENTOS) NECESSÁRIOS

PARA O OBJETO

Quais as responsabilidades do objeto? Qual ações deve executar?

IDENTIFICAR A COMUNICAÇÃO ENTRE OS OBJETOS

EX.: Objeto Tela irá solicitar ao objeto Retângulo que o mesmo se

desenhe.

IMPLEMENTAR AS CLASSES

Criação do código do programa utilizando uma linguagem

Orientada a objetos
12
UTILIZANDO DO DevC+ +

Será utilizado o ambiente DevC+ + . Versão 4.9.7.0

Ambiente gráfico; Em português; Gratuito

Utiliza compiladores da família gcc

Criando um novo Projeto

Arquivo Æ Novo Æ Projeto...

Um projeto contém todas as informações necessárias para compilar e

criar programas. Em um projeto são armazenados todos os arquivos
necessários (arquivos .cpp; .h e .rc)

O projeto (hello.dev) deve ser salvo de preferência em uma pasta

específica para o mesmo.
UTILIZANDO O DevC+ +

Criando um novo Projeto / Salvando Arquivos

Um projeto “Console Application” consiste de um

programa que será executado no terminal do S.O em
modo texto.

Após criar o projeto automaticamente será criada a

função main, necessária para a execução do mesmo
int main(int argc, char *argv[])

Além disso um arquivo main.cpp será criado. Neste

arquivo existe o código básico de uma “Console
Application”. Este arquivo deve ser salvo na pasta criada
para o projeto.
Para salvar um arquivo utilize a opção do menu Arquivo
Æ Salvar (Ctrl + s) ou então a barra de ferramentas

13
Editando programas

O editor de programas possui recursos interessantes como:

navegador de classes; diferentes cores para diferentes
partes do código; complemento de código; entre outras.

Cada parte do código possui uma cor específica:

Palavras reservadas da linguagem – preto / negrito

Texto (Strings) – vermelho

Números – roxo

Preprocessador - verde

Comentário – azul
/ / console application - código básico
# include < iostream>
# include < stdlib.h>
int main(int argc, char * argv[ ] ){
printf("Hello World!\ n\ n");
system("PAUSE");
return 0;
} Flávio de Oliveira Silva 27

Compilando programas

Para compilar os programas utilizar o menu Executar Æ

Compilar (Ctrl + F9) Editor
Código Preprocessador Header

main.cpp stdlib.h
Compilador
g++.exe
Arquivo Objeto
hello.o
Arquivos Objeto Linker Bibliotecas

*.o libgcc.a
Arquivo Executável
hello.exe
14
CONFIGURANDO O DevC+ +

Um problema muito comum é o compilador e o linker não

encontrar os arquivos .h e as bibliotecas necessárias
Para Configurar o DevC+ + para utilização do código em C+ +
inicialmente deve ser utilizado o menu: Ferramentas Æ

Opções do Compilador

Em seguida deve-se clicar no tab DI RETÓRI OS.

No tab BI NÁRI OS deve existir a seguinte informação:

C:\ Dev-Cpp\ Bin

Esta é a pasta que contém os executáveis (compilador;

linker; etc.)

No tab BI BLI OTECAS deve existir a seguinte informação:

C:\ Dev-Cpp\ lib

Esta é a pasta que contém as bibliotecas que serão

utilizadas pelo linker

No tab “C I NCLUDES” deve existir a seguinte informação:

C:\ Dev-Cpp\ include

Esta é a pasta que contém arquivos .h básicos utilizados

normalmente por um programa que utiliza apenas C padrão

No tab “C+ + I NCLUDES” deve existir as seguintes

informações:

C:\ Dev-Cpp\ include\ c+ +

C:\ Dev-Cpp\ include

C:\ Dev-Cpp\ include\ c+ + \ mingw32

C:\ Dev-Cpp\ include\ c+ + \ bits

Estas pasta que contém arquivos .h básicos utilizados

normalmente por um programa que utiliza C+ +
Nos exemplos acima é considerado que o DevC+ +

está instalado na pasta: “C:\ Dev-cpp”. Caso a pasta
seja outra o nome deve ser substituido .
15

A figura abaixo mostra a tela de configuração. Para adicionar

ou remover pastas deve ser utilizado os botões localizados na
parte inferior da tela.
DEPURANDO PROGRAMAS

Um recurso importante do compilador é a possibilida de

depurar (debug) o código. Para isto inicialmente é necessário
informar ao compilador que gere informações adicionais que
serão utilizadas pelo debugger.

Para configurar deve-se utilizar o menu Projeto Æ Opções do

Projeto. Em seguida deve-se clicar no tab e marcar “YES” em
“Gerar informação de depuração”, conforme mostrado abaixo.
16
DEPURANDO PROGRAMAS

Feito isto além de gerar o código será também gerada a

informação para depuração.

O próximo passo é criar “BreakPoints” que são pontos de

parada durante a execução do código. Para criar um
“breakpoint” basta clicar na faixa preta ao lado de cada linha,
conforme mostrado abaixo:
As linhas que contém “breakpoints” são destacadas

Para iniciar o processo de depuração utiliza-se o menu DEBUG
ÆDEBUG ( F8)

DEPURANDO PROGRAMAS

Após o processo de debug ser iniciado pode utilizar o painel

inferior para executar o programa passo a passo(opção
“Próximo passo”)

Para inspecionar métodos deve-se utilizar a opção “passar por

dentro” antes da execução do mesmo. Dessa forma o debugger
irá passar o controle para o método, sendo possível assim,
observar o seu funcionamento.

Para inspecionar o conteúdo de variáveis e objetos, deve-se

selecionar a variável e clicar no botão “Adicionar Marcador”
17
C+ + CARACTERÍSTICAS
Linguagem compilada

ANSI C – Padrão e Portabilidade

Programação em Alto nível e baixo nível

Programação Estruturada

Utilização da memória: Ponteiros
C++

Criado por Stroustroup em 1980

Novos conceitos em procedimentos

(Sobrecarga; Templates; exceções; converões de tipos)

Programação orientada a objetos

(Classes; Herança; Encapsulamento; Polimorfismo)
Aplicação Console – Código Básico

/ / Preprocessador inclui o arquivo stdio.h - definição da função printf
#include <stdio.h>
/ / Inclue funções básicas, neste caso a função system
#include <stdlib.h>
/ / Definição da função main. Uma aplicação console deve possuir uma
/ / função main
int main(int argc, char *argv[])
/ / Inicio do bloco da função main
{
/ / Imprime o texto - Hello World! – e duas quebras de linha
printf("Hello World!\n\n");
/ / Chama um comando do console, neste caso o comando PAUSE
system("PAUSE");
/ / Finaliza o processamento da função main e retorna
return 0;
/ / fim do bloco da função main
}
18
COMANDOS e EXPRESSÕES

Comando é a menor unidade de um programa C+ + e pode

conter uma ou mais linhas

Os comandos são finalizados por ;

Um bloco contém uma sequência de comandos que são

executados sequencialmente e inicia com o caracter { e termina
com o caracter }

É possível a criação de blocos dentro de blocos de programa

Uma expressão representa uma operação executada pelo

programa. Ex: Definição de Variável; Expressão Aritmética ou
lógica; Mensagem entre objetos
{
expr1;
expr2;
{
exprI1;
exprI;
}
...
expr3;
}
TIPOS BÁSICOS

Tipos de dados são abstrações utilizadas e manipuladas por uma

linguagem.

Tipos fundamentais fazem parte da linguagem e estão sempre

disponíveis para serem utilizados

Quando uma classe é criada um novo tipo fica disponível para o

programa

A tabela abaixo mostras os tipos fundamentais (plataforma 32 bits)

Também conhecido Tamanho
Tipo Característica Valor Mínimo Valor Máximo
como (bytes)
bool booleano 1 0 1
char signed char caracteres 1 -128 127
unsigned char caracteres sem sinal 1 0 255
short short int; signed short int inteiro pequeno 2 -32768 32767
unsigned sort unsigned short int inteiro pequeno sem sinal 2 0 65535
int signed; signed int inteiros 4 -2.147.483.648 2.147.483.648
unsigned int unsigned inteiro sem sinal 4 0 4.294.967.295
long long int; signed long int inteiro grande 4 -2.147.483.648 2.147.483.648
unsigned long unsigned long int inteiro grande sem sinal 4 0 4.294.967.295
float ponto flutuante; precisão simples 4 -3.4e-37 3.4e+38
double ponto flutuante; precisão dupla 8 -1.7e-307 1.7e+308
long double ponto flutuante; precisão dupla 8 -1.7e-307 1.7e+308
19
VARIÁVEIS

Toda variável deve ser declarada sendo necessário a definição do

seu tipo
int iX;
dobule dX, dY;
bool bValue;

Durante a declaração é possível inicializar a variável, definindo

um valor inicial para a mesma
int iX = 200; / / Sintaxe C padrão
int iX(200), iY(244) / / Sintaxe C+ +

Uma varíavel declarada dentro um bloco é válida somente dentro

daquele bloco. Neste caso ela possui um “escopo LOCAL”

Uma varíavel declarada fora de um bloco possui um “escopo”

GLOBAL”

A keyword const especifica uma variável cujo valor não pode

ser modificado
const double PI = 3.14159;
OPERADORES

ARITMÉTICOS – "+ " "-" "* " "/ " "%"

int iA = 13; //declara e inicializa
int iV(7); //declara e inicializa
float f1; //declara a variável
f1 = 13; //Inicializa variável
iA+iV //retorna 20
iA-iV //retorna 6
iA*iV //retorna 91
iA/iV //retorna 1
f1/iV //retorna 1.8571428
f1%iV //operador módulo – retorna resto
//inteiro da divisão de f1 por iV
//neste caso o valor é zero.
20
OPERADORES

INCREMENTO ("+ + ") E DECREMENTO("--")

Funcionam como operadores unários

int iY, iX = 10 //iY indefinido e iX igual a 10

//Incremento prefixado – incrementa primeiro iX
//e depois Atribui a iY
iY = ++iX;
//Neste ponto iY = 11 e iX = 11;
//Incremento pós-fixado – Primeiro atribui iX a
//iY e depois incrementa iX;
iY = iX++;
//Ao final iY = 11 e iX = 12;
OPERADORES

LÓGICOS – "&&" (AND) "| | " (OR) "!" (NOT)

int bX, bY;
bX bY bX && bY bX || bY !bX
true true true true
false
true false false true
false true false true
true
false false false false

Em C+ + se uma expressão é false, o seu retorno

equivale a zero de tipo int - int false(0). Uma
expressão é true se retorna um valor diferente de
zero.
21
OPERADORES

RELACIONAIS
IGUALDADE == MENOR OU IGUAL QUE <=
DESIGUALDADE != MENOR OU IGUAL QUE <=
MENOR QUE < MAIOR OU IGUAL QUE >=
Exemplos:
int iH = 4, iJ = 4, iK = 6;
iH == iJ //Retorna 1
iH == iK //Retorna 0
iK == iK //Retorna 1
iH < iK //Retorna 1
iH < iJ //Retorna 0
iH <= iJ //Retorna 1
OPERADORES

OPERADORES BINÁRIOS
"AND" BINÁRIO & "OR" INCLSUIVO BINÁRIO |
"OR" EXCLUSIVO BINÁRIO ^ COMPLEMENTO BINÁRIO ~
Exemplos:
int c = 4; //binário 00000100
int d = 6; //binário 00000110
int bytRes;
bytRes = c & d; //retorna 4 00000100
bytRes = c ^ d; //retorna 2 00000010
bytRes = c | d; //retorna 6 00000110
bytRes = ~c; //retorna -5 11111011
bytRes = d >> 2; //retorna 1 00000001
bytRes = d << 2; //retorna 24 00011000
22
OPERADORES

OPERADOR CONDICIONAL( ? : )
Exemplo:
a?b : c / / retorna o valor b se a é true,
/ / caso contrário retorna o valor c
OPERADORES

Associatividade da esquerda para direita

Regras de Precedência
[] . e++ e--
-e !e ~e ++e --e
new
* / %
+ -
== !=
&
^
|
&&
||
?:
Exemplos: = += *= /= %= >>= <<=
&= ^= !=
a/b*c interpretado como (a/b)*c
a+b*c/d interpretado como a+((b*c)/d)
23
OPERADORES IMPORTANTES
ATRIBUI ÇÃO DE VALORES(Operador = )
Variável (v e v1) à esquerda irá conter o valor E,
especificado à direita.
v = E;
v = v1 = E; equivale a v = (v1 = E); / /Evitar!!!
ATRIBUI ÇÃO COM OPERADOR (op= )
Sendo op um operador
v op= f; equivale a v = v op f;
Ex: a + = 2; equivale a a = a + 2;
OPERADORES IMPORTANTES
ASSESSANDO UM MÉTODO DE UM OBJETO
Utiliza-se o operador ponto "." ou então o
operador "-> "
Exemplo:
Circle* pC = new Circle();
/ / No caso acima pC é um ponteiro para um circle
pC-> getName();
Circle c(3); / / Neste caso Circle não é um ponteiro,
c.getArea(); / / mas sim uma variável estática!
24
ESTRUTURA DE UM PROGRAMA EM C+ +
# include
# define
Definições de Variáveis globais
Protótipos de funções/ classes
Funções criadas pelo programa / Métodos de classes
int main()
{
...
return 0;
}
ARQUIVOS INCLUDE

A diretiva # include informa que um arquivo de

cabeçalho (* .h) deverá ser incluido, pelo processador,
no ponto indicado

Os arquivos de cabeçalho (header files) pode conter

protótipos de funções; definições de constantes e
definições de classes juntamente juntamente com
seus atributos e métodos

Para incluir um arquivo somente é necessário informar

o nome do arquivo sem a necessidade de indicar sua
localização, para que a compilação ocorra
corretamente é necessário que as pastas de arquivos
INCLUDE esteja corretamente configura no projeto ou
então no ambiente de desenvolvimento.

Para configurar as pastas onde estão os arquivos de

includes no DEVC+ + deve ser utilizado o menu:
FERRAMENTAS Æ OPÇÕES DO COMPILADOR Æ DIRETÓRIOS
25
DIRETIVA # DEFINE E VARIÁVEIS GLOBAIS

A diretiva # define é utilizada para dar um nome a

um valor constante que será utilizado em todo o
programa.

Após a definição de uma constante através da diretiva

# define, em todas as ocorrências subsequentes no
código, após a definição, o nome utilizado, será
substituido pela constante no momento da compilação

Com a diretiva # define é possível também criar

macros que são utilizados pelo programa

Exemplos:
#define PI 3.141519
#define maior(x,y)((x>y) ? x : Y)
ESPOCO (VISIBILIDADE) EM UMA CLASSE

Dentro de uma classe os métodos e atributos

possuem o seguinte escopo:

public: Método ou atributo visível a todas as

classes

protected: Método ou atributo visível nas

subclasses

private: Método ou atributo visível somente

na classe onde é utilizado
26
SOBRECARREGAMENTO (Overloading)

Consiste em possuir mais de um método com o

mesmo nome, porém com diferentes
parâmetros (número, ordem e tipos)

Este recurso é utilizado para métodos que

realizam tarefas semelhantes porém sobre tipos
de dados diferentes

Normalmente este recurso também é utilizado

no construtor da classe

O sobrecarregamento facilita a reutilização de

código
Exemplo: Circle c = new Circle();
c.move(x,y);/ / Recebe a coordenada x e y
c.move(p); / / Recebe o objeto ponto
CRIANDO UMA CLASSE EM C+ +

Definição classe - Necessário keyword class

Corpo da Classe – Delimitado por { e po r }

A classe contém dados (atributos ou variáveis

membro) e métodos(procedimentos)

Dados (Variáveis Membro)

Dados que representam o objeto; Podem ser

acessados, diretamente, semelhante a uma
“variável global” em qualquer método

MÉTODOS

CONSTRUTORES

DESTRUTORES

MODIFICADORES

ACESSORES

OUTROS MÉTODOS
27
MÉTODOS CONSTRUTORES

Método especial. Deve possuir o mesmo

nome da classe

Inicializa os dados (variáveis membro) do

objeto. Pode também alocar memória e fazer
usos de outros recursos (arquivo, por
exemplo)

Garante que objetos iniciem em um estado

consistente

Construtores normalmente são

sobrecarregados

Construtores não podem retornar um valor


MÉTODO DESTRUTOR

A idéia do destrutor é devolver os recursos para o

sistema no momento de sua chamada

O método destrutor não tem parâmetros e não retorna

valor.

Sua assinatura é: ~ NOMECLASSE( )

O programa deve liberar todos os recursos utilizados,

como por exemplo a memória pelo construtor da classe

Sempre que um objeto sai de seu escopo seu destrutor

será automáticamente chamado

Exemplo de uso: Fechar arquivos abertos / Liberar

Memória
28

MÉTODOS MODIFICADORES (setXXX)

Permitem a modificação dos dados (variáveis

membro) do objeto

Devem ser do tipo public, pois são acessados de

forma externa ao objeto

Normalmente começam com o “set” a fim de facilitar

o entendimento de seu objetivo.

MÉTODOS ACESSORES (getXXX)

Permitem a recuperação dos dados (variáveis

membro) do objeto

Devem ser do tipo public, pois são acessados de

forma externa ao objeto

Normalmente começam com o “get” a fim de facilitar

o entendimento de seu objetivo.

OUTROS MÉTODOS

Executam tarefas que são de responsabilidade do objeto

e que irão representar o comportamento do mesmo.

Estes métodos podem ser públicos (public) ou

privados(private), conforme sua utilização

Para que o método seja acessado externamente o mesmo

de ser do tipo público (public)

Caso o método seja apenas auxiliar à classe sem uma

ligação direta com o comportamento do objeto o mesmo
deve ser do tipo privado (private). Normalmente este
métodos são utilizados por um outro método público
29
DECLARAÇÃO DE UMA CLASSE EM C+ +
class NomeClasse {
modificadorAcesso:
[ tipoVariavel] tipo variavel_membro1;
[ tipoVariavel] tipo variavel_membroN;
modificadorAcesso:
/ / Construtores
NomeClasse();
NomeClasse(T0, T1,...);
/ / Destrutor
~ NomeClasse();
/ / Modificadores
tipoRetorno setXXX(T0, T1,...);
/ / Acessores
tipoRetorno getXXX (T0, T1,...);
/ / Outros métodos (privados e públicos)
tipoRetorno Metodo(T0, T1,...)
};
DECLARANDO UMA CLASSE EM C+ +

class Circle{
private:
double dRaio, dXCenter, dYCenter;
public:
//Construtores (sobrecarregado)
Circle(double);
Circle(double, double, double);
//Destrutor
~Circle();
//Métodos Modificadores
void setRaio(double);
void setCenter(double, double);
//Métodos Acessores
double getRaio();
double getXCenter();
double getYCenter();
//Outros métodos
double getArea();
}; Flávio de Oliveira Silva 60
30
DECLARANDO UMA CLASSE EM C+ +

A declaração da uma classe é sempre feita em um arquivo

* .h, que é um arquivo de cabeçalho.

A implementação da classe é feita em um arquivo * .cpp,

onde necessariamente deverá ser incluido o arquivo .h
correspondente

A forma de trabalho acima não é obrigatória mas é um

interessante padrão de trabalho a fim de facilitar o
compartilhamento dos objetos. Exemplo:

Circle.h / / Declaração da classe Circle

Circle.cpp / / Implementação da classe Circle

O arquivo * .h é um código em C+ + como outro qualquer

logo é possível em seu interior utilizar as diretivas # define
e # include, caso seja necessário incluir a definição de
algum outro objeto definido anteriormente. Exemplo
//Arquivo Circle.cpp
#include "Circle.h"
IMPLEMENTANDO UMA CLASSE EM C+ +

//Includes necessários
#include <iostream>
#include "Circle.h"
using namespace std;
#define PI 3.141592653589793
Circle::Circle(){
dRaio = dXCenter = dYCenter = 0;
cout << "Construindo(1) objeto Circle!" << endl; }
Circle::Circle(double dR){
dRaio = dR;
dXCenter = dYCenter = 0;
//Construtor Sobrecarregado
Circle::Circle(double dR, double dX, double dY){
dRaio = dR;
dXCenter = dX;
dYCenter = dY;
31
//Destrutor
Circle::~Circle(){
dRaio = dXCenter = dYCenter = 0;
cout << "Destruindo o objeto Circle!" << endl; }
//Métodos Modificadores
//Ajusta o raio do círculo
void Circle::setRaio(double dR){
dRaio = dR; }
//Ajusta a coordenada X do Centro
void Circle::setXCenter(double dX){
dXCenter = dX; }
//Ajusta a coordenada Y do Centro
void Circle::setYCenter(double dY){
dYCenter = dY; }
void Circle::setCenter(double dX, double dY){
dXCenter = dX;
dYCenter = dY; }

//Métodos Acessores
//Recupera o raio o Círculo
double Circle::getRaio(){
return dRaio; }
//Recupera a coordenada X do Centro
double Circle::getXCenter(){
return dXCenter; }
//recupera a coordenada Y do Centro
double Circle::getYCenter(){
return dYCenter; }
//Outros métodos
//Calcula área do círculo
double Circle::getArea(){
return PI * dRaio * dRaio;
}
double Circle::getPerimeter(){
return 2 * PI * dRaio;
}
32
UTILIZANDO UMA CLASSE EM C+ +
#include <iostream>
#include "Circle.h"
int main (int argc, char *argv[]){
//cout imprime uma linha de texto na saida padrão
cout << "Hello C++ World!" << endl;
//Cria os objetos utilizando diferentes construtores
Circle c1;
Circle c2(4);
Circle c3(3,4.5,5.5);
c1.setCenter(5,5);
c1.setRaio(10);
cout << "A area de c1 e " << c1.getArea() << endl;
cout << "O perimetro c1 e " << c1.getPerimeter() <<
endl;
//continua... C+ + Orientado a Objetos
UTILIZANDO UMA CLASSE EM C+ +

//Cria um bloco de código
{
cout << "Novo bloco de codigo " << endl;
Circle *c1 = new Circle();
c1->setRaio(3);
cout << "O perimetro c1 e " << c1->getPerimeter()
<< endl;
Circle c2(2);
cout << "O perimetro c1 e " << c1->getPerimeter()
<< endl;
delete c1;
cout << "Finalizando o bloco de codigo. Ao sair c2
será destruido!" << endl;
}
cout << "Digite 0 para finalizar..." << endl;
int iRet(0);
cin >> iRet;
return iRet;
33
ESTRUTURAS DE CONTROLE

ESTRUTURA DE SELEÇÃO – if / if- else

Uma instrução (ou bloco de instruções) somente será executada caso

uma condição (expressão condicional E) resultar em verdadeiro (true)
if (E)
S;

Uma variação da estrutura acima é a estrutura if-else. Onde uma

escolha é feita. Se a expressão condicional (E) for verdadeira (true)
então um o bloco de instruções logo após a expressão será executado.
Caso contrário, sendo a expressão falsa (false) então o bloco que se
encontra após a palavra else será executado.
if (E)
S;
else
R;

EXEMPLO
if (nota >= 60)
cout << “Aprovado” << endl;
else
cout << “Reprovado” << endl;

ESTRUTURA DE SELEÇÃO MÚLTIPLA – sw itch

A estrutura if/ else permite a seleção no máximo entre 2 blocos

diferentes.

Caso seja necessário um número maior de opções então deve ser

utilizado a estrutura sw itch. Exemplo:
switch (E) {
case c1 : S1;
break;
case c2 : S2;
break;
...
default : Sd;

Inicialmente a expressão E é avaliada. Caso a expressão E, resulte na

constante c1, o bloco de instruções S1 será executado, até que a
palavra break seja encontrada. Neste caso o próxima instrução após o
switch será executada. Da mesma forma caso E, resulte na constante
c2 o bloco S2 será executado. E assim, sucessivamente.

Caso a expressão E não resulte em nenhum valor constante presente

no swith (c1, c2, ...) então o bloco padrão (default) Sd será
executado

O bloco default (Sd) é opcional, não sendo necessário sua presença.

34
Os valores constantes utilizados no switch podem ser do tipo btye; short;

int, long e char ( em geral números inteiros) . Exemplo:

int a = 2;
switch (a){
case 1 : {
cout << "A é igual a 1“ << endl;
cout << "Ok!“ << endl;
break;
}
case 2 : {
break;
}
case 3 : {
break;
}
default : {
cout << "A é diferente de 1,2e3“ << endl;
}

ESTRUTURA DE REPETIÇÃO – w hile

Esta estrutura indica que a instrução ou bloco de instruções (S) que se

encontra logo após uma expressão condicional (E) será executado
ENQUANTO tal expressão por verdadeira (true) ou seja diferente de
zero.
while (E)
S;

Quando a última instrução do bloco é executada a expressão (E) será

novamente executada e caso continue verdadeira o bloco será
executado mais uma vez, e assim, sucessivamente.

A fim de evitar que a execução do bloco de instruções (S) execute

indefinidamente é necessário que dentro deste bloco o valor da
expressão condicional seja em algum momento alterado para falso
(false).

No caso da instrução while, sempre é feito um teste antes da

execução do bloco. Dessa forma para que o bloco seja executado, pelo
menos uma vez, o resultado da expressão inicialmente seja verdadeiro.

Ao terminar a repetição a primeira instrução após a instrução while é

executada.
35

ESTRUTURA DE REPETIÇÃO – w hile

Exemplo:
int a;
a = 0;
//A instrução abaixo fosse executada não permitiria a repetição
//a = 10
while (a < 10)
{
cout << “A ainda é menor que 10!” << endl;
//Sem a instrução abaixo a repetição nunca terminaria
a++;
}
//Primeira instrução a ser executada após o while
cout << “Agora, a é igual a 10!” << endl;

ESTRUTURA DE REPETIÇÃO – do / w hile

Esta estrutura é semelhante ao while, porém sempre o bloco de

instruções (S) será executado pelo menos uma vez. Em seguida a
expressão condicional (E) é avaliada e o bloco de instruções será
executada ENQUANTO seu valor for verdadeiro.
do {
S;
} while (E);

Caso a expressão seja verdadeira a primeira instrução do bloco será

executada novamente

ESTRUTURA DE REPETIÇÃO – for

Neste caso a repetição e controlada por um contador da seguinte forma:

for (C; E; I)
S;

O bloco de instruções S, será executado enquanto a expressão

condicional E, for verdadeira. O contador é inicializado pela expressão C
e a expressão I é responsável por alterar o valor do contador.
36

ESTRUTURA DE REPETIÇÃO – for

Exemplo:
int i;
for (i = 0; i < 10; i++){
cout << “O contador I ainda é menor que 10!” << endl;
}

No exemplo acima, o contador é um número inteiro i. A instrução

será executada enquanto a expressão for verdadeira (i < 10) e i
será incrementado de 1 em 1.

No laço pode ser utilizada instrução break que irá finalizar o

mesmo desviando o controle para fora do laço for

A instrução continue desvia o controle para o ínicio do laço for,

não executando o restante das instruções do laço. A diferença
entre continue e break, é que a instrução continue não finaliza
a repetição.

break e continue podem ser utilizados também com w hile;

do/ w hile
ARRAYS (VETORES)

Importante estrutura de dados. Consiste em um grupo de

“OBJETOS” do mesmo tipo, onde a cada objeto é
associado um “ÍNDICE” único.

Estes objetos estão armazenados em uma posição

contígua da memória. O número de objetos contidos é
definido como sendo o TAMANHO do vetor. A seguir é
mostrada a sintaxe para a criação de um array.
Exemplos:
//O código abaixo declara um array de 50
//posições
int iNotas[50];
//Na declaração abaixo o tamanho é
//calculado pelo compilador
int iPrimos[] = {1, 3, 5, 7, 11};
//Cria um array de objetos da classe Circle
Circle aCircle[10];
37
ARRAYS (VETORES)

O acesso da cada elemento pode ser feito da seguinte

forma:
aNotas[0] = 15 //Primeiro elemento
...
aNotas[49] = 34 //Último elemento

Os vetores são estruturas “estáticas”, sendo que uma vez

criados não podem ter o seu tamanho alterado. Porém
sua criação é feita de forma dinâmica, durante a
execução do código.

Para um array de comprimento n, seus índices variam de

0 a n-1.

Um índice equivale a um deslocamento a partir do início

do vetor.

Em c+ + é possível deslocar após o final do vetor. Isto

deve ser sempre evitado!!!
ARRAYS (VETORES)

Exemplos de manipulação de elementos: É possível manipular

em expressões tanto o índice do vetor, quanto cada elemento.
//Soma de elementos
int iSoma = aNotas[0] + aNotas[3] + aNotas[3+1];
int iPrimeiro, iSegundo, iTerceiro, iResultado ;
iPrimeiro = 0;
iSegundo = 1;
iTerceiro = 2;
//adiciona 7 a quarto elemento do vetor (0+1+2=3)
aNotas[iPrimeiro + iSegundo + iTerceiro ] += 7;
iResultado = aNotas[5]/2 + aNotas[3/3]*3
38
ARRAYS (VETORES)

O comprimento de um vetor pode ser obtido utilizando-se o

operador sizeof.

O operador sizeof retorna o tamanho em bytes do operando.

int iSizeOfInt = sizeof(int);
int iSizeOfCircle = sizeof(Circle);

Para calcular o número de elementos do vetor, basta calcular o

tamanho em bytes do vetor e dividir pelo tamanho de um
elemento deste vetor da seguinte forma:
int iArraySize(0);
iArraySize =(sizeof aNotas)/(sizeof aNotas[0]);
iArraySize =(sizeof aCircle)/(sizeof aCircle[0]);
ARRAYS (VETORES)

Percorrendo todos os elementos de um vetor

int iArraySize(0);
iArraySize =(sizeof aNotas)/(sizeof aNotas[0]);
for (int ii = 0; ii < iArraySize ; ii++){
if (aNotas[ii] >= 60)
cout << “Aprovado" << endl;
else
cout << “Reprovado" << endl;
}
39
ARRAYS (VETORES)

VETORES MULTIDIMENSIONAIS – Neste caso cada

elemento do vetor possui mais de um índice associado
ao mesmo.

Uma matriz ou tabela é um vetor de duas dimensões.

Neste caso pode ser dito que a informação está
organizada em linhas e colunas. Exemplo:
int aMatriz[2][3];
aMatriz[0][0] aMatriz[0][1] aMatriz[0][2]
aMatriz[1][0] aMatriz[1][1] aMatriz[1][2]
ARRAYS (VETORES)

Exemplo: Um vetor com três dimensões

int aCuboInteiros[3][3][3];

Percorrendo todos os elementos de um vetor

bidimensional(matriz)
for (int i = 0; i < iRowSize; i++)
{
for (int j = 0; j < iColSize; j++)
cout << “Percorrendo a matriz” << endl;
40
ARRAYS (VETORES) DE CARACTERES

Em c+ + as sequências de caracters (Strings) são tratadas

como um vetor de caracteres, ou seja de elementos do tipo
char

Inicializando um vetor de caracteres

char sNome[ ] = "Flavio", sCurso[ 4] = "C+ + ";
char sLinhaDeTexto[ 256] ;

O tamanho do vetor equivale o número de bytes do mesmo,

visto que cada elemento do tipo char, possui um byte.

Um vetor de caracteres sempre é finalizado pelo caracter NULL

('\ 0') [0] = ’C’

Ao percorrer um vetor de caracteres [1] = ’+’

deve-se parar esta operação ao [2] = ’+’
encontrar um caracter NULL [3] = ’\0’
[4] = ’?’

O código abaixo mostra como criar um método que é

responsável por “concatenar” dois vetores de caracteres:
//Definição da classe que irá manipular
//vetores de caracteres (MyString.h)
#define MAX_SIZE 256
class MyString {
private:
char sData[MAX_SIZE];
public:
MyString();
MyString(char[]);
void append(char sOther[]);
int length();
void print();
};
41
//Arquivo MyString.cpp
#include <stdio.h>
#include "MyString.h"
MyString::MyString(){
int ii(0);
while (ii < MAX_SIZE){
sData[ii]= ’\0’;
ii++;
}
}
//Construtor que copia uma string para outra
MyString::MyString(char pSource[]){
int ii(0);
while (ii < MAX_SIZE){
sData[ii]= ’\0’;
ii++;
}
//continua... C+ + Orientado a Objetos

//continuando...
ii=0;
while (sData[ii] = pSource[ii])
ii = ii++;
}
int MyString::length(){
int ii(0);
while (sData[ii] != ’\0’){
ii = ii++;
}
return ii;
}
void MyString::print(){
printf("%s\n", sData);
}
42
//O método abaixo realiza a junção da string contida
//no objeto MyString com a string pSource
void MyString::append(char pSource[]){
int ii(0);
while (sData[ii] != '\0'){
ii = ii++;
}
int jj(ii);
ii = 0;
while (pSource[ii] != '\0'){
sData[jj+ii] = pSource[ii];
ii = ii++;
}
sData[jj+ii]='\0';
}

//O código abaixo mostra o uso da classe MyString
#include <iostream>
#include "MyString.h"
//Cria um objeto da classe MyString
MyString str(“TRABALHANDO");
//Cria um vetor de caracteres
char str2[] = " COM VETORES DE CARACTERES";
str.append(str2);
//Imprime a string que representa MyString + str2
str.print();
int iRet(0);
cin >> iRet;
return iRet;
43
PONTEIROS

Ponteiro é um tipo de varíavel que contém um endereço de

memória.

Sendo assim, estea varíavel “aponta” para um outra varíavel ou

objeto

O uso de ponteiros é um recurso poderoso da linguagem C+ + .

Ponteiros para variáveis podem ser alocados de forma
dinâmica, ou seja, durante a execução do programa.

Como o ponteiro representa o endereço do objeto é mais

eficiente passar para um método um ponteiro para aquele
objeto do passar uma cópia do objeto, que utiliza maior
quantidade de memória.

Declarando ponteiros: Para declarar um ponteiro basta colocar

um * antes entre o tipo e o nome da variável:
int *pValor; //contém o endereço de um int
double *pCorrente,*pVoltagem;
char* pString;
PONTEIROS

O operador &(endereço de) retorna o endereço de uma

varíavel, desta forma para atribuir a um ponteiro um valor é
necessário o seguinte código:
int iValor(34); //declar um inteiro
int *pValor; //declara um ponteiro
pValor = &iValor; //ponteiro recebe o endereço

Um ponteiro sempre é incializado com um endereço qualquer. É

possível atribuir o valor NULL a um ponteiro desta forma ele
não contém nenhum endereço válido
char* pString = NULL; Endereço Variável Valor
1000 iValor 34
1001
1002 pValor 1000
1003
44
PONTEIROS

O ponteiro pode apontar para qualquer tipo básico da

linguagem e também para objetos de qualquer classe. Sendo
assim um ponteiro está sempre associado a algum tipo.

C+ + suporta um tipo especial de ponteiro, chamado ponteiro

void, que pode apontar para objetos de qualquer tipo.
void* pQualquer;
void* pVetorVariosTipos[32];

É possível a criação de vetores de ponteiros. Um vetor de

ponteiros pode ser manipulado da mesma forma que qualquer
outro vetor. Porém o que este vetor contém é endereços de
outros objetos

Para acessar métodos de um ponteiro para um objeto deve ser

utilizado operador ponteiro (-> ), conforme mostrado abaixo:
Circle c(3);
Circle *pC = &C;
p->area();
PONTEIROS

O ponteiro é inicializado com um valor qualquer. Uma outra

forma de atribuir um valor a um ponteiro consiste fazer o
acesso direto à varíavel que o ponteiro aponta e então realizar
a atribuição

Exemplo de atribuição em um ponteiro:

int *pValor; //declara um ponteiro para inteiro
...
*pValor = 34;//Atribui á variavel seu valor

Sempre que colocamos no código *varName estamos

fazendo uma referência direta ao objeto.

Neste caso estamos obtendo o objeto para o qual o ponteiro

aponta.
45
ALOCAÇÃO DINÂMICA DE MEMÓRIA

A alocação dinâmica de memória é um meio eficiente, porém

perigoso, de se trabalhar em C+ + .

Ao alocar somente a memória necessária o programa utiliza

somente a memória que vai efetivamente necessitar.

A alocação estática, por sua vez, pode trazer problemas, por

exemplo: Ao alocar 256 posições de memória para uma string
pode acontecer de nunca se utilizar mais que 20 posições ou
então pode ocorrer um estouro. Exemplo: char sNom[256];

Para alocar a memória utiliza-se o operado new, conforme

mostrado abaixo:
int *pValor = new int;
Circle* pCircle = new Circle(3);
char* sNome = new char[256];

Ao utilizar o operador new , o método construtor do objeto é

automaticamente chamado
ALOCAÇÃO DINÂMICA DE MEMÓRIA

Toda memória alocada pelo programa dever ser

necessariamente liberada pelo mesmo!

Para liberar a memória alocada utiliza-se o operador delete

int *pValor = new int;
Circle* pCircle = new Circle(3);
char* sNome = new char[256];
...
delete pValor;
delete pCircle;
delete sNome;

As variáveis estáticas, alocadas pelo programa, são liberadas

automaticamente, não sendo necessária sua remoção

Ao utilizar o operador delete, o método destrutor do objeto é

chamado
46
REFERÊNCIAS

Uma referência pode ser entendida com um “apelido” para um

objeto

Após inicializar uma referência, qualquer alteração no objeto e

na referência ao mesmo serão percebidas em ambos.

Abaixo é mostrado como criar uma referência:

int iNumber(43);
int &iNumberRef = iNumber; //declarando e inicializando
iNumber = 2;
cout << "iNumberRef: " << iNumberRef << endl; //imprime 2
iNumberRef = 3;
cout << "iNumber: " << iNumber << endl; //imprime 3

A referência deve ser sempre inicializada isto pode ser feito

somente uma vez.
REFERÊNCIAS COM PARÂMETROS

Um importante uso de referências é a passagem de

parâmetros para métodos. O uso de referência permite que
o método utilize a variável diretamente e não sua cópia,
aumentando a eficiência e economizando memória.

Sempre que um argumento é passado por referência sua

modificação dentro do método será percebida ao sair do
mesmo, visto que não há uma cópia e sim uma manipulação
direta do objeto.

Para evitar que uma referência seja modificada dentro de

um método pode ser utilizada a palavra reservada const
dessa forma mantém-se os benefícios e evita-se a
modificação da variável. Neste caso não é permitida a
alteração da variável dentro do método, qualquer tentativa
será rejeitada pelo compilador
47
PONTEIROS COMO PARÂMETROS

O uso de ponteiros como parâmetros também é muito

eficiente quando o objeto a ser passado representa uma
grande quantidade de memória

Outro interessante uso do ponteiro ocorre quanto é

necessário a modificação do objeto dentro do método.

Quando um ponteiro é passado para o método, na realidade

é passado apenas o endereço de um outro objeto. Sendo
assim qualquer modificação dentro do método será refletida
no objeto.
PASSAGEM

DE PARÂMETROS
A seguir são mostrados exemplos de protótipos de método
que utilizam as várias formas de passagem de parâmetros

PASSAGEM POR VALOR – Outra cópia é feita; Menos

eficiente

void ClassName::metodo(int);

PASSAGEM POR REFERÊNCIA – O próprio objeto é passado;

alteração dentro do método é refletida fora do mesmo;
Mais eficiente

void ClassName::metod(int&);

PASSAGEM POR REFERÊNCIA CONSTANTE - O próprio

objeto é passado; alteração dentro do método não é
refletida fora do mesmo; Mais eficiente

void ClassName::metod(const int&);

PASSAGEM POR PONTEIRO – O endereço do objeto é

passado; alterações afetam o objeto original

void ClassName::metod(int*);
48
PASSAGEM DE PARÂMETROS - EXEMPLO

Definição dos métodos na classe

void ClassName::metodoV(int i){
i = 10;
}
void ClassName::metodoR(int& i){
i = 20;
}
void ClassName::metodoRC(const int& i){
//i = 30; compilador não aceita modificação!
}
void ClassName::metodoP(int* i){
*i = 40;
}
PASSAGEM DE PARÂMETROS - EXEMPLO

int i(0);
int &iRef = i;
const int &iConstRef = i;
int* pI = &i;
ClassName p;
p.metodoV(i);
cout << "i: " << i << endl; //imprime 0
//Passagem por referência
p.metodoR(iRef);
cout << "i: " << iRef << endl; //imprime 20
//Passagem por referência constante
p.metodoRC(iConstRef );
cout << "i: " << iConstRef << endl; //imprime 20
//Passagem por ponteiro
p.metodoP(pI);
cout << "pI: “ << pI <<endl; //imprime o endereço de i
cout << "*pI: " << *pI << endl; //imprime 40
49
CLASSE STRING

A biblioteca padrão do C+ + oferece uma classe muito útil

para a manipulação de sequências de caracteres (strings)

O nome da classe é string. Para utiliza-la é necessário o

seguinte include: #include <string>

O primeiro caracter da string está na posição 0 e o último

na posição .length()-1

CONSTRUTORES PRINCIPAIS
string s1; //Cria uma string vazia
string s2("C++ Orientado a Objetos");
string s3 = "C++";
string s4(s2);
//string com 10 posições iguais ao a 'c'
string s5(10,'c');
string s6("Espaço para 32 caracteres",32);
CLASSE STRING

MÉTODOS PRINCIPAIS
size_type size() const – Retorna o tamanho da
string
bool empty() const – Retorna true, caso a string esteja
vazia.
string substr(size_type pos, size_type n)
const – Retorna uma string com n caracteres, iniciando na
posição pos.
size_type find(const string& str, size_type
pos) const – Retorna a posição de inicio, caso a string str
esteja inserida no objeto.
size_type copy(string *s, size_type n,
size_type pos) const- Copia até n elementos da string
s, iniciando na posicao pos do objeto.
50
CLASSE STRING

MÉTODOS PRINCIPAIS
string& insert(size_type pos, const string
*s)- Insere a partir da posição pos a string s

O operador + pode ser utilizado para concatenar dois objetos

da classe string.
string s1("C++ "), s2("Orientado a Objetos");
s1 = s1 + s2;
//s1 contém "C++ Orientado a Objetos"

O operador = (atribuição) pode ser utilizado com os objetos

da classe string
string s1("C++ "), s2;
s2 = s1 // contém "C++ "
CLASSE STRING - EXEMPLOS

string s1;
string s2("C++ Orientado a Objetos");
string s3 = "ESTUDO";
string s4(s2);
string s6("Espaço para 32 caracteres",32);
//imprime: Tamanho - string s6: 32
cout << "Tamanho - s6: " << s6.size() << endl;
Tamanho - string s2: 23
cout << "Tamanho - s2: " << s2.size() << endl;
//imprime: String s1 e vazia
if (s1.empty())
cout << "String s1 e vazia\n";
else
cout << "String s1 não é vazia\n";
51
CLASSE STRING - EXEMPLOS
//continua ...
//imprime: substr de s2: Orientado
cout << "substr de s2: " << s2.substr(4,9) <<
endl;
//insere no final de s3 uma string em branco
s3.insert(s3.length()," ");
//insere no final de s3 a string s2
s3.insert(s3.length(),s2);
//imprime:
//s3 apos insert: ESTUDO C++ Orientado a Objetos
cout << "s3 apos insert: " << s3 << endl;
ENTRADA E SAÍDA(I/ O)

A linguagem C+ + possui uma biblioteca padrão que foi criada

seguindo os princípos da programação orientada a objetos.
Desta forma vários objetos já estão prontos para serem
utilizados e incorporados.

A biblioteca para entrada e saída (I/ O) possui uma série de

classes que permitem adicionar uma série de funcionalidades
aos programas escritos em C+ +

A biblioteca de entrada e saída(I/ O) utilizada pelo C+ +

simplifica a sintaxe em relação ao C tradicional.

Para entrada e saída e utilizado o conceito de uma STREAM

de bytes.

Para utilizar a biblioteca de I/ O deve ser utilizado o seguinte

include: #include <iostream>
52

O conceito de Stream pode ser entendido como um fluxo de

informação que pode entrar ou sair de um programa para uma
fonte de informação que pode ser um arquivo, a memória, o
teclado ou o vídeo

Desta forma a escrita para qualquer um destes meios utiliza-se

basicamente a mesmas classes, falicitando seu uso.

BUFFER – O buffer consiste em uma área de memória onde

as informações são lidas ou escritas. O acesso ao buffer
ocorre na velocida da RAM enquanto os dispositivos de
entrada e saída (teclado; disco; etc.) trabalham em uma
velocidade de acesso muito menor.

Quando parte de um arquivo é necessária, normalmente um

maior volume de informações e lido e transferido para o
buffer, quando uma próxima parte desta informação é
necessária o seu conteúdo já se encontra no buffer.

A utilização de um buffer reduz o número de acessos

necessários a disco, por exemplo, e desta forma este tipo de
i/ o é mais eficiente.

Em C+ + existem buffers do tipo “Unit-buffering” e “Full

buffering”. O primeiro tipo armazena a informação em linhas
o segundo tipo armazena várias linhas até que as mesmas
sejam removidos da memória (flush)
53

O diagrama de classes abaixo mostra como estão

organizadas as classes da biblioteca padrão de entrada e
saida. Normalmente, classes que começam com “i” – input;
“o” - output

Descrição do uso de algumas classes:
Classe Saída(Output) Objetos Descrição

ostream cout, cerr, clog Saída em console
ofstream Saída em arquivo em disco
ostrstream Saída bufferizada em string
Classe Entrada (Input) Objetos Descrição

istream cin Entrada em console
ifstream Entrada em arquivo em disco
istrstream Entrada bufferizada em string
54

A biblioteca possui alguns objetos globais para lidar com

entrada e saída.

cin – Lê a partir de uma entrada padrão, utilizando um

operador de extração . Normalmente a entrada padrão é o
teclado.
cin >> iValor;

cout – Escreve na saída padrão utilizando o operador

inserção. Normalmente esta saída é a tela
cout << iValor;

cerr – Escreve na saída de erros padrão (Unit-buffering)

clog – Escreve na saída de erros padrão (Full buffering)

Normalmente os objetos cerr e clog estão conectados com o

objeto cout, dessa forma todas as saídas são direcionadas
para o mesmo local.

EXTRAÇÃO DE VALORES – O operador de extração (> > )

retira dados da stream e coloca em variáveis utilizadas pelo
programa. Este operador é utilizado para ENTRADA de
dados
Exemplo: int iA, iB;
double dC;
cin >> iA >> iB >> dC;

No exemplo acima o primeiro inteiro digitado no teclado será

colocado na variável iA em seguida após um < ENTER> ,
< TAB> , < SPACE> o segundo valor informado será colocado
na variável iB e assim por diante;
55

Métodos principais (classe istream - objeto cin)

istream& get(char& ch )- Extrai um caracter simples da
stream de entrada.
istream& read( char* pch, int iCount )- Extrai um
número fíxo de caracteres indicados por iCount que estão
presentes em um array de caracteres apontado por pch.
istream& getline(char* pch, int iCount, char
delim = ’\n’)- Extrai um número fíxo de caracteres e
armazena em pch. Os caracteres serão extraídos até que
o caracter delim apareça na sequência ou então o número
iCount-1 de caracteres seja informado
long setf(long lFlags) – Ajusta a formatação da
entrada. O valor lFlags pode ser: ios::left; ios::right;
ios::dec; ios::oct; ios::hex; ios::fixed; ios::scientific; etc

INSERÇÃO DE VALORES – O operador de inserção (< < )

retira dados variáveis utilizadas pelo programa e os coloca
em uma stream. Este operador é utilizado para SAÍ DA de
dados
Exemplo: int iA(3), iB(4);
double dC(34.3);
cout << iA << iB << dC;

Para facilitar o trabalho com a saída existem alguns

manipuladores

endl Coloca um caracter ' \ n'na strem de aída em em

seguida descarrega o buffer (flush)

ends Coloca um caracter nulo ' \ 0‘ na stream de saída

flush Descarrega o buffer de saída.

56

Métodos principais (classe ostream - objeto cout)

ostream& put(char ch)- Insere um caracter simples na
stream de saída.
ostream& write(const char* pch, int iCount)-
Insere um número fíxo de caracteres indicados por iCount que
estão presentes em um array de caracteres apontado por
pch.
long setf(long lFlags) – Ajusta a formatação da saida.
O valor lFlags pode ser: ios::left; ios::right; ios::dec;
ios::oct; ios::hex; ios::fixed; ios::scientific; etc...
Para combinar estas flags deve ser utilizado o operador OU
Binário (| )

Métodos principais – Formatação de streams

Estes métodos são definidos na clase IOS

long setf(long lFlags) – Ajusta a formatação da saida.
O valor lFlags pode ser: ios::left; ios::right; ios::dec;
ios::oct; ios::hex; ios::fixed; ios::scientific; etc...
Para combinar estas flags deve ser utilizado o operador OU
Binário (| )
long unsetf( long lFlags )- Retira uma ou mais flags
de formatação. Os valores da lflags são mostrados acima.
int precision( int iPrec )- Ajusta a precisão de
número em ponto flutuante. iPrec equivale ao número de
dígitos significativos.
57
int width(int iW) – Caso o o tamanho da stream de
saída seja menor que iW, o espaço restante será completado
com o padrão de preenchimento ('' ).
char fill( char cFill )- Ajusta o caracter de
preenchimento da stream, para o valor informado em cFill.
ENTRADA E SAÍDA(I/ O) - FORMATAÇÃO

#include <iostream>
#include <string>
//cout imprime uma linha de texto na saida padrão
cout << "Entrada e Saida - Exemplos!" << endl;
int iA, iB;
double dC;
cout << "Digite os valores e em seguida tecle <TAB>: "
<< endl;
cout << "iA" << "\t" << "iB" << "\t" << "dC" << endl;
cin >> iA >> iB >> dC;
//cout << iA << iB << dC << endl;
//continua...
58
cout << "O Valor iA: " << iA << endl;
cout << "O Valor iB: " << iB << endl;
cout << "O Valor dC: " << dC << endl;
double d(34.3423444234424);
int iC(12);
string s("Teste");
//Ajusta a formatação da saída
cout.setf(ios::showpos | ios::scientific |
ios::uppercase | ios::hex);
cout << "Sinal + para nros positivos; Notacao
cientifica; Caracter Maisuculo em nros!" << endl;
cout << "iC: " << iC << endl; //iC: 12
cout << "d: " << d << endl; //d: +3.434234E+001
cout << "s: " << s << endl; //d: +3.434234E+001
//continua...

//Retira a o Maiusculo
cout.unsetf(ios::uppercase);
cout << "Sinal + para nros positivos; Notacao
cientifica!" << endl;
cout << "iC: " << iC << endl; //iC: 12
cout << "d: " << d << endl; //d: +3.434234e+001
cout << "s: " << s << endl; //s: Teste
//Ajusta a precisão - ponto flutante 7 dígitos
cout << "Ajuste de precisao" << endl;
cout.unsetf(ios::scientific);
cout.precision(7);
cout << "d: " << d << endl; //d: +34.34234
//Retira o decimal e Coloca valor em hexadecimal nos
//números inteiros
cout.unsetf(ios::dec);
cout.setf(ios::hex);
//continua...
59
cout << "Valores HexaDecimais em inteiros; sem notacao
cientifica" << endl;
cout << "iC: " << iC << endl; //iC: c
cout << "d: " << d << endl; //d: +34.34234
//ajusta o tamanho do campo em 12
cout.width(18);
//ajusta o caracter de saida para ’*’
cout.fill(’*’);
cout << "iC: " << iC << endl; //**************iC: c
cout << "d: " << d << endl; //d: +34.34234
int iRet(0);
cin >> iRet;
return iRet;
}
60

C++ Orientado A Objetos

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

C++ Orientado A Objetos

Enviado por

Direitos autorais:

Formatos disponíveis

C+ +

FLÁVIO DE OLI VEIRA SILVA

Computação baseada em fatos e regras. Ex: Prolog

Computação baseada em objetos que se

Entidades que possuem dados e instruções sobre como

Os objetos estão ligado à solução do problema.

Na POO a solução do problema consiste em um primeiro

Um ponto sempre contém dados relacionados ao mesmo que o

Um círculo poderia possuir os métodos: draw;

Um circuito elétrico poderia ter os seguintes

Objetos se comunicam entre si através de

Herança é a capacidade de uma subclasse de

Dessa forma as propriedades de uma classe

Neste caso dizemos que a subclasse herda as

A relação de herança entre duas classes é uma relação da

Exemplos: Um Carro de Passeio “é um tipo de ” veículo;

Herança Múltipla – Uma subclasse herda características

Exemplos: Um gerente de vendas “é um tipo” de

Além da relação de herança entre as classes

USO / AGREGAÇÃO (Relação de Conteúdo)

Encapsulamento é um termo que indica que os dados

Os objetos respondem às messagens que eles

RETÂNGULO TRIÂNGULO CÍRCULO

ANÁLISE ORIENTADA A OBJETOS (OOA)

Objetivo básico – Identificar classes a partir das

Envolve as seguintes tarefas

Comunicações entre objetos

NOMES são potenciais objetos

VERBOS são potenciais métodos

IDENTIFICAÇÃO DE OBJETOS – CRITÉRIOS

IDENTIFICAR OS OBJETOS / CLASSES

ESPECIFICAR OS ATRI BUTOS (DADOS) DOS OBJETOS

Quais dados são necessários para descrever o objeto?

DEFINIR OS MÉTODOS(PROCEDIMENTOS) NECESSÁRIOS

Quais as responsabilidades do objeto? Qual ações deve executar?

IDENTIFICAR A COMUNICAÇÃO ENTRE OS OBJETOS

EX.: Objeto Tela irá solicitar ao objeto Retângulo que o mesmo se

Criação do código do programa utilizando uma linguagem

Será utilizado o ambiente DevC+ + . Versão 4.9.7.0

Ambiente gráfico; Em português; Gratuito

Utiliza compiladores da família gcc

Criando um novo Projeto

Arquivo Æ Novo Æ Projeto...

Um projeto contém todas as informações necessárias para compilar e

O projeto (hello.dev) deve ser salvo de preferência em uma pasta

Criando um novo Projeto / Salvando Arquivos

Um projeto “Console Application” consiste de um

Após criar o projeto automaticamente será criada a

Além disso um arquivo main.cpp será criado. Neste

O editor de programas possui recursos interessantes como:

Cada parte do código possui uma cor específica:

Palavras reservadas da linguagem – preto / negrito

Texto (Strings) – vermelho

Para compilar os programas utilizar o menu Executar Æ

Código Preprocessador Header

Arquivos Objeto Linker Bibliotecas

Um problema muito comum é o compilador e o linker não

Em seguida deve-se clicar no tab DI RETÓRI OS.

No tab BI NÁRI OS deve existir a seguinte informação:

C:\ Dev-Cpp\ Bin

Esta é a pasta que contém os executáveis (compilador;

No tab BI BLI OTECAS deve existir a seguinte informação:

C:\ Dev-Cpp\ lib