--- filename: learnpascal-pt.pas contributors: - ["Ganesha Danu", "https://github.com/blinfoldking"] - ["Keith Miyake", "https//github.com/kaymmm"] - ["Raul Almeida", "https://github.com/almeidaraul"] translators: - ["Raul Almeida", "https://github.com/almeidaraul"] --- >Pascal é uma linguagem de programação estruturada, que recebeu este nome em homenagem ao matemático e físico Blaise Pascal. Foi criada em 1970 pelo suíço Niklaus Wirth,tendo em mente encorajar o uso de código estruturado. fonte : [wikipédia](https://pt.wikipedia.org/wiki/Pascal_(linguagem_de_programa%C3%A7%C3%A3o)) Para compilar e executar um programa em Pascal, você pode usar o freepascal, um compilador gratuito. [Faça o download aqui](https://www.freepascal.org/) ```pascal //Corpo de um programa em Pascal //isso é um comentário { isso também é um comentário, mas com várias linhas } //cabeçalho do programa PROGRAM aprendendo_pascal; //<-- não esqueça o ponto e vírgula. O nome do programa deve começar com uma letra. CONST { aqui você declara valores constantes } TYPE { aqui você declara tipos não nativos } VAR { aqui você declara variáveis } //programa de fato BEGIN 80 aqui ficam todas as instruções que não pertencem nem a funções nem a procedimentos blocos de código começam com BEGIN e terminam com END (como as chaves em C) } END. //o "end" no final do programa requer um ponto final. ``` ```pascal //formas de declarar uma variável VAR a:INTEGER; VAR b:INTEGER; VAR a : INTEGER; b : INTEGER; VAR a,b : INTEGER; ``` ```pascal PROGRAM Learn_More; //agora, mais sobre tipos de dados e operações CONST PI = 3.141592654; GNU = 'GNU''s Not Unix'; { a convenção é usar caixa alta para constantes constantes têm valores fixos que só podem ser alterados antes da compilação constantes podem ser de qualquer tipo nativo (integer, real, boolean, char, string) TYPE vet_char : array [0..255] of CHAR; // isso declara um novo tipo de variável, vet_char, com 256 caracteres vet_multd : array of array of INTEGER; // vetores de vetores são vetores multidimensionais // use vetores de tamanho 0 (daí, usa-se alocação dinâmica) // vetores do tipo vet_multd são de duas dimensões //declarando variáveis VAR int, c, d : INTEGER; // três variáveis que guardam valores inteiros // inteiros têm 16 bits (vão de -32768 a 32767) r : REAL; // uma variável que guarda um valor real // reais vão de 3.4E-38 a 3.4E38 bool : BOOLEAN; // uma variável que guarda um valor booleano (verdadeiro ou falso) ch : CHAR; // uma variável que guarda um caractere // caracteres têm 8 bits str : STRING; // STRING não é um tipo padrão, mas vem na maioria dos compiladores // string é um vetor de caracteres com tamanho padrão de 255 elementos s : STRING[50]; // especificar o tamanho de uma string assim otimiza o uso de memória my_str: vet_char; // aqui, uma variável de um tipo personalizado declarado acima my_2d : vet_multd; // defina o tamanho de vetores dinâmicos antes de usá-los // outros tipos de dados (pascal é uma linguagem fortemente tipada) // tipos adicionais de inteiros b : BYTE; // faixa [0..255] shi : SHORTINT; // faixa [-128..127] smi : SMALLINT; // faixa [-32,768..32,767] (inteiro padrão) w : WORD; // faixa [0..65,535] li : LONGINT; // faixa [-2,147,483,648..2,147,483,647] lw : LONGWORD; // faixa [0..4,294,967,295] c : CARDINAL; // longword i64 : INT64; // faixa [-9223372036854775808..9223372036854775807] qw : QWORD; // faixa [0..18,446,744,073,709,551,615] // tipos adicionais de reais rr : REAL; // faixa depende da plataforma (8 bits, 16 bits, etc) rs : SINGLE; // faixa [1.5E-45..3.4E38] rd : DOUBLE; // faixa [5.0E-324 .. 1.7E308] re : EXTENDED; // faixa [1.9E-4932..1.1E4932] rc : COMP; // faixa [-2E64+1 .. 2E63-1] BEGIN int := 1;// usa-se := para atribuir valores a variáveis r := 3.14; ch := 'a'; str := 'apple'; bool := true; //pascal não é case-sensitive (não diferencia maiúsculas de minúsculas) // uma opção de organização é usar maiúsculas para termos da linguagem // (BEGIN, END, INTEGER, etc) e constantes // aritmética int := 1 + 1; // int deixa de ser 1 e passa a ser 2 int := int + 1; // int = 2 + 1 = 3; int := 4 DIV 2; //int = 2 (DIV é uma divisão inteira - ignora o resto) int := 3 DIV 2; //int = 1 int := 1 DIV 2; //int = 0 bool := true OR false; // bool = true bool := false AND true; // bool = false bool := true XOR true; // bool = false r := 3 / 2; // usa-se a "/" para divisões entre inteiros r := int; // um real pode receber um valor inteiro (mas não o contrário) c := str[1]; //acessando elementos de um vetor: vetor[índice do elemento] str := 'hello' + 'world'; //concatenação de strings my_str[0] := 'a'; { só se pode atribuir valores a vetores elemento por elemento (não o vetor inteiro de uma vez) } // LAÇOS WHILE (ch != 'a') DO BEGIN writeln('ch é diferente de a'); IF (ch = 'c') THEN writeln('ch é igual a c'); END; SETLENGTH(my_2d,10,10); // inicialização de um vetor com alocação dinâmica; my_2d vira um 10x10 FOR c := 0 to 9 DO { vetores começam em 0 e terminam em tamanho-1 (exceto se, declarando o tipo, forem especificados valores diferentes) } FOR d := 0 to 9 DO // a variável usada em um laço FOR deve ter sido declarada no cabeçalho my_2d[c,d] := c * d; // acessam-se elementos de vetores multidimensionais com [d1, d2, d3...] END. ``` ```pascal PROGRAM programacao_com_funcoes; VAR i, inutil : INTEGER; { OBS: diferença entre procedimento e função função: realiza operações e retorna valor procedimento: só realiza operações } //declarando e descrevendo uma função FUNCTION fatorial_recursiva(CONST a: INTEGER) : INTEGER; { calcula a! recursivamente } // pode-se declarar variáveis locais para funções e procedimentos // exemplo: // VAR // local_a : INTEGER; BEGIN { O bloco ELSE só funciona se não houver ponto e vírgula no bloco do IF exemplo: IF a THEN writeln('a'); ELSE writeln('b'); Isso não permitiria que o programa compilasse } IF a >= 1 THEN // o valor de retorno é atribuído como se a função fosse uma variável fatorial_recursiva := a * fatorial_recursiva(a-1) ELSE fatorial_recursiva := 1; END; // o END de funções e procedimentos recebe ponto e vírgula //declarando e descrevendo um procedimento PROCEDURE salvainteiro(VAR i : INTEGER; inutil : INTEGER); { recebe entrada do usuário e salva na variável i passagem de valor: POR REFERÊNCIA - "VAR i: integer"; implica que alterações na variável i dentro da função são guardadas para o escopo de todo o programa POR VALOR - "inutil: integer"; implica que o valor do argumento é copiado e alterações na variável inutil não são guardadas } BEGIN WRITE('Insira um inteiro: '); //escreve sem quebrar linha READLN(i); //lê i com quebra de linha inutil := 4; // inutil não terá seu valor alterado fora do procedimento. END; BEGIN // programa principal inutil := 3; salvainteiro(i, inutil); // escrevendo i! WRITELN(i, '! = ', factorial_recursion(i)); // escreve e quebra linha // valores numéricos são automaticamente convertidos para texto na escrita // escrever valor de inutil (sempre 3, já que salvainteiro não a altera) WRITELN('inutil = ', inutil); END. ```