5_6_Subprogramas_TAD_completo - Pré P2 - Schneider

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

Subprogramas
		Um programa separado a partir do programa principal, que executa uma série de operações que ocorre várias vezes durante o ciclo de execução. Subprogramas encurtam e simplificam a programação manual.
Fundamentos dos subprogramas
			Um programa de computador contido dentro de outro programa que funciona de forma semi-independentemente do programa que encerra.
Características gerais
		Um único ponto de entrada, o inicio da execução suspende a execução da unidade chamadora e o termino da execução faz a execução da unidade chamadora continuar.
Definições Básicas
		A definição de subprograma descreve a interface a as ações de abstração de subprograma. 
		Chamada a subprograma é a solicitação explicita para executar o programa. Se o subprograma está ativo significa que ele iniciou sua execução mais ainda não o finalizou. 
		Cabeçalho de subprograma é a primeira linha do subprograma que inclui nome, tipo do subprograma e parâmetros formais. O perfil de parâmetro de um subprograma é o numero, a ordem e o tipo de parâmetro formal já o protocolo é o “perfil de parâmetro” + o retorno no caso de uma função.
		Declaração de subprograma identifica um bloco como sendo um subprograma de um determinado tipo, dá um nome para ele e identifica seus parâmetros. Parâmetro formal é uma variável listada no cabeçalho do subprograma, e Parâmetro real representa um valor ou endereço utilizado no subprograma pela declaração que o chamou.
 Parâmetros
	São formas de fornecer dados para o processamento do subprograma, e os deixa mais legível que o uso de variáveis externas. Podem ser dados ou subprogramas. Pode ser feita por posição ou nome (algumas linguagens os dois).
	Parâmetros posicionais: A correspondência dos parâmetros (real para formal) é feita simplesmente pela posição. 
Parâmetros nomeados: O nome do parâmetro real especifica em qual parâmetro formal vai ser vinculado. A vantagem é que dá maior flexibilidade ao código que chama a sub-rotina (subprograma, função ou procedimento) permitindo a alteração na ordem dos argumentos passados ou na omissão de algum argumento, ou seja, a ordem é irrelevante, entretanto o usuário precisa saber os nomes dos parâmetros formais.
Procedimentos e funções
	Procedimentos: Produzem resultados alterando variáveis externas (efeitos colaterais) já que não retornam valores. As variáveis não são necessariamente visíveis no programa.
	Funções: Podem apresentar efeitos colaterais, podem fazer tudo que um procedimento faz e ainda retornar valor. 
 Ambientes de referência locais
	Variáveis definidas dentro de subprogramas são chamadas de variáveis locais, geralmente são variáveis stack-dinâmicas, pois suportam recursão e o armazenamento pode ser compartilhado com outros subprogramas, entretanto o tempo de alocação e desalocação são maiores, o endereçamento é indireto.
Métodos de passagem de parâmetros
	Parâmetros é uma boa forma de transmitir dados para dentro e para fora de um subprograma. Existem três modelos de transmissão de parâmetros: os de entrada (receber dados dos parâmetros reais), saída (transmitir dados para os parâmetros reais) e entrada/saída (ambos).
Passagem por valor
	O valor do parâmetro real é usado para inicializar o parâmetro formal, que então agem como uma variável local. (in mode).
Vantagens: É um método seguro, pode ser proferida caso o programador deseje passar poucos dados de modo de entrada.
Desvantagens: Requer mais armazenamento e tempo extra pra cópia, custo para transferir o parâmetro fisicamente.
 Passagem por resultado
	O parâmetro funciona como uma variável local, cujo valor é copiado para o parâmetro real ao final do subprograma. O parâmetro real deve ser apropriado para recebimento dos valores, ou seja, associado a um left value. (out mode).
Vantagens: Ajuda na redução do método de retorno de função, no sentido que ele não aparece junto dos outros parâmetros.
Desvantagens: Pode haver colisão de parâmetros reais, a ordem dos parâmetros reais determina o valor dos parâmetros formais.
Passagem por valor-resultado
 	É a cópia do valor para um armazenamento separado durante a chamada e durante o encerramento do subprograma (inout mode).
		Desvantagens: Junção das desvantagens das passagens por valor e por resultado.
Passagem por referência
	Também conhecido como passagem por compartilhamento, nesse modelo não ocorre à transmissão de valores entre os parâmetros. A unidade chamadora transmite aos subprogramas um caminho de acesso (geralmente o endereço). (in out mode)
		Vantagem: Passagem de parâmetros é eficiente (não existe cópia, nem espaços duplicados), é rápida, pois uma referência é uma quantidade pequena de informação e tem sempre o mesmo tamanho.
		Desvantagem: Acesso lento, o subprograma passa a ter acesso a variáveis não locais (podendo gerar efeito colaterais indesejados)
Passagem por nome
	Esse tipo de passagem faz com que o parâmetro real, com efeito, seja substituído para o parâmetro formal correspondente em todas as ocorrências no subprograma. São vinculados a valores ou endereços no momento da chamada. 
Resultados semânticos:
	Se o parâmetro real for escalar, será passado por referencia.
	Se o parâmetro real for constante, será passado por valor.
	Se for um elemento de um array, será passado diferente de todos.
		Vantagem: Flexibilidade
		Desvantagem: Referencia ineficiente, são difíceis de implementar e sua legibilidade é péssima.
Parâmetros que são nomes de subprogramas
	É feita a passagem de argumentos, os parâmetros são checados quanto ao tipo, o que permite maior reaproveitamento do código e ajuda a manter vários subprogramas pequenos.
	Ambiente de referenciamento de uma instrução é o conjunto de nomes válidos nela.
	Existem três tipos de ambientes em que para se executar o subprograma passado.
	Ambiente de definição do subprograma passado, aquele em que o subprograma foi declarado (vinculação profunda).
	Ambiente de instrução de chamada é aquele em que o subprograma foi ativado (ordem de execução define a vinculação), ele é perigoso (vinculação rasa).
	Ambiente de instrução de chamada é aquele em que o subprograma foi usado como parâmetro (vinculação ad hoc).
Subprogramas sobrecarregados
	Um subprograma sobrecarregado é aquele quem tem o mesmo nome que outro subprograma no mesmo ambiente de referenciamento mas que possuem protocolo único. A sobrecarga é considerada um tipo de polimorfismo (polimorfismo ad hoc). Se uso pode levar à implementação de subprogramas exatamente iguais em termos de instruções, mas que diferem em termos de tipos.
 Subprogramas genéricos
	Um subprograma genérico ou polimórfico é um subprograma que leva parâmetros de diferentes tipos em várias ativações. Subprogramas genéricos são, portanto, subprogramas em que a declaração de um ou mais tipos de parâmetros foi parametrizada.
	Polimorfismo paramétrico é apresentado por um subprograma que leva um parâmetro genérico usado em uma expressão de tipos que descreve os tipos dos parâmetros do subprograma.
Compilação Separada e Independente
	Unidades de comparação são divididas em das partes: Compilação separada e compilação independente.
	Compilação separada: é a compilação de algumas unidades do programa realizadas separadamente do resto do programa utilizando a informação do cabeçalho para verificar a validade entre as duas partes.
	Compilação independente: é a compilação de algumas unidades do programa realizadas separadamente sem o beneficio da informação do cabeçalho, tornando assim inviável a verificação de tipos em tempo de compilação.
Co-rotinas
	Elas prestam uma relação de igual para igual entre a unidade chamadora e a chamada. São ligadas ainda por uma unidade mestra que cria uma série de co-rotinas que “se conhecem” e as inicializa.É um subprograma que possui múltiplas entradas e ele mesmo as controla mantendo uma memória de suas ativações anteriores.
	A invocação de uma co-rotina é chamada de retomada, eles também são conhecidos como controle simétricos. Sua execução é intercalada,
mas não sobreposta. Apenas uma co-rotina é executada por vez. A distribuição é feita a partir do desejo do programador. As co-rotinas são muito dependentes das outras, e isso não é uma boa coisa, então hoje em dia é usada as threads(alguém de fora determina quem executa quem).
Tipos Abstratos de Dados
	Um tipo abstrato de dados é um encapsulamento que inclui a representação de dados de um único tipo mais os subprogramas que fornecem as operações para este tipo.
	Uma instancia de um TAD é um objeto, e a ocultação de dados[1] é necessária para ser considerada uma TAD.
	Um encapsulamento é um agrupamento de subprogramas e os dados que eles manipulam.
	[1] Ocultação de dados é uma forma de controle de acesso que limita o uso que se pode fazer de um identificador, a ocultação de dados não tem como objetivo esconder dados (no sentido de impedir que o cliente saiba da sua existência) , o que ele faz é proporcionar a proteção (impedir de usa-los) mantendo independência entre os módulos de um programa. OD ajuda a manter a consistência de um TAD, ou seja, como o estado de um TAD só pode ser alterado pelas operações definidas no encapsulamento.
Suporte nas linguagens
	São à base da orientação ao objeto, são suportadas por todas as linguagens que os utiliza.
Em C++:
	É baseado no tipo struct do C e nas classes do SIMULA67, a estrutura que proporciona encapsula mento é a classe. As classes são tipos de dados, a informação oculta funciona a partir de clausulas private (entidades ocultas), public(entidades de interface) e protected( herança).
	Construtores são funções para inicializar os membros de dados das instancias (não criam objetos), eles podem fazer alocação de armazenamento se parte do objeto é dinâmico no heap. São implicitamente chamados quando a instancia é criada, e podem ser chamados explicitamente. O nome é o mesmo do nome da classe.
	Destrutores são funções para a limpeza após uma instancia ser destruída, usualmente apenas retomada de espaço de armazenamento heap. Implicitamente chamados quando o tempo de vida do objeto acaba, também pode ser chamados explicitamente. Nome é o mesmo do nome da classe mas tem o ~ na frente.
Atribuir e verificar, construir e destruir são operações com qualquer tipos de dados.
	2.3. Tipos abstratos de dados parametrizados
	Eles permitem generalizar tipos de dados, descrevendo tipos como “lista de qualquer coisa”. Assim como nos subprogramas eles usam o código como modelo para a construção de vários pacotes o classes conforme os casos são instanciados.