0-POO em C++

Prévia do material em texto

Programação Orientada a Objetos
Jorge Campos
jorge@unifacs.br
Conceitos Básicos em C++
Problema 1
Escreva um programa que solicite dois números inteiros e imprima o menor deles.
2
Solução Problema 1
#include <cstdlib>
#include <iostream>
using namespace std;
int main(int argc, char** argv) {
 int i,j; // variáveis para armazenar os números a serem testados
 int menor; // variável para guardar o resultado
 // leitura dos dados
 cout<<"Informe dois números"<<endl;
 cin>>i;
 cin>>j;
 // cálculos
 if (i<j) 
	menor=i;	
 else 
	menor=j;
 // impressão do resultado
 cout<<"Menor número="<<menor<<endl; 
 return 0;
}
Funções
Conjunto de comandos agrupados em um bloco de programação que recebe um nome e através deste pode ser evocado.
Sintaxe das funções
Tipo_de_retorno nome_da_função (Lista de argumentos)
Tipo_de_retorno – qualquer tipo definido na linguagem 
			void – não retorna nada
Nome_da_função – Nome válido
Lista de argumentos – Devem ser explicitadas como se tivéssemos definindo variáveis
Solução Problema 1 com Funções (1)
#include <cstdlib>
#include <iostream>
using namespace std;
int min(int a, int b) {
 if (a<b)
 return a;
 return b;
}
int main(int argc, char** argv) {
 int i,j; // variáveis para armazenar os números a serem testados
 int menor; // variável para guardar o resultado
 // leitura dos dados
 cout<<"Informe dois números"<<endl;
 cin>>i;
 cin>>j;
 // cálculos
 menor=min(i,j);	
// impressão do resultado
 cout<<"Menor número="<<menor<<endl; 
 return 0;
}
Implementação da função
Chamada da função
Solução Problema 1 com Funções (2)
#include <cstdlib>
#include <iostream>
using namespace std;
int min(int,int);
int main(int argc, char** argv) {
 int i,j; // variáveis para armazenar os números a serem testados
 int menor; // variável para guardar o resultado
 // leitura dos dados
 cout<<"Informe dois números"<<endl;
 cin>>i;
 cin>>j;
 // cálculos
 menor=min(i,j);	
// impressão do resultado
 cout<<"Menor número="<<menor<<endl; 
 return 0;
} 
int min(int a, int b) {
 if (a<b)
 return a;
 return b;
}
Declaração da função
Implementação da função
Chamada da função
Solução Problema 1 com Funções (3)
#include <cstdlib>
#include <iostream>
#include “minhasfunções.h”
using namespace std;
int main(int argc, char** argv) {
 int i,j; // variáveis para armazenar os números a serem testados
 int menor; // variável para guardar o resultado
 // leitura dos dados
 cout<<"Informe dois números"<<endl;
 cin>>i;
 cin>>j;
 // cálculos
 menor=min(i,j);	
// impressão do resultado
 cout<<"Menor número="<<menor<<endl; 
 return 0;
} 
Inclusão da função da biblioteca com as minhas funções
Chamada da função
Declaração e Implementação das funções ???
Implementação de Bibliotecas em C++
Classes, tipos estruturados e funções em C++ são geralmente definidas em dois arquivo separados.
arquivo.h
	Definição da classe/struct
	Especificação dos atributos
	Definição das funções membro (métodos)
	Definição de funções “globais” 
arquivo.cpp
	Especificação das funções (implementação das funções)
Implementação de Bibliotecas em C++
Funções em C++ são geralmente definidas em dois arquivo separados.
minhasfuncoes.h
#ifndef MINHASFUNCOES_H
#define MINHASFUNCOES_H
int min(int,int);
#endif /* MINHASFUNCOES_H */
minhasfuncoes.cpp
#include "minhasfuncoes.h"
int min(int a, int b) {
 if (a<b)
 return a;
 return b;
}
Problema 2
Escreva um programa que leia os dados de um círculo e um ponto no plano cartesiano. O seu programa deverá imprimir a área e o perímetro do círculo e dizer se o ponto informado está dento ou fora do círculo.
Y
X
(xc,yc)
(xp,yp)
raio
Solução Problema 2 (1)
#include <cstdlib>
#include <iostream>
#include <cmath>
int main(int argc, char** argv) {
 // Variáveis (representação das entidades)
 float xc,yc,raio; // o circulo
 float xp,yp; // o ponto
 float area, perímetro; // resultado do processamento
 // leitura dos dados
 cout<<"Informe as coordenadas X e Y do centro do círculo"<<endl;
 cin>>xc;
 cin>>yc;
 cout<<"Informe o raio do círculo"<<endl;
 cin>>raio;
 cout<<"Informe as coordenadas X e Y do ponto"<<endl;
 cin>>xp;
 cin>>yp;
Solução Problema 2 (1)
Cálculo da área e do perímetro
Y
X
(xc,yc)
raio
Área = π · raio2
Perímetro = 2 · π · raio
Solução Problema 2 (1)
 // cálculo da área e do perímetro
 area= M_PI * pow(raio,2);
 perimetro= 2*M_PI*raio;
 // impressão da área e do perimetro
 cout<<"Area="<<area<<endl;
 cout<<"Perimetro="<<perimetro<<endl;
Solução Problema 2 (1)
Teste de inclusão (o ponto está dentro ou fora do círculo?)
Y
X
(xc,yc)
(xp,yp)
raio
dist=?
(xc,yc)
(xp,yp)
xP-xc
yP-yc
dist=?
 
dist <= raio (o ponto está dentro)
dist > raio (o ponto está fora)
Solução Problema 2 (1)
 // teste de inclusão
 float dist;
 dist=sqrt( pow(xc-xp,2) + pow(yp-yc,2) );
 if (dist<=raio)
	cout<<“o ponto está dentro<<endl;
 else 
	cout<<“o ponto está fora<<endl;
 return 0;
}
Variáveis e a Memória 
// Variáveis de tipos básicos
int i;
float f;
char c;
bool b;
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
Variáveis e a Memória 
// Variáveis de tipos básicos
int i;
float f;
char c;
bool b;
...
i=5;
f=2.7;
c=‘J’;
b=true;
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
Variáveis e a Memória 
// Variáveis de tipos básicos
int i;
float f;
char c;
bool b;
...
i=5;
f=2.7;
c=‘J’;
b=true;
																														
													5																	
																														
																								true						
																														
																														
																														
							2.7																							
																														
																														
								J																						
																														
																														
																														
																														
Variáveis e a Memória 
// Variáveis de tipos básico
float xc,yc,raio; // o circulo
float xp,yp; // o ponto
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
cout<<"Informe ...
cin>>xc;
cin>>yc;
cout<<"Informe ...
cin>>raio;
cout<<"Informe ...
cin>>xp;
cin>>yp;
...
area= M_PI * pow(raio,2);
perimetro= 2*M_PI*raio;
Tipo de Dados Estruturados
float xp,yp; // o ponto
// uma instância de um ponto
xp=5;
yp=3;
Tipos de dados estruturados (struct) é um recurso da linguagem C/C++ para agrupar variáveis utilizadas para modelar entidades do mundo real ou conceitual que não são representas através de um único tipo básico.
Geralmente, utiliza-se struct em conjunto com o operador typedef para a criação de um novo tipo de dado nalinguagem.
typedef struct {
	float x,y;
} Ponto;
...
Ponto p; // o ponto
// uma instância de um ponto
p.x=5;
p.y=3;
Definição de um novo tipo na linguagem para modelar o 
conceito matemático de um ponto no plano cartesiano.
20
Tipo de Dados Estruturados no Problema 2
float xc,yc,raio; // o circulo
// uma instância de um círculo
xc=4;
yc=2;
raio=3;
typedef struct {
	float x,y;
} Ponto;
typedef struct {
	Ponto centro;
	float raio;
} Circulo;
..
Circulo c; // o circulo
// uma instância de um círculo
c.centro.x=4;
c.centro.y=2;
c.raio=3;
21
Funções no Problema 2
 // cálculo da área e do perímetro
 area= M_PI * pow(c.raio,2);
 perímetro= 2*M_PI*c.raio;
float area(Circulo circ) {
	float a;
	a=M_PI * pow(circ.raio,2);
	return a;
}
float perimetro (Circulo circ) {
	float p;
	p=2* M_PI * circ.raio;
	return a;
}
Funções no Problema 2
 // teste de inclusão
 float dist;
 dist=sqrt( pow(xc-xp,2) + pow(yp-yc,2) );
 if (dist<=raio)
	cout<<“o ponto está dentro<<endl;
 else 
	cout<<“o ponto está fora<<endl;
}
bool pertence(Ponto point, Circulo circle) {
	float dist;
 	dist=sqrt( pow(circle.centro.x-point.x,2) + pow(circle.centro.y-point.y,2) );
 	if (dist<=circle.raio)
		return true;
 	else 
		return false;
}
A Biblioteca Geometria
geometria.h
#ifndef GEOMETRIA_H
#define GEOMETRIA_H
typedef struct {
	float x,y;
} Ponto;
typedef struct {
	Ponto centro;
	float raio;
} Circulo;
float area(Circulo);
float perimetro(Circulo);
bool pertence(Ponto,Circulo);
#endif /* GEOMETRIA_H */
A Biblioteca Geometria
geometria.cpp
#include "geometria.h"
#include <cmath>
float area(Circulo circ) {
 float a;
 a=M_PI * pow(circ.raio,2);
 return a;
}
float perimetro (Circulo circ) {
 float p;
 p=2* M_PI * circ.raio;
 return p;
}
bool pertence(Ponto point, Circulo circle) {
 float dist;
 dist=sqrt( pow(circle.centro.x-point.x,2) + pow(circle.centro.x-point.x,2) );
 if (dist<=circle.raio)
	return true;
 else 
	return false;
}
Solução Problema 2
#include <cstdlib>
#include <iostream>
#include “geometria.h”
int main(int argc, char** argv) {
 // Variáveis (representação das entidades)
 Circulo c; // o circulo
 Ponto p; // o ponto 
// leitura dos dados
 cout<<"Informe as coordenadas X e Y do centro do círculo"<<endl;
 cin>>c.centro.x;
 cin>>c.centro.y;
 cout<<"Informe o raio do círculo"<<endl;
 cin>>c.raio;
 cout<<"Informe as coordenadas X e Y do ponto"<<endl;
 cin>>p.x;
 cin>>p.y;
Solução Problema 2 
// impressão da área e do perimetro
 cout<<"Area="<<area(c)<<endl;
 cout<<"Perimetro="<<perimetro(c)<<endl; 
 
// teste de inclusão 
 if (pertence(p,c))
	cout<<"o ponto está dentro"<<endl;
 else 
	cout<<"o ponto está fora"<<endl;
return 0;
}
Variáveis e a Memória 
// Variáveis de tipos estruturados
Ponto p;
Circulo c;
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
Variáveis e a Memória 
// Variáveis de tipos estruturados
Ponto p;
Circulo c;
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
typedef struct {
	float x,y;
} Ponto;
p.x
p.y
Variáveis e a Memória 
// Variáveis de tipos estruturados
Ponto p;
Circulo c;
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
typedef struct {
	float x,y;
} Ponto;
p.x
p.y
typedef struct {
	Ponto centro;
	float raio;
} Ponto;
c.centro
c.centro.x
c.centro.y
c.raio
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int a,int b) {
	int temp=a;
 	a=b;
 	b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(x,y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
x=1 e y=2
Passagem de Argumentos em Funções (Valor)
O QUE ACONTECEU?
Passagem de argumentos por valor
31
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int a,int b) {
	int temp=a;
 	a=b;
 	b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(x,y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
Passagem de Argumentos em Funções (Valor)
										
										
										
										
										
										
										
										
32
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int a,int b) {
	int temp=a;
 	a=b;
 	b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(x,y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
Passagem de Argumentos em Funções (Valor)
										
										
										
										
										
										
										
										
Escopo função main
33
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int a,int b) {
	int temp=a;
 	a=b;
 	b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(x,y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
Passagem de Argumentos em Funções (Valor)
										
										
										
										
				1						
					2					
										
										
Escopo função main
34
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int a,int b) {
	int temp=a;
 	a=b;
 	b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(x,y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
Passagem de Argumentos em Funções (Valor)
										
										
										
										
				1						
					2					
										
										
Escopo função main
Escopo função troca
35
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int a,int b) {
	int temp=a;
 	a=b;
 	b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(x,y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
Passagem de Argumentos em Funções
										
		1								
										
		2								
				1						
					2					
										
										
Escopo função main
Escopo função troca
36
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int a,int b) {
	int temp=a;
 	a=b;
 	b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(x,y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
Passagem de Argumentos em Funções (Valor)
										
		1								
			1							
		2								
				1						
					2					
										
										
Escopo função main
Escopo função troca
37
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int a,int b) {
	int temp=a;
 	a=b;
 	b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(x,y);cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
Passagem de Argumentos em Funções (Valor)
										
		2								
			1							
		2								
				1						
					2					
										
										
Escopo função main
Escopo função troca
38
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int a,int b) {
	int temp=a;
 	a=b;
 	b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(x,y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
Passagem de Argumentos em Funções (Valor)
										
		2								
			1							
		1								
				1						
					2					
										
										
Escopo função main
Escopo função troca
39
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int a,int b) {
	int temp=a;
 	a=b;
 	b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(x,y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
x=1 e y=2
Passagem de Argumentos em Funções (Valor)
										
										
										
										
				1						
					2					
										
										
Escopo função main
40
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int a,int b) {
	int temp=a;
 	a=b;
 	b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(x,y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
x=1 e y=2
Passagem de Argumentos em Funções (Valor)
										
										
										
										
										
										
										
										
41
Ponteiro é uma variável utilizada para armazenar um endereço de memória ou o endereço de outra variável.
int a; //uma variável do tipo inteiro
int* ptr; // um ponteiro para uma variável do tipo inteiro
a=7; 
ptr=&a; // &-operador de referência (endereço da variável a)
cout<<“O valor da variável a="<<a<<endl;
cout<<"O endereco da variavel a"=<<&a<<endl;
cout<<"O endereco da variavel a"=<<ptr<<endl;
Saída:
O valor da variável a=7
O endereco da variavel a=0xffffcc28
O endereco da variavel a=0xffffcc28
Ponteiros
int a; //uma variável do tipo inteiro
int* ptr; // um ponteiro para uma variável do tipo inteiro
a=7;
										
										
										
										
										
										
										
										
Ponteiros
int a; //uma variável do tipo inteiro
int* ptr; // um ponteiro para uma variável do tipo inteiro
a=7;
ptr=&a;
		7								
										
										
										
										
										
										
										
Ponteiros
0x...
Permite acessar o valor armazenado no endereço referenciado pelo ponteiro
int a; //uma variável do tipo inteiro
int* ptr; // um ponteiro para uma variável do tipo inteiro
a=7; 
ptr=&a;
cout<<“O valor da variável a="<<a<<endl;
cout<<"O endereco da variavel a"=<<&a<<endl;
cout<<"O endereco da variavel a"=<<ptr<<endl;
*ptr=10;
cout<<“O valor da variável a="<<a<<endl;
cout<<"O endereco da variavel a"=<<&a<<endl;
cout<<"O endereco da variavel a"=<<ptr<<endl;
int b=*ptr*a; 
cout<<“O valor da variável b="<<b<<endl;
Saída:
O valor da variável a=7
O endereco da variavel a=0xffffcc28
O endereco da variavel a=0xffffcc28
O valor da variável a=10
O endereco da variavel a=0xffffcc28
O endereco da variavel a=0xffffcc28
O valor da variável b=100;
Operador de Derreferência *
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int* a,int* b) {
	int temp=*a;
 	*a=*b;
 	*b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(&x,&y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
x=2 e y=1
Passagem de Argumentos em Funções (Referência)
Agora funcionou!!
Passagem de argumentos por referência
46
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int* a,int* b) {
	int temp=*a;
 	*a=*b;
 	*b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(&x,&y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
Passagem de Argumentos em Funções (Valor)
										
										
										
										
										
										
										
										
47
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int* a,int* b) {
	int temp=*a;
 	*a=*b;
 	*b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(&x,&y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
Passagem de Argumentos em Funções (Valor)
										
										
										
										
										
										
										
										
Escopo função main
48
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int* a,int* b) {
	int temp=*a;
 	*a=*b;
 	*b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(&x,&y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
Passagem de Argumentos em Funções (Valor)
										
										
										
										
				1						
					2					
										
										
Escopo função main
49
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int* a,int* b) {
	int temp=*a;
 	*a=*b;
 	*b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(&x,&y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
Passagem de Argumentos em Funções (Valor)
										
										
										
										
				1						
					2					
										
										
Escopo função main
Escopo função troca
50
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int* a,int* b) {
	int temp=*a;
 	*a=*b;
 	*b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(&x,&y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
Passagem de Argumentos em Funções (Valor)
										
		0x...								
										
		0x...								
				1						
					2					
										
										
Escopo função main
Escopo função troca
51
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int* a,int* b) {
	int temp=*a;
 	*a=*b;
 	*b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(&x,&y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
Passagem de Argumentos em Funções (Valor)
										
		0x...								
			1							
		0x...								
				1						
					2					
										
										
Escopo função main
Escopo função troca
52
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int* a,int* b) {
	int temp=*a;
 	*a=*b;
 	*b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(&x,&y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
Passagem de Argumentos em Funções (Valor)
										
		0x...								
			1							
		0x...								
				2						
					2					
										
										
Escopo função main
Escopo função troca
53
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int* a,int* b) {
	int temp=*a;
 	*a=*b;
 	*b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(&x,&y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
Passagem de Argumentos em Funções (Valor)
										
		0x...								
			1							
		0x...								
				2						
					1					
										
										
Escopo função main
Escopo função troca
54
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int* a,int* b) {
	int temp=*a;
 	*a=*b;
 	*b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(&x,&y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
x=2 e y=1
Passagem de Argumentosem Funções (Valor)
										
										
										
										
				2						
					1					
										
										
Escopo função main
55
#include <cstdlib>
#include <iostream>
using namespace std;
void troca(int* a,int* b) {
	int temp=*a;
 	*a=*b;
 	*b=temp;
}
int main(int argc, char** argv) {
	int x=1,y=2;
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl;
 	troca(&x,&y);
 	cout<<"x="<<x<<" e "<<"y="<<y<<endl; 
	return 0;
}
Saída:
x=1 e y=2
x=2 e y=1
Passagem de Argumentos em Funções (Valor)
										
										
										
										
										
										
										
										
56
Problema 3 
Escreva um programa que leia os dados de dois pontos no plano cartesiano. O seu programa deverá calcular e imprimir a distância entre os pontos informados.
Y
X
(x2,y2)
(x1,y1)
d=?
Classes e Objetos em C++
Classes são novos tipos na linguagem. As classes são utilizadas para representar conceitos e entidades complexas, ou seja, aquelas que necessitam de um conjunto de variáveis para definir a sua representação.
As classes possuem a seção de atributos (variáveis que definem a representação do tipo) e funções membros ou métodos (código que manipula as variáveis da classe).
As classes serão utilizadas para modelar novos tipos na linguagem (a exemplo dos recursos typedef + struct.
Podemos, por analogia, comparar uma classe com um novo tipo estruturado que possui funções que manipulam os elementos da estrutura.
Implementação da Classe em C++
Classes em C++ são geralmente definidas em dois arquivo separados.
NomeDaClasse.h
	Definição da classe
	Especificação dos atributos
	Definição das funções membro (métodos)
NomeDaClasse.cpp
	Especificação das funções membro (implementação da função)
Uma Classe para Modelar um Ponto
Arquivo Ponto.h
class Ponto {
private:
	float m_x,m_y;
public:
	Ponto();
	Ponto(float,float);
	void setX(float);
	float getX();
 	void setY(float);
	float getY();
 	float distancia(Ponto);
	~Ponto();
};
Atributos
Construtores
métodos
Destrutor
Implementação das Funções Membros (Métodos)
Arquivo Ponto.cpp
#include <cmath>
#include "Ponto.h"
Ponto::Ponto() {
 m_x=0;
 m_y=0;
}
Ponto::Ponto(float x,float y) {
 m_x=x;
 m_y=y;
}
Ponto::~Ponto() {
	// coloque o código de liberação de recursos aqui
}
Implementação das Funções Membros (Métodos)
Arquivo Ponto.cpp
(continuação)
float Ponto::GetX() const {
 return m_x;
}
void Ponto::SetX(float x) {
 m_x = x;
}
float Ponto::GetY() const {
 return m_y;
}
void Ponto::SetY(float y) {
 m_y = y;
}
float Ponto::distancia(Ponto p) {
 float dist;
 dist=sqrt(pow(m_x-p.getX(),2)+pow(m_y-p.getY(),2));
 return dist;
}
Criação de Objetos em Java
Em Java, a única maneira de criar um Objeto é através do operador new, seguido da chamada de um dos construtores da classe.
	Ponto p;		// declaração de variável do tipo Ponto
	p=new Ponto();	// criação do objeto (instanciação)
		OU
	Ponto p=new Ponto(); // declaração e instanciação
Uma vez criada a instância da classe (objeto) é possível enviar mensagem ao objeto (evocar os métodos públicos).
	p.setX(15);
	p.setY(12);
63
Criação de Objetos em C++
Em C++, existem duas formas para criação de objetos :
Sem o operador new – Instância da classe
Com o operador new – Ponteiro para a instância da classe
64
Criação de Objetos em C++ sem Operador new
Criação do objeto
// cria uma instância da classe Ponto chamando o construtor default Ponto::Ponto()
Ponto p=Ponto(); 
// cria uma instância da classe Ponto chamando o construtor com os valores de X e Y como argumento Ponto::Ponto(float,float)
Ponto p=Ponto(3,5); 
Trabalhando com o objeto
Após a instanciação do objeto, o envio de mensagem para o objeto é feito como em Java
	p.setX(15);
	p.setY(12);
65
Criação de Objetos em C++ com Operador new
Criação do objeto
// cria uma instância da classe Ponto chamando o construtor default Ponto::Ponto()
Ponto* p=new Ponto(); 
// cria uma instância da classe Ponto chamando o construtor com os valores de X e Y como argumento Ponto::Ponto(float,float)
Ponto* p=new Ponto(3,5); 
Trabalhando com o objeto
Após a instanciação do objeto, o envio de mensagem para o objeto é feito através do operador ->
	p->setX(15);
	p->setY(12);
66
Notas sobre Ponteiros e Instâncias
Na criação de objetos sem o operador new, o objeto é alocado na chamada memória automática, memória local ou stack. 
Neste caso, quando o bloco onde a variável é declarada termina, a mémoria é automaticamente devolvida ao sistema (mesmo efeito do coletor de lixo do Java).
Na criação de objetos com o operador new, o objeto é alocado na chamada memória global ou heap. 
Neste caso, quando o bloco onde a variável é declarada termina, a mémoria NÃO é automaticamente devolvida ao sistema e precisa ser liberada explicitamente (evitar o problema memory leak).
Ponto* p=new Ponto(); // alocação da memória
…
delete p;	// liberação da memória
67
Solução Problema 3 (com instâncias)
#include <cstdlib>
#include <iostream>
#include "Ponto.h"
using namespace std;
int main(int argc, char** argv) {
 // Variáveis (representação das entidades)
 Ponto p1; // um ponto
 Ponto p2; // um ponto
 float a,b; // variáveis auxiliares
Variáveis e a Memória (com instâncias) 
// Variáveis de tipos Classes
Ponto p1;
Ponto p2;
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
class Ponto {
 private:
	float x,y;
…
};
p1.x
p1.y
p2.x
p2.y
p1=Ponto();
p1.x=2;
p1.y=5;
p1.setX(2);
p1.setY(5);
Variáveis e a Memória (com instâncias) 
// Variáveis de tipos Classes
Ponto p1;
Ponto p2;
																														
														2	5															
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
																														
class Ponto {
 private:
	float x,y;
…
};
p1.x
p1.y
p2.x
p2.y
p1=Ponto();
p1.x=2;
p1.y=5;
p1.setX(2);
p1.setY(5);
Solução Problema 3 (com instâncias)
 // leitura dos dados
 cout<<"Informe as coordenadas X e Y do primeiro ponto"<<endl;
 cin>>a;
 cin>>b;
 p1=Ponto(a,b);
 cout<<"Informe as coordenadas X e Y do segundo ponto"<<endl;
 cin>>a;
 cin>>b;
 p2=Ponto(a,b);
 
 // impressão da distância entre os pontos
 cout<<"distancia="<<p1.distancia(p2);
 return 0;
}
Solução Problema 3 (com ponteiros)
#include <cstdlib>
#include <iostream>
#include "Ponto.h"
using namespace std;
int main(int argc, char** argv) {
 // Variáveis (representação das entidades)
 Ponto* p1; // um ponto
 Ponto* p2; // um ponto
 float a,b; // variáveis auxiliares
Solução Problema 3 (com ponteiros)
 // leitura dos dados
 cout<<"Informe as coordenadas X e Y do primeiro ponto"<<endl;
 cin>>a;
 cin>>b;
 p1=new Ponto(a,b);
 cout<<"Informe as coordenadas X e Y do segundo ponto"<<endl;
 cin>>a;
 cin>>b;
 p2=new Ponto(a,b);
 
 // impressão da distância entre os pontos
 cout<<"distancia="<<p1->distancia(*p2);
 // liberação da memória
 delete p1,p2;
 return 0;
}
Desafio
Reescrever o problema 2 utilizando classes. Utilize ponteiros ao invés de instâncias sempre que possível.