Revisão de prova - Pré P2 - Schneider
5 pág.

Revisão de prova - Pré P2 - Schneider


DisciplinaProgramação I21.537 materiais245.137 seguidores
Pré-visualização1 página
João Vitor Squillace Teixeira
============== REVISÃO para a PROVA =============
Passagem parâmetro por nome:
void sub (int a){.
b=a; //b recebe o valor do vet[a]
i=3;
c=a; //c vai receber um valor diferente do que b, no caso ele recebe vet[3]
.}
sub(vet[i]);	
Passagem parâmetro por resultado:
void sub(out int a){ //nao copio x para cá
	 a=3;
}
sub(x);
printf(\u201cx é: &d \u201d,x);
//x no caso será impresso 3 pois foi o retorno,o valor está voltando.
//em toda linguagem tem passagem por resultado, mas dificilmente aparece.
São efeitos indesejáveis:
- Colisão de parâmetros +importante
- Parâmetro tem que estar associado com o left \u2013 importante
Procedure P(procedure Q(a:real),b:real)
Begin
Q(2*b)
End;
Procedure R(x:real)
Begin
\u2026.
End;
P(R,n);
Exemplo de vinculação de parâmetros por nome (palavra chave)
void AbrirJanela(string titulo,posição p,tamanho t){
}
...
AbrirJanela (p=x,t=(640,480),titulo=\u201dAlo Mundo\u201d);
TAD: coisas obrigatórias
Ocultação de dados (public, private) //alguma outra coisa elemento sintático com legenda.
Encapsulamento (precisa ter um elemento sintático, alguma coisa juntando os dados e as instruções subprogramas)
+++++++++++++++++++++++ Java ++++++++++++++++++++++++++++
Class Casa{ //teoricamente indica o encapsulamento mas tem que ter subprograma
	Public string endereço;
	Public string proprietário;
} //NÃO TEM ENCAPSULAMENTO POR QUE SÓ TEM DADOS E NÃO TEM SUBPROGRAMAS!!!
+++++++++++++++++++++++ Java ++++++++++++++++++++++++++++
Class Casa{ //teoricamente indica o encapsulamento mas tem que ter subprograma
	Public string endereço;
	Public string proprietário;
	Public float Calcular IPTU();
} //tem um encapsulamento mas não tem nada escondido. Mas só esconde aquilo que tem problema de consistência, se você falar que não é tipo de dados por que não tem ocultação de dados pois está tudo publico está certo!
Subprogramas Sobrecarregados
void calcula (int a,int b){
}
void calcula (char a,char b){
}
void calcula (flat a,float b){
}
main(){
int a =10;b=5;
calcula (a,b);
}
A linguagem possui compatibilidade de tipos
A linguagem possui conversões automáticas
//em C++ isso é um erro (não é subprograma sobrecarregado!!!!) pois tem compatibilidade e conversão automática, ele pode se confundir com o calcula (int a,intb) e calcula(float a,float b);
void calcula (int a,int b){
}
int calcula (funcionario a,funcionario b){
}
main(){
int a =10;b=5;
calcula (a,b);
}//esse é um exemplo de subprograma sobrecarregado! 
Declarar de alguma forma uma função que não especifica o tipo no polimorfismo paramétrico. Toda hora que se referir ao tipo, será aquele tipo. 
Polimorfismo paramétrico só existe na vinculação estática (linguagens).
int calcula (tipo f){
tipo x;
return x;
} //só consegue ver isso na hora que o código é gerado pelo compilador, vimos em Ada, em C++ (ele vê que está usando e cria o código automaticamente) e vimos também em haskel ( ele define o tipo em... )
Polimorfismo Parametrico em Haskell
Em C++
Template <class Tipo>
Tipo soma(Tipo a,Tipo b){
	return a+b;
}
soma (1.0,2.3);
// Em c++ isso seria um problema, ele ficaria confuso pois se você der um char ele não saberia somar, ele no caso concatenaria.
Em Haskell
soma:: Num t => t \u2192 t \u2192 t
soma a b=a+b;
//Não existem problemas de poliformismo paramétrico em haskel. No caso o num já indica que o valor seria em numérico.
Compilação separada e compilação independente
Na compilação separada o programa não é um arquivo, ele é um monte de subprogramas separados e compilados em tempos diferentes. A compilação é feita dos programas é feita por partes e não tudo de uma vez. Na compilação separada precisa ter as informações das outras partes, 
Linguagem com compilação independente abre mão das verificações de tipos.
_
Namespaces são agrupamentos lógicos de elementos, sejam eles classes ou mesmo outros namespaces, dentre outras tem como funcionalidade evitar conflito de nomes.
Dois bons motivos para se utilizar da manipulações de exceções: Propagação de erros automático (ele busca o tratamento de erros nas funções anteriores, e depois de percorrê-las todas novamente se ainda e se não achar o tratamento ai sim ele indica erro, se não ele o trata).
Facilidade no tratamento (legibilidade) pois a estrutura limpa fica em uma parte separada das com erro.