• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Resumo de aulas lp1
 

Resumo de aulas lp1

on

  • 507 views

 

Statistics

Views

Total Views
507
Views on SlideShare
507
Embed Views
0

Actions

Likes
0
Downloads
14
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Resumo de aulas lp1 Resumo de aulas lp1 Document Transcript

    • Resumo de AulasLinguagens de Programação I Pedro Victor de Sousa Lima Ciência da Computação
    • SumárioTIPOS DE DADOS .................................................................................................................................................. 4 inteiros .......................................................................................................................................................................... 4 ponto flutuante ............................................................................................................................................................. 4 decimais ........................................................................................................................................................................ 5 booleanos ...................................................................................................................................................................... 5 caracteres...................................................................................................................................................................... 6 ponteiros ....................................................................................................................................................................... 6STRING ................................................................................................................................................................ 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 ....................................................................................................................................................................... 9VETORES ............................................................................................................................................................ 10 alocação estática ou dinâmica.................................................................................................................................... 11 vetores associativos (hashes) ...................................................................................................................................... 11 árvore .......................................................................................................................................................................... 11 registro ........................................................................................................................................................................ 11 tipo lista ...................................................................................................................................................................... 12 tipo unidade ................................................................................................................................................................ 12VINCULAÇÕES .................................................................................................................................................... 13 vinculação de nome .................................................................................................................................................... 14 aliases.......................................................................................................................................................................... 14 namespaces................................................................................................................................................................. 14ESCOPO ............................................................................................................................................................. 15 escopo estático............................................................................................................................................................ 15 escopo dinâmico ......................................................................................................................................................... 15 vinculação de tipos ...................................................................................................................................................... 15 inferênca de tipos ........................................................................................................................................................ 15COERÇÃO (IMPLÍCITA) X CONVERSÃO (EXPLÍCITA) ............................................................................................... 16 compatibilidade de tipos ............................................................................................................................................. 16VINCULAÇÃO AO ARMAZENAMENTO ................................................................................................................. 17 2
    • INICIALIZAÇÃO ................................................................................................................................................... 17AVALIAÇÃO DE EXPRESSÕES ............................................................................................................................... 18CONVERSÃO DE TIPOS ........................................................................................................................................ 19COERÇÃO EM EXPRESSÕES ................................................................................................................................. 19OPERADORES RELACIONAIS E EXPRESSÕES BOOLEANAS...................................................................................... 19AVALIAÇÃO EM CURTO CIRCUITO ....................................................................................................................... 19OPERADOR 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 .............................................................................................................................................. 20CONTROLE DE FLUXO ......................................................................................................................................... 21 instruções compostas .................................................................................................................................................. 21 instruções de seleção .................................................................................................................................................. 22 seletores alinhados ..................................................................................................................................................... 22 endentação ................................................................................................................................................................. 22 seletores múltiplos ...................................................................................................................................................... 23INSTRUÇÕ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 .................................................................................................................... 24DESVIO 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.................................................................................................................................................. 26REVISÃO ............................................................................................................................................................ 27DICAS ................................................................................................................................................................ 27 3
    • 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 2Podem 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. 4
    • A verificação de equivalência entre dois valores de tipo ponto flutuante é altamente imprevisível.Exemplo:Int inteiro = 16777217Float 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 =0If (terminou) >>> dessa forma, a declaração fica mais legível 5
    • 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-1Uma tabela completa com todos os símbolos utilizados pelo homem foi criada. Chamada por UNICODE. No momentode representar um número inteiro temos muitas opções,para um numero natural também, no entanto, o processo detabelamento de todos os símbolos gráficos demorou muitos anos, quando começaram a aparecer os primeirossoftwares 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 noutilizando 64 bits pra cada símbolo. No entanto utilizar 64 bits para cada símbolo é muito. Solução: fazer tamanhovariável.Vantagem: os símbolos usados por americanos utilizados com poucos bits, e símbolos mais sofisticados utilizam-semais bits. Alfabetos que utilizam muitos caracteres ocuparão pouco espaço, e alfabetos que utilizam poucoscaracteres 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 8Representaçã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 aexecutar 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. 6
    • 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 GTamanho 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. 7
    •  ANSI Strings 2 o i /0 a e g h e nTamanho 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 Utilizar 1 nome para representar coisas distintas. copos 1 Rosa, cor, e rosa, flor. 8
    • 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 realizarchecagens.Estrutura de Dados: não há como serem declaradas. 9
    • VETORES  Valores em posições consecutivasÉ vetor:X X x x xNão é vetor:X x xSã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êneoOs elementos devem ser do mesmo tipo. Índices organizadosOs ponteiros guardam as referencias, as “contas” para as obtenções do elementos que estão em determinadaposiçã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 cadalinguagem 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 índiceAlgumas vezes há a checagem, depende da linguagem, ou pode ser característica do compilador, ou algumas vezes ocompilador não obedece à regra. 10
    • ALOCAÇÃO ESTÁTICA OU DINÂMICAEstática: pré-definidaDinâ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 Hash33 22 30 26Traduzir 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. ÁRVOREEstrutura 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. REGISTROInformaçã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.AlunoNomeNº de matriculaNotaData TipoEixo = X|Y|Z|Eixo FloatFloatFloatEm Sublinhado = são as chamadas “Tags” 11
    • TIPO LISTAÉ um aglomerado de valores assim como o vetorSã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. 12
    • Vinculações  Nome -> (escopo)  Tipo  Armazenamento (endereço) -> “Tempo de vida”, que a variável consegue guardar o valor.  ValorCostuma-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 gerauma 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. 13
    • 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. NAMESPACESErros de nomes comuns, acontecem geralmente com bibliotecas. O que acontece é que o compilador não conseguedistinguir 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 hajamuito menos conflitos na linguagem.  Desvantagem: complicações a mais e uma maior necessidade de atenção. 14
    • EscopoLugares das instruções em que o nome é válidoDeclaração da variável. Um recurso é utilizado para que o mesmo nome possa ser utilizado para outras coisas, entãodivide-se o programa em varias partes. Mais internas e mais externas. Está inicialmente ligado às funções, ousubprogramas.*Variáveis locais*Variáveis externas (“globais”)É importante criar “pedaços” de códigos, cada um com seus nomes, variáveis respectivas, criando umaindependê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ãodesvantajosos, 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 limitara múltipla utilização de nomes.Diretriz do escopo mínimo: projetar os nomes das variáveis do programa para que eles sejam utilizadosespecificamente em sua parte especifica.Comparando C++ com Pascal, ao se declarar um subprograma em pascal é necessário que se tenha uma seçãoespecífica de declaração de variáveis, e estritamente naquele local que serão visíveis em todo o trecho dosubprograma. Já em C++ não se tem uma seção especifica d declaração de variáveis, a declaração acontece emqualquer lugar do código, mais um recurso da linguagem para reduzir o escopo. ESCOPO ESTÁTICOO COMPILADOR SABE QUE qualquer instrução de códigos os nomes que são validos e os que não são. Neste tipo deescopo as regras são aplicáveis antes da execução. ESCOPO DINÂMICORegras são definidas em função da execução. VINCULAÇÃO DE TIPOSAssociação das variáveis com os tipos, normalmente é realizada antes da operação, só posso somar se souber o tipodas 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âmicaExplícita: quando se escreve a vinculação de tiposNa dinâmica, o compilador é mais simples de ser feito. Na estática, tem-se mais eficiência, pois não se precisa geraro código para se controlar o sistema de tipos. Sabendo o tipo o compilador pode fazer otimizações, dependendo dasituação o compilador pode passar mais tempo com o código. Nas linguagens com vinculação dinâmica, é comumque se possa mudar o tipo. INFERÊNCA DE TIPOS  Estática e implícita / Sujeito à redundância 15
    • 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 namemória, escolhe-se outro lugar na memória para fazer uma nova vinculação.B = (float) acria=se uma variável temporária copia-se o valor para B. COMPATIBILIDADE DE TIPOSTipos 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. 16
    • 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 emprogramas independentes, uma variável para cada subprograma, não para o programa todo. O ideal seria vincularna 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 umavariável. Então se torna necessário evitar que o programador faça isto, com um controle mais automático pormeio de algoritmos (contadores em todos os ponteiros). É menos eficiente em termos de tempo e aproveitamentode 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çãoQuando uma variável é vinculada a um armazenamento é necessário que seja vinculada a um valor também. Auxiliaa mostrar o que funciona e o que não funciona. Não basta apenas inicializar, é necessário que se inicialize comalguma coisa. Normalmente inicializa-se com zeros, o hardware normalmente possui circuitos para colocar zeros emgrandes 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 0Pode-se gastar tempo com 2 inicializações, tanto inicialização do programador quanto do compilador, quando ocompilador faz isso automaticamente tem-se menos eficiência. A inicialização é, realmente, o valor após adeclaração do armazenamento. 17
    • Avaliação de Expressões(A+B)*CNormalmente 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. 18
    • 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 novasopções, recursos. Há uma serie de conversões em que a linguagem faz automaticamente, outras linguagens serãonecessárias à conversão de tipos da própria linguagem. Coerção em ExpressõesAcontecem implicitamente em expressões de modo misto (os operandos não estão na posição certa, no sentido deque a operação não existe, e por isso necessita uma conversão de tipos previamente para ser efetuada). Operadores Relacionais e Expressões BooleanasO processamento entre operando é uma relação, daí designa-se que o quando o resultado de uma operação com osoperadores gera um booleano, chama-se expressão booleana. O operador booleano nem sempre existe, mas mesmoque não exista, deve-se haver uma referencia ao booleano, e frequentemente tem-se um número inteiro pararepresentar 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” dosoperadores “(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 paraalgum tipo numérico. Avaliação em curto circuitoTem-se uma expressão e outros operadores, mas às vezes pode-se não precisar percorrer toda expressão paracalcular o resultado, caso consiga-se detectar a operação em questão, calcula-se. (possibilidade de que a avaliaçãonão seja processada por inteiro, faz se o caminho mais curto para se chegar ao resultado) O contrário seria o circuitolongo, em que se varre toda a expressão o que gasta mais tempo. É mais comum em expressões booleanas em que seexclui uma determinada parte {(a and b) or c} o que pode gerar um efeito colateral, pelo fato de que se deixou fazeruma parte de uma operação, o estado das coisas é diferente, resultando em algo diverso aquilo pretendido. Algumaslinguagens possibilitam “chavear” o efeito de querer ou não fazer-se uso da avaliação em curto circuito comcomandos específicos, Ada é uma linguagem que possibilita isto. 19
    • Operador de atribuiçãoFundamental para qualquer linguagem imperativa. Bastante necessário, algumas linguagens possuem um operadorbem 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 comcaracterí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 aooperando 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ÚLTIPLOSCopia 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 CONDICIONAISAtribuição em que algumas vezes se copie para um lado, e outras vezes para o outro. ATRIBUIÇÃO COMPOSTAInc (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 escrevera+=2 é mais eficiente do que escrever a=a+2. OPERADOR UNITÁRIO DE ATRIBUIÇÃOE a atribuição em que há apenas um elemento. Unitário, como no caso de um incremento {i++} pelos mesmosmotivos da atribuição composta, é mais prático e vantajoso i++ do que i=i+1C possui dois tipos o pré-incremento (++i) e o pós-incremento (i++) a diferença é que o pré-incremento é o operadorque faz o incremento e depois retorna o valor. O por declara o valor e depois incrementa. Para isso ele cria umavariável temporária que assume o valor de i e tal variável posteriormente é posta no lugar da expressão. ATRIBUIÇÃO COMO FUNÇÃOAlgumas vezes a atribuição é uma função e outras vezes, procedimento. Ou seja, algumas vezes retorna valor e outranã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, porcompactar uma serie de códigos e absorver mais informação, em termos de quantidade de código. Quando alinguagem não exige que dois operando sejam de mesmo tipo chama-se atribuição de forma mista. 20
    • 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 Próxima execuçãoexecutando “física”Desvio incondicional: instrução que dá o endereço da próxima instrução a ser executada. (geralmente aparece comoo 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 oualgum evento acontecer previamente.No entanto, as duas instruções acima possuem um nível de abstração muito baixo, portanto as linguagens precisamconverter 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) comandoIF (teste) goto x --- --- x:Isto não é mais usado em instruções compostas, pois traz mais desvantagens.Repeat --- --- ---Until (teste) 21
    • INSTRUÇÕES DE SELEÇÃOAs instruções em Linguagens de Programação que definem qual o caminho a ser percorrido chamam-se instruções deseleção.Desvio: associado ao hardwareSeleçã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) comandoEm sublinhado: expressão booleana.Em alguns casos especiais de algumas linguagens, temos opções de utilizar números no lugar de instruções paraserem 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 comandoVarias linguagens apresentam os seletores unidirecionais como se fossem bidirecionais. SELETORES ALINHADOSIF teste then IF teste then comandoElse 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 outroIF. 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 (;). 22
    • 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 muitoscomandos, é o “elseif” ou “elif” de Python, PHP. Portanto, também são classificados como seletores múltiplos. 23
    • Instruções Iterativas  Iterativo = repetitivo ou INDICA UMA REPETIÇÃO. LAÇO CONTROLADO POR CONTADORFor i:=1 to n do comandoTem-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ÓGICAQuer repetir, no entanto fazem-se várias verificações para saber se já atingiu o ponto final ou, a cada fim derepetição faz-se uma verificação para saber se já atingiu o ponto final. O “while” do Pascal é um tipo de laçocontrolado por Lógica.While (teste) do comandoUtiliza 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 umaexpressão booleana. São mais genéricos que laços controlados por contador. CONTROLE LOCALIZADO PELO USUÁRIOO controle não é fixo e nem está na sintaxe do comando. Está em outro comando que o programador põe a seufavor:Repeat --- --- --- If ~~~~~~~ then resume If ~~~~~~~ then break LAÇO CONTROLADO POR ESTRUTURAS DE DADOSA 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 porcontador quanto por estruturas de dados:for(i: coleção) 24
    • 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 osprogramas 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 deprogramaçã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 ESTRUTURADAProgramação Não estruturada é quando o programa não possui uma estrutura planejada, uma fase de engenhariaem que se planeja o que irá ser feito.Com o tempo, a necessidade de construir programas maiores aconteceu.Daprogramação não estruturada evoluiu-se para a programação estruturada. PROGRAMAÇÃO ESTRUTURADAHá 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çãovieram novos paradigmas.Um exemplo “clássico” de programação estruturada é o Pascal. Com o objetivo deincentivar determinadas coisas.Em certo tempo, a programação estrutura tornou-se insuficiente, daí apareceu aprogramação orientada a objeto. PROGRAMAÇÃO ORIENTADA A OBJETOSDiferentemente da estruturada, na POO tem-se varias diretrizes de como são as partes independentes, como elas secomportam 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 naprogramação estruturada, tem-se trechos no programa tratando de trechos diferentes tratando partes diferentes, noentanto não se tem maneiras de se separar cada uma das partes. Para isto, usa-se o goto. Uma parte do programarecebe 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 ogoto não é tão eficiente quanto das linguagens anteriores. Com o desenvolvimento novas linguagens foramaparecendo 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ÚLTIPLASSituação numa instrução iterativa em que se executa no inicio porem tem-se vários pontos de saída, tanto dacondicional, do seletor ou outro.Dessa forma, quebra-se a diretriz da programação estruturada, tendo em vista que não está se executando cadabloquinho, 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 umseletor. Há outros exemplos, como o “return” o “continue”, “last”, “resume” dependendo da linguagem. 25
    • 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 queserão executadas mediantes testes, jogando para o compilador a decisão. Selecionar pedaços do programa de umamaneira 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ívelexecutar, ou se algo já foi executado previamente. 26
    • 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 PascalProcedure 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”. 27