Revisão para prova LP1 (prova2) - Pré P2 - Schneider

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

João Vitor Squillace Teixeira 
============== REVISÃO para a PROVA ============= 
1) 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]); 
 
2) Passagem parâmetro por resultado: 
void sub(out int a){ //nao copio x para cá 
 a=3; 
} 
 
sub(x); 
 
printf(“x é: &d ”,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 – importante 
 
 
Procedure P(procedure Q(a:real),b:real) 
Begin 
Q(2*b) 
End; 
 
Procedure R(x:real) 
Begin 
…. 
End; 
 
P(R,n); 
 
João Vitor Squillace Teixeira 
 
 
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=”Alo Mundo”); 
 
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! 
João Vitor Squillace Teixeira 
 
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). 
João Vitor Squillace Teixeira 
 
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 → t → 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. 
_ 
João Vitor Squillace Teixeira 
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.