eclp_ap02

Prévia do material em texto

Linguagens de Programação Imperativas
As linguagens de programação imperativa são abstrações da arquitetura do computador de Von Neumann subjacente.
Principais componentes: 
Memória: armazena tanto instruções como dados.
Processador: fornece operações para modificar o conteúdo da memória.
Variáveis: abstrações para as células de memória da máquina.
Atributos de uma variável 
 Nome: identificadores.
Endereço: da memória à qual ela está associada (valor-l).
Valor: é o conteúdo das células de memória associadas à variável ( valor-r ).
Tipo: determina a faixa de valores que ela pode ter e o conjunto de operações definidas para os valores desse tipo.
Tempo de vida: é o tempo durante o qual a variável é vinculada a uma localização de memória específica.
Escopo: é a faixa de instruções na qual a variável é visível.
Nomes
Um nome é uma cadeia de caracteres usada para identificar alguma entidade de um programa.
Questões de projeto a serem definidas:
Qual é o tamanho máximo de um nome?
Caracteres de conexão podem ser usados em nomes?
Os nomes fazem distinção entre maiúsculas e minúsculas?
As palavras especiais são palavras reservadas ou palavras-chave?
Nomes
Palavras especiais: são usadas para tornar os programas mais legíveis ao dar nome a ações que devem ser executadas. Também são usadas para dar nome as entidades sintáticas dos programas.
Palavras reservadas: é especial e não pode ser usada como um nome.
Palavra-chave: é especial somente em certos contextos.
Nomes predefinidos
Apelidos
Quando mais de um nome de variável pode ser usado para acessar uma única localização de memória, os nomes são chamados de apelidos.
A criação de apelidos é um problema para a legibilidade, porque permite que uma variável tenha seu valor modificado por uma atribuição a uma variável diferente.
Recurso utilizado inicialmente para minimizar espaço de armazenamento.
Vinculação
Uma vinculação é uma associação, como por exemplo, entre um atributo e uma entidade ou entre uma operação e um símbolo.
O momento em que uma vinculação se desenvolve é chamado de tempo de vinculação. 
As vinculações podem acontecer no tempo de projeto da linguagem, no tempo de implementação da linguagem, no tempo de compilação, no tempo de ligação (link), no tempo de carregamento ou no tempo de execução. 
Vinculação Estática e Dinâmica 
Uma vinculação é estática se ocorre antes do tempo de execução e permanece inalterada ao longo da execução do programa.
Uma vinculação será chamada dinâmica se ela ocorre durante a execução ou puder ser modificada no decorrer da execução de um programa.
Exemplo de vinculação
Dado o seguinte trecho de programa em C:
		int cont;
		...
		cont = cont + 5; 
 
Conjunto dos tipos possíveis para cont: vinculado no tempo de projeto da linguagem.
 
Tipo de cont: vinculado no tempo de compilação.
 
Conjunto dos valores possíveis de cont: vinculado no tempo de projeto do compilador.
Exemplo de vinculação (cont.)
Valor de cont: vinculado no tempo de execução com esta instrução.
Conjunto dos significados possíveis para o símbolo do operador +: vinculado no tempo de definição da linguagem.
Significado do símbolo do operador + nessa instrução: vinculado no tempo de compilação.
Representação interna do literal 5: vinculada no tempo de projeto do compilador.
Declaração de variáveis
Uma declaração explícita é uma instrução em um programa que lista nomes de variáveis e especifica que elas são de um tipo particular. 
 
Uma declaração implícita é um meio de associar as variáveis a tipos por convenções padrão em vez de por instruções de declaração. 
 
 	int *p;
 		p = malloc(50*sizeof(int));
 
Declarações e Definições
Em algumas linguagens, às vezes, deve-se distinguir entre declarações e definições:
 
As declarações especificam tipos e outros atributos, mas não causam alocação de armazenamento. 
As definições especificam atributos e causam alocação de armazenamento.
Vinculações de armazenamento
 
Alocação: toma de uma célula de memória à qual é vinculada uma variável.
Deslocação: é o processo de devolver uma célula de memória desvinculada de uma variável ao conjunto de memória disponível.
Tempo de vida de uma variável
Tempo de vida de uma variável: é o tempo durante o qual esta é vinculada a uma localização de memória específica.
 
Inicia-se quando ela é vinculada a uma célula especifica e encerra-se quando ela é desvinculada dessa célula.
Variáveis Estáticas
São aquelas vinculadas a células da memória antes que a execução do programa inicie e que assim permanecem até que a execução do programa encerre.
Vantagens: eficiência, endereçamento direto.
Desvantagens: uma linguagem só com variáveis estaticamente não suporta subprogramas recursivos. O armazenamento não pode ser compartilhado.
C, C++ e Java permitem que os programadores incluam o especificador static em uma definição de variável local. Pascal não têm variáveis estáticas.
Variáveis dinâmicas na pilha
A vinculação de armazenamento destas variáveis cria-se a partir da elaboração de sua instruções de declaração, mas cujo tipo é estaticamente vinculado.
A elaboração dessas declarações refere-se ao processo de alocação e de vinculação de armazenamento indicado pela declaração, o qual se desenvolve quando a execução atinge o código em que ela se encontra.
Variáveis dinâmicas na pilha (cont.)
 Estas variáveis são alocadas na pilha mantida pelo sistema em tempo de execução.
Em Pascal todas as variáveis definidas em subprogramas que não sejam dinâmicas na heap serão dinâmicas na pilha.
Em C, Java e C++ as variáveis locais são assumidas como dinâmicas na pilha.
Variáveis dinâmicas na heap explícitas
As variáveis dinâmicas na heap explícitas são células de memória sem nome (abstratas) alocadas e desalocadas por instruções explícitas em tempo de execução, especificadas pelo programador.
 Estas variáveis só podem ser referenciadas por médio de variáveis de ponteiro ou de referência.
Variáveis dinâmicas na heap explícitas (cont.)
Em C++, estas variáveis são criadas por meio do operador de alocação new que usa um nome de tipo como seu operando.
 Em C é criada por meio de uma chamada a um subprograma de sistema.
Alem de um subprograma ou de um operador para criar este tipo de variáveis, algumas linguagens incluem um meio para destruí-las.
Em Java, os objetos são dinâmicos na heap explícitos e acessados por meio de variáveis de referência. Java não tem coleta de lixo implícita.
Exemplo de variáveis dinâmicas na heap explícitas
Exemplo em C++:
	 int *intnode; ...
	 intnode = new int; /* aloca uma célula int */...
 	 delete intnode; /* desaloca célula */
			
 Exemplo em C:  
	 int *intnode; ...
	 intnode = (int) malloc(1*sizeof(int));…
	 free(intnode);
Variáveis dinâmicas na heap implícitas
As variáveis dinâmicas na heap implícitas são vinculadas ao armazenamento na heap somente quando lhe são atribuídos valores.
Estas variáveis permitem que se escreva um código altamente genérico.
Desvantagens: custo de manter todos os atributos dinâmicos e perda da capacidade de detecção de erros pelo compilador. 
As cadeias de caracteres e matrizes em Perl e JavaScript são deste tipo.
Vinculação dinâmica de tipos
O tipo não é especificado por uma instrução de declaração. 
Uma variável é vinculada a um tipo quando lhe é atribuído um valor em uma instrução de atribuição.
Proporciona flexibilidade de programação.
A capacidade de detecção de erros do compilador é diminuída em relação ao compilador de uma linguagem que possui vinculação de tipos estática.
Uma outra desvantagem é o custo para implementar vinculação dinâmica de atributos durante a execução.
Toda variável deve ter um descritor associado a ela para manter o tipo atual.
A memória usada para o valor de uma variável deve ter um tamanho variável.
Verificação de tipos
O conceito de operando e operadores é generalizado para incluir subprogramas e instruções de atribuição.
A verificaçãode tipos é a atividade de assegurar que os operandos de um operador sejam de tipos compatíveis. 
Um tipo compatível é aquele válido para o operador ou com permissão, nas regras da linguagem, para ser convertido pelo código gerado pelo compilador para um tipo válido. 
A conversão automática chama-se de coerção. 
Um erro de tipo é a aplicação de um operador a um operando de tipo impróprio.
Verificação dinâmica de tipos: é a verificação de tipo em tempo de execução. 
Ainda que todas as variáveis sejam estaticamente vinculadas a tipos em linguagens como o C e o Pascal, nem todos os erros podem ser detectados pela verificação estática de tipos.
Tipificação forte
Numa linguagem com tipificação forte cada nome de um programa tem um único tipo associado e esse tipo é conhecido no momento da compilação (definição simplificada). 
Todos os tipos são vinculados estaticamente. 
Um tipo de variável pode ser conhecido, mas a localização do armazenamento ao qual ele está vinculado pode armazenar valores de diferentes tipos em diferentes tempos. 
Uma linguagem de programação é fortemente tipificada se os erros de tipo sempre forem detectados. 
Tipificação forte (cont.)
O Pascal falha em seu projeto de registros variantes. 
O C e o C++ não são linguagens fortemente tipificadas porque ambas permitem funções para as quais os parâmetros não são verificados quanto ao tipo. Os tipos união dessas linguagens não são verificados quanto à compatibilidade.
Escopo
O escopo de uma variável é a faixa de instruções na qual ela é visível. 
Uma variável é visível em uma instrução se puder ser referenciada nessa instrução. 
 As regras de escopo de uma linguagem determinam como uma ocorrência particular de um nome está associada à variável.
As regras de escopo determinam como as referências a variáveis declaradas fora do subprograma ou do bloco que estão atualmente em execução são associadas a suas declarações.
Variáveis locais e não locais
Uma variável é local a uma unidade ou a um bloco de programa se for declarada aí. 
As variáveis não locais de uma unidade ou de um bloco de programa são as visíveis dentro daquela ou deste, mas não são declaradas aí.
Escopo estático (I)
Em linguagens com escopo estático, o escopo de uma variável pode ser determinado antes da execução. 
A maior parte dos escopos estáticos nas linguagens imperativas está associada a definições de unidade de programa (será assumido, por enquanto, que todos os escopos assim estão). 
Em muitas linguagens, os subprogramas criam seus próprios escopos. Em Pascal e JavaScript os subprogramas podem ser aninhados dentro de outros subprogramas criando uma hierarquia de escopos. 
Os atributos de uma variável são determinados localizando-se a instrução na qual ela é declarada.
Pai-estático – Ancestrais estáticos – Variáveis ocultas.
Escopo estático: exemplo
 	procedure big;
 	var x : integer;
 	procedure sub1;
	begin{ sub1 }
	 	... 
	end; { sub1 }
 procedure sub2;
	 	var x: integer;
	 begin { sub2 }
 	 ...
	 end; { sub2 }
 	begin { big }
		...
 	end; { big }
	 
Escopo estático (II)
C e C++ tem variáveis globais.
Variáveis locais podem ocultar as globais, como no Pascal.
 Em C++, as variáveis globais ocultas podem ser acessadas usando-se o operador de escopo (::)
Blocos
Muitas linguagens permitem que novos escopos estáticos sejam definidos no meio de código executável, permitindo que uma seção de código tenha suas próprias variáveis locais. Essa seção de código é chamada de bloco.
C, C++ e Java permitem que qualquer instrução composta (uma sequencia de instruções contornadas por chaves emparelhadas) tenha declarações definindo assim seu próprio escopo. 
Os escopos criados por blocos são tratados exatamente como aqueles criados por subprogramas.
Blocos (exemplo)
 
	if (list[i] < list[j]) {
		int temp;
		temp = list[i];
		list[i] = list[j];
		list[j] = temp; 
	}
 
Avaliação do escopo estático (I)
Dada a seguinte estrutura de um programa:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Avaliação do escopo estático (I)
O acesso a procedimentos exigido é o seguinte: main pode chamar a A e B, A pode chamar C e D, e B pode chamar A e E.
O acesso de procedimento deve restringir-se aos necessários.
Escopo dinâmico 
O escopo dinâmico baseia-se na sequencia de chamadas de subprogramas, não em suas relações espaciais como um todo. 
O escopo dinâmico pode ser determinado somente em tempo de execução.
Escopo Dinâmico (cont.)
 Uma instrução em um subprograma que contenha uma referência a uma variável não local pode se referir a diferentes variáveis durante diversas execuções do subprograma.
Os subprogramas são sempre executados no ambiente imediato do chamador.
Incapacidade de determinar estaticamente a declaração para uma variável referenciada como não local.
Dificulta a leitura dos programas.
Os acessos a variáveis não locais em linguagens com escopo dinâmico tomam mais tempo do que os acessos a não locais quando o escopo é estático. 
As variáveis definidas no chamador são implicitamente visíveis no subprograma chamado.
Ambientes de Referenciamento (I)
O ambiente de referenciamento de uma instrução é o conjunto de todos os nomes visíveis na instrução. 
O ambiente de referenciamento de uma instrução em uma linguagem de escopo estático é o conjunto das variáveis declaradas em seu escopo local mais o conjunto de todas as variáveis de seus escopos ancestrais visíveis. 
No Pascal, o ambiente de referência de uma instrução inclui as variáveis locais, todas as variáveis declaradas nos procedimentos nos quais a instrução está aninhada junto com as variáveis declaradas no programa principal, excluindo-se aquelas em escopos não locais ocultas por declarações em procedimentos mais próximos.
Exemplo 1 (I)
program exemplo;
	var a, b : integer;
		 ... 
 procedure sub1; 
	var x, y: integer;
begin { sub1 }					
		...  1
end; { sub1 }
Exemplo 1 (II)
procedure sub2;
	var x: integer;
	 ...
	procedure sub3;
 var x: integer;
	begin { sub3}
 		...  2
	 end; { sub3 }
 	begin { sub2}
 ...  3
	end; { sub2 }
begin { exemplo}
 ...  4
end. { exemplo }
Exemplo 1 (III)
Ponto 		Ambiente de referenciamento
1			x e y de sub1, a e b de exemplo
2			x de sub1, a e b de exemplo
3			x de sub2, a e b de exemplo
4			a e b de exemplo
Ambientes de Referenciamento (II)
 
Um subprograma é ativo se sua execução tiver começado, mas ainda não tiver terminado.
O ambiente de referenciamento de uma instrução em uma linguagem de escopo dinâmico é o conjunto das variáveis declaradas localmente, mais as variáveis de todos os outros subprogramas atualmente ativos.
 
Exemplo 2 (I)
void sub1 ( ) {
	int a, b;
	 ...  1 
 	 } /* end of sub1 */ 
void sub2( ) {	
	int b, c;					
...  2
	sub1( );
 } /* end of sub2 */
void main ( ) {					 
	int b, c;					
	...  3
	sub2( );
		 } /* end of main */
Exemplo 2 (II)
Ponto	Ambiente de referenciamento
	
	1		a e b de sub1, c de sub2, d de main
	
	2		b e c de sub2, d de main
	
	3		c e d de main
Constantes nomeadas
Uma constante nomeada é uma variável vinculada a um valor somente no momento em que ela é vinculada a um armazenamento. 
 Seu valor não pode ser mudado pela instrução de atribuição ou por uma instrução de entrada. 
As constantes nomeadas são úteis como auxílios para a legibilidade e para a confiabilidade do programa.
C++ e Java permitem vinculação dinâmica de valores para constantes nomeadas:
			const int max = 2 * A + 1;
 O valor de A deve ser visível quando max for alocado e vinculado ao seu valor.
Inicialização de variáveis
Inicialização: é vinculação de uma variável a um valor no momento em que ela é vinculada ao armazenamento. 
 
Em C ou C++, por exemplo, os valores iniciaisdas variáveis podem ser especificados na instrução de declaração. 
	Exemplo:	  
			int soma = 0;