Resumo de info

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

Resumo de informática Aluno: 2101 – Philipe Cavalcanti
PASCAL
 Estrutura da linguagem pascal:
Pascal	Algoritmo no visualg	
program exemplo_01; algoritmo “exemplo 01”
uses crt;
var var
Begin 				 inicio
end. fimalgoritmo
Comparando as estruturas principais do pascal e do algoritmo, nota-se uma certa semelhança na escrita dos dois. Porém, existem algumas diferenças além da língua inglesa:
Para colocar o nome do programa não se usa as aspas (“”), não pode conter espaços em branco e no final da linha deve conter um “;” (ponto e virgula).
O “uses crt;” que antes não existia serve para indicar ao programa quais serão as bibliotecas (série de procedimentos ou funções prontas.) que serão utilizadas dentro dele, no caso é a crt.
O Begin e o end (seguido do “.” [ponto final]) equivalem, respectivamente, ao inicio e ao fimalgoritmo.
Tipos de variáveis:
No pascal as variáveis são basicamente as mesmas utilizadas no visualg.
Ex:
Program exemplo_02;
Var
a:integer; 			 // inteiro
b:real; 			 // real
c:string; 			 // caracter
d:boolean; 			 // lógico
vet:array [1..5] of integer; // vetor [1..5] de inteiro
matriz:array [1..3,1..3] of integer; // vetor [1..3,1..3] de inteiro
f:char;				 // um byte apenas (um digito só)
g:string[30];
// No pascal os comentários iniciam-se com “{“ e devem terminar com “}”
{-> Diferente do visualg o pascal nos permite limitar a quantidade de caracteres com que trabalharemos. No exemplo acima aparece escrito “g:string[30];” quando colocamos a palavra string sozinha o computador separa 256 bytes (256 dígitos) para armazenar o valor da variável. Porém se vamos utilizar no máximo 30 caracteres, não é preciso que se reserve 256 lugares para armazená-los. É como se o string fosse um vetor [0..255] de char. <-}
1.2.1 Tipos de dados pré-definidos na biblioteca:
	Tipo de dado inteiro
	Faixa de abrangência
	Tamanho(byte)
	Shortint
	De -128 até 127
	1 byte
	Integer
	De -32.768 a 32.767
	2 bytes
	Longint
	De -2.147.483.648 a 2.147.483.647
	4 bytes
	Byte
	De 0 até 255
	1 byte
	Word
	De 0 até 65535
	2 bytes
 
	Tipo de dado real
	Faixa de abrangência
	Tamanho(byte)
	Real
	De 2.9 e-39 até 1.7 e38
	6 bytes
	Single
	De 1.5 e-45 até 3.4 e38
	4 bytes
	Double
	De 5.0 3-324 até 1.7 e 308
	8 bytes
	Extended
	De 3.4 e-4.932 até 1.1 e4.932
	10 bytes
	Comp
	De -9.2 e18 até 9.2 e18
	8 bytes
1.3 Comandos de leitura e gravação
1.3.1 Saída de dados:
Utilizam-se os comandos write e writeln, conforme a sintaxe abaixo:
Write (local_para_saida_de dados, expressão);
Writeln (local_para_saida_de dados, expressão);
A diferença entre um e outro é que o segundo comando faz o cursor passar para a próxima linha. Para que a expressão seja escrita na tela o local para saída de dados deve ser output.
Ex: Writeln(output,’Turma 09’);
Porém como a saída de dados na tela é algo considerado padrão qualquer expressão dentro do comando write ou writeln é escrita no vídeo, ou seja, não é preciso escrever o local para saída de dados se o local desejado é a tela. 
Em se tratando de números, há a possibilidade da saída formatada, que define o tamanho total do campo numérico (incluindo o ponto), bem como a quantidade de casas decimais.
Ex: writeln(variável : tamanho_do_campo : casas_decimais);
Program exemplo​_03;	Resultado na tela:
	 12.4
 12.43
12.431 
Var	
A:real;
Begin
| a:= 12.431; 
| writeln (a:5:1);
| writeln (a:5:2);
| writeln (a:5:3);
End.
Caso não seja especificada a quantidade de casas decimais o número de casas decimais, o numero real será impresso na notação de ponto flutuante.
Ex:					resultado na tela:
	1.24 e02
 Writeln(124.31:8);	
 
 
1.3.2 Entrada de dados:
Utilizam-se os comandos read e readln, conforme a sintaxe abaixo:
Read (local_para_entrada_de_dados,variável);
Readln (local_para_entrada_de_dados ,variável) 
A diferença entre um e outro é que o segundo comando obriga que a próxima leitura de dados seja feita na linha seguinte. Para que a variável seja lida do teclado o local para entrada de dados deve ser input.
Ex:
Read(input,a);
No caso do read e do readln o local de entrada padrão dos dados é o teclado.
Para a entrada de dados do teclado o uso do read ou do readln não faz diferença. Porém quando a entrada de dados é feita por meio de um arquivo texto o uso do read fará com que o cursor para leitura do arquivo não pule para a linha de baixo depois de chegar no final dela. Portanto é preciso usar o readln para ler todas as linha do arquivo.
1.4 Operadores:
 
	Tipo
	Operador
	Símbolo
	Aritmético
	Multipliçao
	*
	
	Divisão real
	/
	
	Divisão inteira (truncada)
	Div
	
	Resto da divisão inteira
	Mod
	
	Subtração
	-
	
	Adição
	+
	Relacional
	Maior que
	>
	
	Menor que
	<
	
	Maior ou igual
	>=
	
	Menor ou igual
	<=
	
	Igual
	=
	
	Diferente
	<>
	Lógico
(boolean)
	Não
	Not
	
	E
	And
	
	Ou
	or
1.5 Expressões:
Linearizar expressões:
Ex: a:= ((x+y)/3)*2;
Não esquecendo de que ao adicionar variáveis não numéricas estamos
efetuando um CONCATENAÇÃO:
a:=”João”+”Maria”; Resultado: JoãoMaria
1.6 if...then...else....
Alternativa Simples: if...then
 If <expressão_lógica> Then Comando;
Expressão_lógica pode ser simples ou até relações complexas. Se a expressão_lógica resultar verdadeira (TRUE), então o comando será executado caso contrário não. Para os casos em que tivermos mais de um comando para serem executados, eles deverão vir delimitados pelas palavras Begin e End.
 If <expressão_lógica> Then
 Begin
 Comando_1;
 Comando_2;
 Comando_3;
 End;
No caso acima, se expressão_lógica for TRUE então todos comandos inclusos entre as palavras Begin e End serão executados, caso contrário não.
Alternativa composta: if...then...else
 If <expressão_lógica> Then Comando_1
 Else Comando_2;
Neste caso, se expressão_lógica for TRUE então comando_1 será executado e comando_2 não, caso contrário, comando_2 será executado e comando_1 não. Repare que não temos ; no final de comando_1.
Podemos também escrever:
 If <expressão> Then Begin
 Comando_1;
 Comando_2;
 End { não tem ; }
 Else Begin
 Comando_3;
 Comando_4;
 End;
Importante!!!
Não esqueça que todo comando deve ter um ; no final.
Não se coloca ; antes de else;
Quando usamos um só comando não e preciso colocar Begin e end o ; funciona para indicar o final da estrutura;
Quando utilizamos um ninho de IFs apenas um ; é usado para indicar o final da estrutura, diferentemente do visualg onde para cada se tinha um fimse.
Relembrando!!!
1.6 Vetores e Matrizes
	Vetores e matrizes são variáveis que possuem vários elementos de mesmo tipo, cada elemento possui um ou mais índices que os referenciam e os diferenciam. Uma característica importante é que todos os valores permanecem na memória ao mesmo tempo. Os elementos são alocados com contigüidade física, ou seja, um ao lado do outro.
1.6.1 Vetores
	É um tipo particular de matriz onde cada elemento possui só um índice (unidimensional). 
	O programa exemplo abaixo, permite a entrada de nomes e idades, logo após imprime todos os nomes e idades contidos na memória.
Program Vetor;
Uses Crt;
Var 
Nome: Array[1..3] of String;
Idade: Array[1..3] of integer
I:integer;
Begin
 For
i:=1 to 3 do
 begin
 ReadLn(Nome[i]);
 Readln(idade[i]);
 End;
 For i:= 1 to 3 do 
 Begin
 Writeln(nome[i]);
 Writeln(idade[i]);
 End; 
End. 
1.6.2 Matriz
	É um tipo de dado que permite que uma variável contenha vários elementos de mesmo tipo. Cada elemento possui dois ou mais índices (bidimensional, tridimensional, etc) que o diferencia dos outros elementos.
O programa abaixo lê 9 números e os coloca no formato de uma matriz 3x3.
program matriz;
Var
elemento:array[1..3,1..3] of integer;
i,j:integer;
Begin
 For i:=1 to 3 do
 For j:=1 to 3 do 
 Readln(elemento[i,j]);
 For i:=1 to 3 do
 begin
 For j:=1 to 3 do
 Write(elemento[i,j]);
 writeln;
 end;
end.
1.7. Procedimento
O procedimeto é como se fosse um algoritmo. Ele tem a estrutura praticamente igual a de um algoritmo, como veremos mais adiante. O procedimento deve ser ativado (chamado) pelo algoritmo principal ou por um outro procedimeto, ou até por ele mesmo.
1.7.1 Declaraçao de Procedimentos e funçoes
Um procedimento tem praticamente a mesma estrutura de um algoritmo, ou seja, ele contém um cabeçalho, área de declarações e o corpo do procedimento.
Exemplo 5:
var
a: vetor [1..3] de caracter
i:inteiro
procedimento ler
inicio
para i:=1 ate 3 faca
leia(a[i])
fimpara
fimprocedimento
procedimento escrever 
inicio
para i:=1 ate 3 faca
escreval(a[i])
fimpara
fimprocedimento
inicio
ler
escrever
fimalgoritmo
Esse algoritmo lê três nomes e depois os escreve, perceba que eu declaro o procedimento antes do algoritmo principal e do um nome para ele depois eu apenas escrevo nome do procedimento, que ele o executa como sendo uma extensão do algoritmo principal. Vamos dizer que tivéssemo que escrever esses mesmo procedimentos 'n' vezes seria muito mais facil escrever o nome do procedimeno do que escreve-lo vez por vez dentro do algoritmo. Essa é a ideia principal, economizar tempo e linhas dentro do algoritmo usando procedimentos e funções. 
Exemplo 6:
//algoritmo que soma dois numeros e divide essa soma por 2 
var 
y:real
funcao soma: inteiro
var
a,b,c:inteiro
inicio
leia(a)
leia(b)
c:=a+b
retorne(c)
fimfuncao
inicio
y:=soma/2
escreval(y)
fimalgoritmo
A funcao funciona igual ao procedimento porém na funcao eu tenho a opçao de retornar um valor para o nome da funcao ou seja, quando a funçao é iniciada ela cria uma variavel com o proprio nome para que possa ser dado a essa variavel algum valor, para isso é preciso usar o comando retorne, dentro dos parenteses o valor da variavel que você queira retornar para a funçao. Vamos imaginar que tivessemos uma conta monstruosa e a unica coisa que nos importasse fosse o resultado, com a funçao nós temos essa opçao de ficar apenas com o resultado final.
1.7.2 Variáveis (global / local)
Como estamos aprendendo funções e procedimentos é preciso introduzir o conceito de variável global ou local. Variáveis globais são aquelas declaradas na seçao de variáveis do algoritmo principal. Variáveis locais são declaradas dentro da seção de variáveis do procedimento ou funçao.
Qual a diferença? Variáveis globais podem ser usadas em qualquer parte do algoritmo principal, procedimentos e funções pois, quando o algoritmo é iniciado elas permanecem criadas do inicio ao fim. Variáveis locais só podem ser usadas dentro do procedimento ou função em que forem criadas pois, quando o procedimento ou função é iniciado as variávis declaradas dentro da seçao são criadas, terminada a função ou procedimento elas são apagadas da memória do pc, ou seja se tentármos utilizar uma variável criada dentro de uma função ou procedimento dentro do algoritmo principal irá ocorrer erro pois, será como se ela nunca tivesse existido para o algoritmo principal. 
Importante!
As variaveis criadas dentro da funçao ou procedimento só existem dentro deles não podendo ser usadas fora deles sendo chamadas de variaveis locais, caso precise utlizar uma variavel em mais de uma funçao ou procedimento ou ate mesmo dentro do algoritmo principal é preciso que seja declarada uma variavel global, sendo colocada dentro da area de varariaveis do algoritmo principal.
Uma funçao ou procedimento não é uma variavel, não acumulando valores, uma vez que ela é chamada dentro do algoritmo é iniciado os parametros definidos dentro dela, caso seja chamado novamente dentro do algoritmo será reiniciado todo processo dentro da função ou procedimento
Passagem de Parâmetros
1.8.1 Por valor
No programa do exemplo abaixo a passagem dos parâmetros a e b foi realizada por valor:
apenas seus valores foram copiados paras os argumentos x e y, respectivamente. Neste caso, não
há possibilidade de se alterar o valor deste parâmetro.
Program ExemploFuncao;
Var								Resultado:
	Digite os valores dos catetos: 3 4 [enter]
A hipotenusa é 5.00
a, b: real;
function Hipotenusa(x:real; y:real):real;
Begin
Hipotenusa := sqrt(x*x + y*y);
End;
begin
write('Digite os valores dos catetos: ');
read(a,b);
writeln('A hipotenusa é ',Hipotenusa(a,b):5:2);
end.
1.8.2 Por Referência
Quando o objetivo é alterar o valor de algum parâmetro, a passagem por referência é indicado.
Para isto, deve ser colocado na frente dos argumentos da função ou procedimento a palavra
reservada var. O programa do exemplo abaixo exemplifica a passagem por referência. Nele, a função
incrementa altera o valor da variável n (k passado por referência) por um valor d (parâmetro
passado por valor, já que não será alterado).
Program PassaParametros;
var
k: integer;
procedure incrementa(var n: integer; d: integer);
begin
n := n + d;						Resultado:
	k = 1
k = 5
k = 2 
end;
begin
k := 1;
writeln('k = ',k);
incrementa(k,4);
writeln('k = ',k);
incrementa(k,-3);
writeln('k = ',k);
end.