Revisão para  prova LP1 (prova2) - Pré P2 - Schneider
5 pág.

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

Disciplina:Linguagens de Programação I260 materiais733 seguidores
Pré-visualização1 página
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.