Embed Size (px)
Citation preview
Resumo de Aulas
Linguagens de Programação I
Pedro Victor de Sousa Lima
Ciência da Computação
2
Sumário
TIPOS DE DADOS .................................................................................................................................................. 4
inteiros .......................................................................................................................................................................... 4
ponto flutuante ............................................................................................................................................................. 4
decimais ........................................................................................................................................................................ 5
booleanos ...................................................................................................................................................................... 5
caracteres ...................................................................................................................................................................... 6
ponteiros ....................................................................................................................................................................... 6
STRING ................................................................................................................................................................ 7
representação de strings ............................................................................................................................................... 7
strings dinâmicas .......................................................................................................................................................... 8
interpolação de strings.................................................................................................................................................. 8
casamento de padrões .................................................................................................................................................. 8
biblioteca de programação ........................................................................................................................................... 8
enumerados .................................................................................................................................................................. 8
subfaixas ....................................................................................................................................................................... 9
VETORES ............................................................................................................................................................ 10
alocação estática ou dinâmica .................................................................................................................................... 11
vetores associativos (hashes) ...................................................................................................................................... 11
árvore .......................................................................................................................................................................... 11
registro ........................................................................................................................................................................ 11
tipo lista ...................................................................................................................................................................... 12
tipo unidade ................................................................................................................................................................ 12
VINCULAÇÕES .................................................................................................................................................... 13
vinculação de nome .................................................................................................................................................... 14
aliases .......................................................................................................................................................................... 14
namespaces ................................................................................................................................................................. 14
ESCOPO ............................................................................................................................................................. 15
escopo estático............................................................................................................................................................ 15
escopo dinâmico ......................................................................................................................................................... 15
vinculação de tipos ...................................................................................................................................................... 15
inferênca de tipos ........................................................................................................................................................ 15
COERÇÃO (IMPLÍCITA) X CONVERSÃO (EXPLÍCITA) ............................................................................................... 16
compatibilidade de tipos ............................................................................................................................................. 16
VINCULAÇÃO AO ARMAZENAMENTO ................................................................................................................. 17
3
INICIALIZAÇÃO ................................................................................................................................................... 17
AVALIAÇÃO DE EXPRESSÕES ............................................................................................................................... 18
CONVERSÃO DE TIPOS ........................................................................................................................................ 19
COERÇÃO EM EXPRESSÕES ................................................................................................................................. 19
OPERADORES RELACIONAIS E EXPRESSÕES BOOLEANAS...................................................................................... 19
AVALIAÇÃO EM CURTO CIRCUITO ....................................................................................................................... 19
OPERADOR DE ATRIBUIÇÃO ............................................................................................................................... 20
atribuição simples ....................................................................................................................................................... 20
alvos múltiplos ............................................................................................................................................................ 20
alvos condicionais ....................................................................................................................................................... 20
atribuição composta ................................................................................................................................................... 20
operador unitário de atribuição .................................................................................................................................. 20
atribuição como função .............................................................................................................................................. 20
CONTROLE DE FLUXO ......................................................................................................................................... 21
instruções compostas .................................................................................................................................................. 21
instruções de seleção .................................................................................................................................................. 22
seletores alinhados ..................................................................................................................................................... 22
endentação ................................................................................................................................................................. 22
seletores múltiplos ...................................................................................................................................................... 23
INSTRUÇÕES ITERATIVAS .................................................................................................................................... 24
laço controlado por contador...................................................................................................................................... 24
laço controlado por lógica .......................................................................................................................................... 24
controle localizado pelo usuário ................................................................................................................................. 24
laço controlado por estruturas de dados .................................................................................................................... 24
DESVIO INCONDICIONAL .................................................................................................................................... 25
programação não estruturada .................................................................................................................................... 25
programação estruturada ........................................................................................................................................... 25
programação orientada a objetos .............................................................................................................................. 25
goto ............................................................................................................................................................................. 25
saídas múltiplas .......................................................................................................................................................... 25
comandos protegidos .................................................................................................................................................. 26
REVISÃO ............................................................................................................................................................ 27
DICAS ................................................................................................................................................................ 27
4
Tipos de dados
A possibilidade de declarar tipos de dados apareceu no algol68
Estruturas de dados podem ser produzidas a partir de tipos simples (ex. listas a partir de vetores).
Algol68 – formato da linguagem definida no ano de 68
Podem-se usar tipos de dados para criar novas estruturas, novos coisas.
INTEIROS
São abstrações bastante diretas da memória
Aparecem em diferentes capacidades
Com ou sem sinal
Representados geralmente na forma de complemento de 2
Podem ser “infinitos.”.
A maioria das linguagens tenta oferecer uma garantia de um número mínimo.
Inteiros dinâmicos são mais lentos, o hardware faz contas “dígitos por dígitos”, isto é, em partes.
Wrap around: acontece quando o tipo de dados escolhido não consegue suprir as necessidades dele.
PONTO FLUTUANTE
Podem possuir precisão simples, dupla ou quádrupla.
Poucos valores conhecidos são muito precisos, as operações fazem a precisão cair.
Objetivo: aproveitar o número limitado de bits para guardar a maior quantidade de dígitos significativos
possíveis (mantissa e expoente).
Ponto flutuante = float (em C)
Representar um número que não é inteiro é ter uma forma de representação de não ter dígitos de casas
decimais de formas fixas, apenas ter números decimais e depois por tais números de forma representativa.
Escrevendo a parte significativa separada da magnitude, a parte que irá classificar, diferencia o número
pequeno de um número grande.
+ 0.23 * 10²
Bits separados, um bit indica sinal, outro bit a mantissa e o outro magnitude.
5
A verificação de equivalência entre dois valores de tipo ponto flutuante é altamente imprevisível.
Exemplo:
Int inteiro = 16777217
Float real = inteiro;
If (real == inteiro)
Cout << “os valores são iguais. \n”;
Else
Cout << “valores são diferentes!\n”;
DECIMAIS
Possuem um número fixo de casas decimais (chamados também de ponto fixo, em contrapartida aos de
pontos flutuantes).
São interessantes em aplicações comerciais.
Alguns processadores tinham circuitos específicos para operações com decimais (e notação própria)
Geralmente representados por strings de dígitos. (4 bits para cada digito do número decimal, o software
faria a conta de 4 em 4 dígitos).
Hoje simulados por software (inteiros). (incomum)
BOOLEANOS
Aumentam a legibilidade (um dos tipos mais importantes, senão o mais importante. C não possui booleano
explícito...).
Geralmente não são endereçáveis.
Podem ser facilmente representados por inteiros ou descritos em termos de outros tipos.
Algumas linguagens permitem que o valor de qualquer tipo seja “testado”.
Int terminou = 1
= 0
If (terminou) >>> dessa forma, a declaração fica mais legível
6
CARACTERES
-A velha dificuldade de padronização da representação.
-Quanto espaço ocupa um caractere?
ASCII -> padronização da associação de caracteres. Ele possui 128 espaços para associações. Com 7 bits.
No Brasil costuma-se usar a padronização para sistema de codificação chamada ISSO-8859-1
Uma tabela completa com todos os símbolos utilizados pelo homem foi criada. Chamada por UNICODE. No momento
de representar um número inteiro temos muitas opções,para um numero natural também, no entanto, o processo de
tabelamento de todos os símbolos gráficos demorou muitos anos, quando começaram a aparecer os primeiros
softwares com UNICODE não haviam muitos símbolos.
Antes haviam tamanhos fixos para as representações de caracteres.
Após algum tempo surgiu um novo padrão mais sofisticado,o UNICODE.Neste, temos milhões de símbolos no
utilizando 64 bits pra cada símbolo. No entanto utilizar 64 bits para cada símbolo é muito. Solução: fazer tamanho
variável.
Vantagem: os símbolos usados por americanos utilizados com poucos bits, e símbolos mais sofisticados utilizam-se
mais bits. Alfabetos que utilizam muitos caracteres ocuparão pouco espaço, e alfabetos que utilizam poucos
caracteres ocuparão o mesmo espaço, visto que os textos serão escritos com menos símbolos.
UTF-8
PONTEIROS
Flexibilização
Representam uma posição de memória:
0 1 2 3 4 5 6 7 8
Representação de espaços na memória.
Nem tudo o que é guardado representa um espaço na memória.
Existe pelo menos uma representação que não significa espaço, é a posição “0” (não usada).
Porque o 0? Porque quase todo computador representa um lugar, convenciona um lugar, para que ele comece a
executar as instruções iniciais, um programa não tem acesso ao começo da memória.
Assim o 0 fica reservado para representar um valor especial. Dependendo da linguagem.
Em Pascal é o “nil”
Em C é o “NULL”
O ponteiro pode apontar um valor ou não.
7
STRING
São a forma de representar texto. As strings são junções de caracteres.
Seqüência de caracteres, cadeia de caracteres, possuem a característica de representar caracteres uns ao lado dos
outros.
Podem ser tipos primitivos (tipo que não pode ser acessado por partes) – independentes da forma de
representação.
Quando a string é primitiva vem acompanhada de algumas operações:
Concatenar strings: junção de strings
Encontrar uma substring – Pedro (outra string com valores ou caracteres da primeira string).
REPRESENTAÇÃO DE STRINGS
Pascal
É feita em varias posições na memória, pegando caracteres consecutivos na memória.
2 0 i a b c d e f G
Tamanho Caracteres
Forma de representação que limita o tamanho, há sempre um tamanho máximo. E pode-se sempre estar
desperdiçando memória.
Vantagem: a hora que quiser saber quantos caracteres há numa string, estará lá, na parte que cuida do
controle.
Normalmente os compiladores usavam 2 bytes no controle.
Desvantagem: não há como representar string com mais de 255 caracteres.
C
Em C também há quantidades variáveis de strings, ao contrario de pascal, não há tamanho padrão. Em C deve-se
declarar o tamanho. Porém, um espaço razoável na memória será gasto.
0 i \0 B C e f G i O
Todos os espaços são usados para guardar informações, menos 1, que será um espaço especial, um sinal para indicar
o fim da seqüência.
Vantagens: não há tamanhos máximos para as strings. Desde que haja posições suficientes.
Desvantagens: necessário contar a quantidade de caracteres.
8
ANSI Strings
2 o i /0 a e g h e n
Tamanho Controle
Padronização: ao se representar strings, reserva-se uma parte para armazenar o tamanho e outra para indicar o
controle, o fim da string.
STRINGS DINÂMICAS
Seus valores mudam ao decorrer da execução.
String x:= “alo”;
Na hora de mudar o valor, desmarca-se a região antiga, reserva-se uma nova região de memória e depois associa a
variável com a nova posição de memória. Desperdiça-se tempo porém, economiza-se memória.
INTERPOLAÇÃO DE STRINGS
Inserir números ou variáveis no meio de Strings. Concatenação.
Writeln (‘o resultado é: ‘, result);
Printf(“O resultado é: %d’, result);
Insere a String a partir de outra coisa
CASAMENTO DE PADRÕES
Expressão regular que define um formato, strings que seguem regras de formação.
Substitui uma string por uma série de operações separadas.
Um único comando verifica se a String segue tal expressão.
BIBLIOTECA DE PROGRAMAÇÃO
Conjunto de partes de programa, pedaços, desenvolvidos previamente e que agora poderá ser usado no seu
próprio programa.
ENUMERADOS
Aumentam a legibilidade
Repetição de constantes simbólicas.
Parece com uma string, ou com um identificador, porém não é associado a tais coisas. É usado pelo compilador, de
modo que uma tabela será construída automaticamente e usada pelo programa. Temos legibilidade sem
complicação.
reais 0
copos 1
Utilizar 1 nome para
representar coisas distintas.
Rosa, cor, e rosa, flor.
9
SUBFAIXAS
Aumentam a legibilidade (tornam os limites explícitos)
Podem ajudar na detecção de erros;
Conjunto limitado de outro tipo, tipo que existe uma ordem entre os elementos.
Ex: tipos numéricos: [1,2,3,4,5,6] Alguns vem antes e outros depois.
Facilidade: não é necessário ficar verificando constantemente se aqueles valores não estão em sequencia.
Em pascal há o índice de subfaixa e é indicado no início de uma declaração de vetor:
Array [1..10] of integer;
Tipo de dados: classificação dos dados nos programas. Os compiladores usam essa classificação para realizar
checagens.
Estrutura de Dados: não há como serem declaradas.
10
VETORES
Valores em posições consecutivas
É vetor:
X X x x x
Não é vetor:
X x x
São posições na memória, há coisas relacionadas antes e depois das posições.
x x x X ... ... 15
Há dificuldade para mudar o tamanho.
Deve se procurar outro lugar na memória em que caibam outros elementos que se deseja
Acesso em tempo constante.
O tempo que se demora em saber se o 1º ou qualquer outro elemento são iguais:
Dada uma posição, faz-se uma conta e assim a conta se refere à posição de memória onde se localiza o
elemento desejado, o tempo da conta é a mesma, igual, constante para todos os elementos.
Homogêneo
Os elementos devem ser do mesmo tipo. Índices organizados
Os ponteiros guardam as referencias, as “contas” para as obtenções do elementos que estão em determinada
posição. Demora um pouco mais, porém o tempo continua sendo constante para todos os elementos.
-Operador [] ou ()
Dependem da linguagem. A questão da declaração e uso dos operadores dependem da linguagem porque cada
linguagem possui um paradigma próprio.
A linguagem pode querer enfatizar coisas importantes para a mesma:
- Tipo do índice
-O valor mínimo do índice
-A validação do índice
Algumas vezes há a checagem, depende da linguagem, ou pode ser característica do compilador, ou algumas vezes o
compilador não obedece à regra.
11
ALOCAÇÃO ESTÁTICA OU DINÂMICA
Estática: pré-definida
Dinâmica: definida na hora da compilação. Primeiro guarda os valores e depois se define o tamanho do vetor.
VETORES ASSOCIATIVOS (HASHES)
Em Perl é hash, em Lua é table, em Python é lista.
São estruturas chave-valor.
Podem ser usados como vetores, listas ou registros.
Implementados por arvores ou funções hash.
Nota [“João”]
Tabela Hash
33 22 30 26
Traduzir para a forma que o hardware consiga trabalhar.
Função hash: pega-se uma quantidade indeterminada de bytes para determinar, pega-se por partes, faz-se
um conta misturando as partes de forma que saia sempre um número de tamanho fixo.
Associa qualquer quantidade de informação numa quantidade fixa.
Nota [hash(“João”)]
A conta gera um índice referente ao nome.
ÁRVORE
Estrutura de dados em que há pedaços diferentes localizados em lugares diferentes na memória.
Fácil inserir e remover elementos, porém ao acessar torna-se mais lenta.
REGISTRO
Informação heterogênea para representar muitas coisas. É um tipo de vetor associativo
Associa diferentes tipos comuns. Aglomerado de informações assim como no vetor, só que diferente deste,
acumula tipos diferentes.
Aluno
Nome
Nº de matricula
Nota
Data TipoEixo = X|Y|Z|Eixo FloatFloatFloat
Em Sublinhado = são as chamadas “Tags”
12
TIPO LISTA
É um aglomerado de valores assim como o vetor
São chamados de tipos fundamentais.
A diferença para o vetor é que a lista é espalhada pela memória, seus itens são encontrados e/ou
organizados por ponteiros.
TIPO UNIDADE
Tipo que só pode representar um valor.
Com 1 bit só se representa 2 valores, 0 ou 1.
A unidade pode ser representada com 0 bits, não se precisa de memória para guardar o tipo unidade.
Void > Tipo que não precisa de armazenamento, é tratado de maneira especial pelo compilador.
Os compiladores também definem tipos.
Há bibliotecas que já são importadas pelo compilador.
O tipo pode estar na linguagem, no compilador, na biblioteca ou em alguma parte do programa.
13
Vinculações
Nome -> (escopo)
Tipo
Armazenamento (endereço) -> “Tempo de vida”, que a variável consegue guardar o valor.
Valor
Costuma-se pensar na variável como o seu valor. A variável não é a única que está sujeita à vinculação.
Deve-se entender a variável como algo que se está vinculado com um nome, um tipo, um armazenamento
(endereço) e valor. Mas não necessariamente com todos. Tais itens podem variar ao longo do
tempo/execução.
Problema do endereço – ao se declarar uma variável, declara-se um endereço. Se o endereço é sempre o mesmo gera
uma complicação na flexibilidade.
Vinculação estática - sempre a mesma associação em toda a execução do programa.
Vinculação dinâmica – Associação da variável com mais coisas na execução do programa. Pode-se mudar
várias vinculações, o nome, o tipo, o endereço, o valor da variável.
Projeto de linguagem – coisas que acontecem no projeto. Em Pascal, BEGIN está vinculado ao projeto de linguagem.
*Implementação de linguagem, construção do compilador ou implementador da linguagem.
Tempo de implementação de programa –
Tempo de compilação – momento da tradução do código fonte em código objeto, as instruções escritas de
uma forma mais próxima do que o hardware entende.
Tempo de ligação – tempo em que o compilador (link editor) faz as vinculações. Mais especificamente, com
endereços de memória, outro exemplo, os comandos importados de bibliotecas. Algum programa ira pegar
as instruções de outros lugares e inserir no seu programa.
Tempo de carregamento - após criar o executável em linguagem de maquina, há certas coisas que faltam
serem resolvidas. A Cópia das instruções do HD para algum lugar na memória ou outro local é chamado de
tempo de carregamento.
Tempo de execução – Tempo entre uma execução e outra. A partir do comando inicial de executar.
14
VINCULAÇÃO DE NOME
Cada instrução possui um nome referente.
Há variáveis que não possuem nomes:
Print (a+b)
O a+b serão resolvidos e retornados para alguma outra variável de forma que :
Print (x) onde x é igual a a+b
Palavras reservadas – possuem sempre o mesmo significado. São vinculadas em tempo de projeto da
linguagem.
Palavras - chave – são especiais apenas em algum determinado contexto.
Ambas são coisas diferentes.
Palavras pré-definidas – algumas vezes uma palavra está ligada com uma linguagem por questões de facilidade.
Como por exemplo o “Writeln” de Pascal, que significa escrever algo na saída padrão.
ALIASES
Mais de um nome para a mesma coisa.
Ex: passagem de parâmetro por referência.
NAMESPACES
Erros de nomes comuns, acontecem geralmente com bibliotecas. O que acontece é que o compilador não consegue
distinguir uma coisa de outra.
Solução: o uso dos Namespaces.
Auxiliam a distinguir os nomes de cada coisa do programa.
Algo parecido com “nome” e “sobrenome” para uma melhor identificação/controle extra, fazendo com que se haja
muito menos conflitos na linguagem.
Desvantagem: complicações a mais e uma maior necessidade de atenção.
15
Escopo
Lugares das instruções em que o nome é válido
Declaração da variável. Um recurso é utilizado para que o mesmo nome possa ser utilizado para outras coisas, então
divide-se o programa em varias partes. Mais internas e mais externas. Está inicialmente ligado às funções, ou
subprogramas.
*Variáveis locais
*Variáveis externas (“globais”)
É importante criar “pedaços” de códigos, cada um com seus nomes, variáveis respectivas, criando uma
independência entre elas e facilitando a programação.
Efeito colateral: quando o valor de uma variável muda a partir de outro pedaço do programa em outro local. São
desvantajosos, pelo fato de que diminuiu a independência das partes do programa.
Para criar mais partes independentes do programa é necessário que se use os recursos da linguagem para se limitar
a múltipla utilização de nomes.
Diretriz do escopo mínimo: projetar os nomes das variáveis do programa para que eles sejam utilizados
especificamente em sua parte especifica.
Comparando C++ com Pascal, ao se declarar um subprograma em pascal é necessário que se tenha uma seção
específica de declaração de variáveis, e estritamente naquele local que serão visíveis em todo o trecho do
subprograma. Já em C++ não se tem uma seção especifica d declaração de variáveis, a declaração acontece em
qualquer lugar do código, mais um recurso da linguagem para reduzir o escopo.
ESCOPO ESTÁTICO
O COMPILADOR SABE QUE qualquer instrução de códigos os nomes que são validos e os que não são. Neste tipo de
escopo as regras são aplicáveis antes da execução.
ESCOPO DINÂMICO
Regras são definidas em função da execução.
VINCULAÇÃO DE TIPOS
Associação das variáveis com os tipos, normalmente é realizada antes da operação, só posso somar se souber o tipo das variáveis. Ao se restringir as variáveis em tipos pode-se restringir o que o programador irá fazer.
Pode ser explícita ou implícita.
Estática ou dinâmica
Explícita: quando se escreve a vinculação de tipos
Na dinâmica, o compilador é mais simples de ser feito. Na estática, tem-se mais eficiência, pois não se precisa gerar o código para se controlar o sistema de tipos. Sabendo o tipo o compilador pode fazer otimizações, dependendo da situação o compilador pode passar mais tempo com o código. Nas linguagens com vinculação dinâmica, é comum que se possa mudar o tipo.
INFERÊNCA DE TIPOS
Estática e implícita / Sujeito à redundância
16
Coerção (implícita) X Conversão (explícita) Quando se diz que se muda o tipo de uma variável quer se dizer que há uma variável correspondente a um espaço na
memória, escolhe-se outro lugar na memória para fazer uma nova vinculação.
B = (float) a
cria=se uma variável temporária copia-se o valor para B.
COMPATIBILIDADE DE TIPOS
Tipos que podem ser utilizados uns nos lugares do outros como se forem a “mesma coisa”
Compatibilidade por nome (dois tipos são iguais se eles possuem o mesmo nome).
Compatibilidade por estrutura (dois tipos são iguais se possuem as mesmas partes internas).
Herança.
Type Graus = real;
Radianos = real;
Function Seno (x:graus)
Os tipos acima são compatíveis
Var vet: array [1..100] of integer;
Ordena (var v: array [1..100] of integer);
Os tipos acima não são compatíveis
Frequentemente tem-se tipos que são espalhados pela memória, normalmente se faz isso com ponteiro. Uma das
partes do tipo normalmente são ponteiros que apontam para os lugares que possuem as partes do programa.
Obs.: quando se usa compatibilidade para nome, é frequente que se use comparações globais de tipo.
O compilador precisa conhecer todos os nomes para determinar as compatibilidades de tipos, se fazemos
declarações de tipos que só valem em uma parte do código podem ocorrer erros.
17
Vinculação ao Armazenamento Estática - processo simples e gera código eficiente, mas não aproveita muito bem a memória.
Inicialmente era estática, só que à medida que os programas aumentaram, necessita dividir o programa em
programas independentes, uma variável para cada subprograma, não para o programa todo. O ideal seria vincular
na hora da execução respectiva e desvincular na hora que se acaba a execução.
Stack-dinâmica – simples, é fonte de problemas comuns, é de sistema dinâmico, a vinculação muda ao
longo da execução, mas segue um controle de pilha, de forma que se empilham endereços ou espaços de
armazenamento daquelas variáveis, de tal forma que se desempilha economizando memória. É a mais
comum atualmente.
Heap-dinâmica explícita – Demorado, é um controle um pouco mais “bagunçado” , mais complicado
(lento), é muito mais demorado se alocar uma heap-dinâmica explícita do que uma Stack Dinâmica, porém
consegue-se fazer mais coisas que esta, principalmente em linguagens em que podem se abstrair mais
coisas.
Em Java utiliza-se o comando “new”.
Heap-dinâmica implícita – Não se manda fazer o controle. Como exemplo, PHP. Usada em casos em que
não tem como se prever o que será feito pelo compilador. Ou será uma situação criada automaticamente,
como variáveis temporárias para se guardar alguma coisa.
“Heap” – Monte, um pouco sem controle, coisas jogadas sem organização.
Tempo de vida de uma variável – inicia-se no momento da vinculação, até o momento em que a vinculação acaba
(desvinculação), independentemente de mudanças na vinculação.
“Garbage Collection” – os programadores frequentemente esquecem-se de declarar que não querem mais uma
variável. Então se torna necessário evitar que o programador faça isto, com um controle mais automático por
meio de algoritmos (contadores em todos os ponteiros). É menos eficiente em termos de tempo e aproveitamento
de memória, porém facilita alocando mais memória do que o necessário é o “melhor sobrar do que faltar” Java é
um exemplo de linguagem que possui Garbage Collection.
Inicialização
Quando uma variável é vinculada a um armazenamento é necessário que seja vinculada a um valor também. Auxilia
a mostrar o que funciona e o que não funciona. Não basta apenas inicializar, é necessário que se inicialize com
alguma coisa. Normalmente inicializa-se com zeros, o hardware normalmente possui circuitos para colocar zeros em
grandes quantidades de bits, tal quantidade significará uma coisa ou outra dependendo dos tipos.
Uma string em C conforme abaixo, seria uma String vazia.
0 0 0 0 0 0 0 0 0 0
Pode-se gastar tempo com 2 inicializações, tanto inicialização do programador quanto do compilador, quando o
compilador faz isso automaticamente tem-se menos eficiência. A inicialização é, realmente, o valor após a
declaração do armazenamento.
18
Avaliação de Expressões (A+B)*C
Normalmente tem-se algumas expressões ou símbolos previamente criados.
Alguns são definidos pela matemática, outros são meramente símbolos representados pelo teclado que não são tão,
“especiais”.
Normalmente tem-se parênteses, operadores, e mais alguns operadores que todos juntos forma-se algo chamado
“expressão”.
Para se calcular uma expressão, dar um significado para aquela serie de símbolos é:
1. Ordem de avaliação: como cada expressão tem uma ordem de processamento, é melhor que se faça um
único significado para tudo. Portanto haverá associatividade entre alguns operadores. Associatividade à
direita e à esquerda. Um exemplo de associatividade à esquerda seria (a+b+c). Outro exemplo de
associatividade à direita seria o comando de atribuição em C/C++.
2. Definição do compilador: as regras de execução das expressões podem ser previamente determinadas pelo
compilador ou não, dependendo da linguagem. Em Java é sempre do mesmo jeito, o que prejudica a
velocidade de execução. E C++ não se tem a garantia de que será compilado e executado sempre do mesmo
jeito, porém se terá a garantia de que a execução/compilação será mais rápida.
3. Ordem de avaliação dos operandos: f(a) + f(b) aqui, os operandos são também funções, então o compilador
terá de calcular cada um separadamente para no final calcular a expressão.
4. Sobrecarga de Operadores: quando o mesmo nome está associado/vinculado está associado com mais de
uma operação diferente, é necessário se especificar qual a operação está mais correta. Algumas linguagens
permitem que o usuário faça a modificação da especificação dos operandos, um “+” pode significar uma
operação. Quando a linguagem permite isto, quer dizer que a linguagem possui sobrecarga. Na maioria das
linguagens só se e possível utilizar nomes previamente definidos, outras são mais flexíveis como, por
exemplo, digitar muitos símbolos e associar a um nome para alguma coisa. A sobrecarga de operadores
(possibilidade de o programador definir novos usos para os identificadores) é mais comum em linguagens
mais modernas. Costuma-se dizer que a sobrecarga de operadores é um recurso bom, porque aumenta a
legibilidade. Outro problema da sobrecarga de operadores é no caso de bibliotecas, em que cada um que cria
uma biblioteca pode associar um símbolo/operador diferente, reduzindo a padronização e ocasionando
ambiguidade, a linguagem não sabe mais como distinguir o significado de um operador para o outro.
19
Conversão de Tipos No hardware costuma-se ser mais restrito com tipos. O objetivo da conversão de tipos é criar outra variável com
outro tipo, mas que irá significar a mesma coisa, outra representação com outro tipo diferente. Caracterizada em
dois tipos:
1.) Estreitamento: alguns valores não possuem nada parecido para se colocar num tipo novo.
2.) Alargamento: existe uma representação aproximada para qualquer valor, para qualquer valor representado
num tipo ‘a’ tem-se algo parecido num tipo ‘b’. É mais segura, possui uma garantia maior de que irá
acontecer.
Na necessidade de novos tipos em que o hardware não consegue trabalhar, a linguagem pode oferecer novas
opções, recursos. Há uma serie de conversões em que a linguagem faz automaticamente, outras linguagens serão
necessárias à conversão de tipos da própria linguagem.
Coerção em Expressões Acontecem implicitamente em expressões de modo misto (os operandos não estão na posição certa, no sentido de
que a operação não existe, e por isso necessita uma conversão de tipos previamente para ser efetuada).
Operadores Relacionais e Expressões Booleanas O processamento entre operando é uma relação, daí designa-se que o quando o resultado de uma operação com os
operadores gera um booleano, chama-se expressão booleana. O operador booleano nem sempre existe, mas mesmo
que não exista, deve-se haver uma referencia ao booleano, e frequentemente tem-se um número inteiro para
representar estes valores, como mais comuns ‘0’ para falso e ‘1’ para verdadeiro.
Tem-se certa dificuldade de se seguir conceitos matemáticos, porque em matemática tem-se “abreviações” dos
operadores “(a>b>c)” no caso da programação, quer-se dizer que (a>b e a>c) o que não existe. No caso da linguagem
“C” faz-se por relação de precedência primeira (a>b) e depois (b>c). Em Java não há conversão de booleano para
algum tipo numérico.
Avaliação em curto circuito Tem-se uma expressão e outros operadores, mas às vezes pode-se não precisar percorrer toda expressão para
calcular o resultado, caso consiga-se detectar a operação em questão, calcula-se. (possibilidade de que a avaliação
não seja processada por inteiro, faz se o caminho mais curto para se chegar ao resultado) O contrário seria o circuito
longo, em que se varre toda a expressão o que gasta mais tempo. É mais comum em expressões booleanas em que se
exclui uma determinada parte {(a and b) or c} o que pode gerar um efeito colateral, pelo fato de que se deixou fazer
uma parte de uma operação, o estado das coisas é diferente, resultando em algo diverso aquilo pretendido. Algumas
linguagens possibilitam “chavear” o efeito de querer ou não fazer-se uso da avaliação em curto circuito com
comandos específicos, Ada é uma linguagem que possibilita isto.
20
Operador de atribuição Fundamental para qualquer linguagem imperativa. Bastante necessário, algumas linguagens possuem um operador
bem simples, como no caso de Pascal {:=} outras linguagens possuem extras a mais em seus operadores.
Chama-se o operando da esquerda de “Left value” e o da direita de “Right value”, e são operandos com características distintas. Na direita, é Necessário que seja capaz de transformar em um valor, no caso da esquerda é necessário que ele seja capaz de transformar algo em endereço. Nem sempre é possível atribuir um endereço ao operando da esquerda.
(Left value) {Operador de atribuição da linguagem} (Right value)
ATRIBUIÇÃO SIMPLES
É a mais comum, assim como Pascal, do tipo “copie um valor de um lado para o outro”
ALVOS MÚLTIPLOS
Copia um valor para vários lugares, frequentemente as linguagens utilizam uma vírgula para separar as variáveis,
como por exemplo: {a,b=0}
ALVOS CONDICIONAIS
Atribuição em que algumas vezes se copie para um lado, e outras vezes para o outro.
ATRIBUIÇÃO COMPOSTA Inc (a,2) é a atribuição em que o valor que se pretende copiar depende um valor prévio. “incremento”, “decremento”,
pode-se associar a este tipo de atribuição a um valor que depende de outro valor prévio.
Em C existem vários operadores de atribuição tais como “+=” “-=” “*=”.
Algumas vezes a linguagem faz uma otimização própria, como no caso de “C” em que a possibilidade de se escrever
a+=2 é mais eficiente do que escrever a=a+2.
OPERADOR UNITÁRIO DE ATRIBUIÇÃO
E a atribuição em que há apenas um elemento. Unitário, como no caso de um incremento {i++} pelos mesmos
motivos da atribuição composta, é mais prático e vantajoso i++ do que i=i+1
C possui dois tipos o pré-incremento (++i) e o pós-incremento (i++) a diferença é que o pré-incremento é o operador
que faz o incremento e depois retorna o valor. O por declara o valor e depois incrementa. Para isso ele cria uma
variável temporária que assume o valor de i e tal variável posteriormente é posta no lugar da expressão.
ATRIBUIÇÃO COMO FUNÇÃO
Algumas vezes a atribuição é uma função e outras vezes, procedimento. Ou seja, algumas vezes retorna valor e outra
não retorna.
A=b=c=0;
(a?b: c=0); “questiona ‘a’ . Se ‘a’ for verdadeira, copia o valor para ‘b’. se for falsa, copia para ‘c’ ”
A atribuição como função, permite simplificar uma serie de códigos. Porém torna o programa menos legível, por
compactar uma serie de códigos e absorver mais informação, em termos de quantidade de código. Quando a
linguagem não exige que dois operando sejam de mesmo tipo chama-se atribuição de forma mista.
21
Controle de Fluxo É necessário algo que mantenha a ordem na execução de um programa imperativo.
O hardware possui um sistema de controle em que as instruções são guardadas na memória:
Instrução executando
Próxima execução “física”
Desvio incondicional: instrução que dá o endereço da próxima instrução a ser executada. (geralmente aparece como
o comando “goto”)
Desvio condicional: tem o endereço da próxima instrução, mas a próxima instrução só será ela mesma se algo ou
algum evento acontecer previamente.
No entanto, as duas instruções acima possuem um nível de abstração muito baixo, portanto as linguagens precisam
converter tal esquema acima para algo de mais alto nível.
INSTRUÇÕES COMPOSTAS
É o primeiro passo da programação, permite colocar elementos em que a linguagem esperaria um comando.
São feitas de vários comandos, por exemplo, em Pascal:
Begin
---
---
---
End
É o trecho de programa que está entre o Begin e o end.
IF (teste) comando
IF (teste) goto x
---
---
x:
Isto não é mais usado em instruções compostas, pois traz mais desvantagens.
Repeat
---
---
---
Until (teste)
22
INSTRUÇÕES DE SELEÇÃO
As instruções em Linguagens de Programação que definem qual o caminho a ser percorrido chamam-se instruções de
seleção.
Desvio: associado ao hardware
Seleção: associado à Linguagem de Programação
Unidirecional:
Garante uma única opção de caminho. Testa a condição e mediante resultado executa alguma instrução.
IF (teste) comando
Em sublinhado: expressão booleana.
Em alguns casos especiais de algumas linguagens, temos opções de utilizar números no lugar de instruções para
serem testados. FORTRAN é uma destas linguagens.
Bidirecional:
Dá duas opções de caminho. Existe em quase toda linguagem e frequentemente aparece como abaixo:
IF teste then comando
Else comando
Varias linguagens apresentam os seletores unidirecionais como se fossem bidirecionais.
SELETORES ALINHADOS
IF teste then
IF teste then comando
Else comando
(Gera uma ambiguidade).Algumas linguagens possuem regras que resolvem o problema da ambiguidade acima.
Um seletor não pode ser parte de outro seletor. Em ALGOL, por exemplo, não se pode colocar um IF dentro de outro
IF.
ENDENTAÇÃO
Em algumas linguagens os comandos compostos não são marcados por comando em especial. Devido a isto,
fazem essa classificação e separação por meio da endentação.
IF (teste) then
-------
-------
-------
Vários comandos à direita do IF. O compilador sabe que é um comando composto. E os comandos
compostos eliminam a ambiguidade. Python é um tipo de linguagem que faz isto.
Em outras linguagens, existem regras próprias para desambiguação como exemplo em C e Pascal, o “else” é do “if”
mais interno dele. O ponto-e-vírgula tem o significado de separar comandos (;).
23
Seletores Múltiplos
Oferecem múltiplos caminhos. Em C é representado pelo comando “switch”, em Pascal é representado
pelo comando “case”:
Case (expressão) of ----- ----- ----- End
É muito mais prático (abstrato) do que seletores unidirecionais. (legibilidade)
Uma desvantagem é a questão da endentação, que com muitas opções torna o programa menos legível.
Algumas linguagens fornecem a possibilidade de um novo seletor, sem a necessidade de ficar terminando muitos
comandos, é o “elseif” ou “elif” de Python, PHP. Portanto, também são classificados como seletores múltiplos.
24
Instruções Iterativas
Iterativo = repetitivo ou INDICA UMA REPETIÇÃO.
LAÇO CONTROLADO POR CONTADOR For i:=1 to n do comando
Tem-se uma variável especial que controla a repetição (“i”) e um valor final.
Na maioria das linguagens o tipo dessa variável especial é o tipo inteiro.
Outras linguagens permitem escrever intervalos entre os espaços.
LAÇO CONTROLADO POR LÓGICA
Quer repetir, no entanto fazem-se várias verificações para saber se já atingiu o ponto final ou, a cada fim de
repetição faz-se uma verificação para saber se já atingiu o ponto final. O “while” do Pascal é um tipo de laço
controlado por Lógica.
While (teste) do comando
Utiliza a lógica no começo.
Repeat ---
--- ---
Until (teste) Utiliza a lógica no fim, executa e depois utiliza. Não se sabe quantas vezes irá repetir, para isto escreve-se uma expressão booleana. São mais genéricos que laços controlados por contador.
CONTROLE LOCALIZADO PELO USUÁRIO
O controle não é fixo e nem está na sintaxe do comando. Está em outro comando que o programador põe a seu favor: Repeat --- --- --- If ~~~~~~~ then resume If ~~~~~~~ then break
LAÇO CONTROLADO POR ESTRUTURAS DE DADOS
A repetição surgiu livre e associada com o vetor. Então se tinha um índice que iria repetir com um índice controlando. Hoje em dia há estruturas de dados mais eficientes. O “for” do Java, por exemplo, tanto pode ser controlado por contador quanto por estruturas de dados: for(i: coleção)
25
DESVIO INCONDICIONAL
Instrução do hardware que indica a próxima instrução a ser executada. Em assembly chama-se “JMP”
Varias linguagens de alto nível também possuem essa instrução, em tais linguagens, normalmente chama-se “goto”. Inicialmente haviam programas mais simples, programados com recursos oferecidos pelo hardware. Com o tempo os programas foram se sofisticando a as linguagens de programação necessitaram correr atrás desse desenvolvimento. O hardware sempre soube fazer desvio incondicional, esta forma sempre apareceu nas primeiras linguagens de programação. No entanto, reflete num sistema de programação que não é muito planejado. Chamado de “Programação não estruturada”.
PROGRAMAÇÃO NÃO ESTRUTURADA
Programação Não estruturada é quando o programa não possui uma estrutura planejada, uma fase de engenharia em que se planeja o que irá ser feito.Com o tempo, a necessidade de construir programas maiores aconteceu.Da programação não estruturada evoluiu-se para a programação estruturada.
PROGRAMAÇÃO ESTRUTURADA
Há uma diretriz fundamental em que se separa o programa em partes (modularização).Pequenas coisas, ou partes, que fazem coisas simples, com todas juntas criam-se coisas maiores. Juntamente com esse tipo de programação vieram novos paradigmas.Um exemplo “clássico” de programação estruturada é o Pascal. Com o objetivo de incentivar determinadas coisas.Em certo tempo, a programação estrutura tornou-se insuficiente, daí apareceu a programação orientada a objeto.
PROGRAMAÇÃO ORIENTADA A OBJETOS
Diferentemente da estruturada, na POO tem-se varias diretrizes de como são as partes independentes, como elas se comportam separadamente. Um exemplo de linguagem é o SmallTalk.
GOTO
É uma Instrução de controle de fluxo. O GOTO é um dos elementos antigos que permanecem depois de muito tempo. Sendo muito fundamental na programação estruturada, tem-se trechos no programa tratando de trechos diferentes tratando partes diferentes, no entanto não se tem maneiras de se separar cada uma das partes. Para isto, usa-se o goto. Uma parte do programa recebe um nome, e a partir disso é possível redirecionar a execução para qualquer parte do programa. A medida que os recursos foram aumentando, o goto passou a ser considerado um problema. Uma das diretrizes da programação estruturada é não utilizar o goto. Daí começaram a aparecer linguagens que o goto não é tão eficiente quanto das linguagens anteriores. Com o desenvolvimento novas linguagens foram aparecendo e abandoando o goto gradualmente. Um exemplo de linguagem que não possui goto é o Java. Independentemente da linguagem é uma estrutura que atrapalha a instrução e a legibilidade.
SAÍDAS MÚLTIPLAS
Situação numa instrução iterativa em que se executa no inicio porem tem-se vários pontos de saída, tanto da condicional, do seletor ou outro. Dessa forma, quebra-se a diretriz da programação estruturada, tendo em vista que não está se executando cada bloquinho, cada pedaço do programa, a do seu inicio ao a seu fim. O “brake” em C é um exemplo de instrução que finaliza um bloco. Em algumas linguagens ele pode finalizar um seletor. Há outros exemplos, como o “return” o “continue”, “last”, “resume” dependendo da linguagem.
26
COMANDOS PROTEGIDOS
É outra estrutura de controle de fluxo. Abstrai vários detalhes do programador, no entanto abstraindo, não se terá mais controle do programa, então se perde o controle sobre o que o programa irá executar. series de instruções que serão executadas mediantes testes, jogando para o compilador a decisão. Selecionar pedaços do programa de uma maneira mais geral para garantir a execução ou o teste em questão. IF teste -> comando [] teste -> comando [] teste -> comando . . . Fi É Apenas um recurso a mais. A partir de vários testes, dá mais garantias de que não irá executar se não for possível executar, ou se algo já foi executado previamente.
27
Revisão
O que é uma variável externa e o que é uma variável global? Dê um exemplo em uma linguagem.
* Escolher uma linguagem:
Variável Global ou Externa: Declarada no mesmo bloco que está sendo usada.
Variável Local: Declarada num outro bloco que também está relacionado com um bloco antecedendo, mas que a variável é visível a partir do bloco precedente.
Linguagem Pascal Procedure P() Var v: integer; Begin X:=y; ( x não foi declarado e P(), logo é externa a P() )
--- --- V:=x; (v é interno a P() ) end
Dê um exemplo de implementação em que variáveis diferentes tem o mesmo nome:
DICAS Cuidado com termos mais específicos, se faz sentido para você, pode não fazer para os outros. Pode estar
fora do contexto.
Estar atento a respostas parciais.
Pôr a teoria em prática é essencial.
Nos exemplos, escrever em qual linguagem está se designando os fatores.
Cuidado com respostas ” Universais”.
