Este guia é um material de apoio para quem está começando na linguagem Pascal, especialmente para estudantes que já possuem uma base em lógica de programação.

Pascal foi criada em 1970 por Niklaus Wirth com um objetivo explícito: ser uma linguagem para ensinar programação estruturada de forma clara e disciplinada — por décadas foi a linguagem padrão de cursos introdutórios de Ciência da Computação ao redor do mundo, no papel que hoje é ocupado por Python ou C neste curso. É o par natural de C: as duas nasceram na mesma década, com a mesma proposta de programação estruturada, mas com filosofias de sintaxe bem diferentes.

🔹 Pascal x C: duas respostas para o mesmo problema

Onde C usa { } para blocos, Pascal usa palavras-chave por extenso — begin/end. Onde C termina cada comando com ; como separador entre TODOS os comandos, Pascal usa ; como separador entre comandos (não terminador) e a palavra end. (com ponto) para fechar o programa inteiro. É uma sintaxe mais verbosa, mas pensada para ser lida quase como português/inglês estruturado — parte do motivo de Wirth tê-la criado para ensino.

🛠️ Instalação e Configuração do Ambiente

A implementação moderna, gratuita e multiplataforma de Pascal é o Free Pascal (FPC), com a IDE Lazarus por cima dele (o equivalente open-source do Delphi):

fpc -h

Baixe o Free Pascal e/ou o Lazarus no site oficial.

🚀 Seu Primeiro Programa em Pascal

Crie um arquivo chamado:

ola.pas

Escreva:

program Ola;
begin
  writeln('Ola, Universo Pascal!');
end.

Compile e execute:

fpc ola.pas
./ola

O resultado será:

Ola, Universo Pascal!

Análise do Código

  • program Ola; nomeia o programa — obrigatório em Pascal, sem equivalente direto em C.
  • begin … end. (com ponto final) delimita o bloco principal — repare no ponto, que não aparece em nenhum outro end do programa.
  • writeln() exibe texto com quebra de linha automática — o println/printf do Pascal.

📊 Tipos de Dados e Variáveis

Diferente de C (declaração de variável em qualquer ponto do bloco), Pascal exige que todas as variáveis sejam declaradas juntas, em uma seção var no início do bloco:

program Variaveis;
var
  nome: string;
  idade: integer;
  salario: real;
  estudante: boolean;
begin
  nome := 'Ana Souza';
  idade := 25;
  salario := 6200.75;
  estudante := true;
end.

:= é o operador de atribuição em Pascal — distinto de =, que é reservado só para comparação. Essa separação evita uma classe inteira de bugs que existe em C/Java, onde = (atribuição) e == (comparação) podem ser confundidos.

🔢 Operadores

Aritméticos

Operador Significado
+ Adição
- Subtração
* Multiplicação
/ Divisão (sempre real)
div Divisão inteira
mod Resto da divisão

Comparativos

Operador Significado
= Igual
<> Diferente
>, <, >=, <= Comparação numérica

Lógicos

Operador Significado
and E (AND)
or OU (OR)
not NÃO (NOT)

Repare que Pascal usa palavras (and, or, not) em vez dos símbolos &&/||/! que aparecem em quase toda outra linguagem deste curso — mais uma decisão de legibilidade “quase-inglês”.

📤 Saída e 📥 Entrada de Dados

program EntradaSaida;
var
  nome: string;
begin
  write('Digite seu nome: ');
  readln(nome);
  writeln('Ola, ', nome, '!');
end.

write exibe sem quebra de linha; writeln exibe com quebra de linha (o “ln” = line). readln lê uma linha do teclado — o par exato de write/writeln para entrada.

🔀 Estrutura Condicional

program Saudacao;
var
  hora: integer;
begin
  write('Digite a hora (0-23): ');
  readln(hora);
  if hora < 6 then
    writeln('Boa madrugada!')
  else if hora < 12 then
    writeln('Bom dia!')
  else if hora < 18 then
    writeln('Boa tarde!')
  else
    writeln('Boa noite!');
end.

Pascal não tem elif/elseif como palavra única — assim como em Batch, else if (duas palavras) encadeado funciona normalmente. Quando um bloco if/else tem mais de um comando, ele precisa ser envolvido em begin ... end, senão só a primeira linha pertence à condição.

🔁 Estruturas de Repetição

// for (laço clássico, sempre incremento de 1 com "to")
var i: integer;
for i := 1 to 5 do
  writeln(i);

// while (testa a condição antes)
var contador: integer;
contador := 0;
while contador < 5 do
begin
  writeln(contador);
  contador := contador + 1;
end;

// repeat-until (testa a condição depois — o do-while do Pascal)
var n: integer;
n := 0;
repeat
  writeln(n);
  n := n + 1;
until n >= 5;

repeat ... until condição é o equivalente do do-while de C — mas repare que a condição do until é o oposto: repeat continua até a condição ser verdadeira, enquanto do-while continua enquanto ela for verdadeira.

📏 Arrays

var
  numeros: array[0..3] of integer;
  i: integer;
begin
  numeros[0] := 10;
  numeros[1] := 20;
  numeros[2] := 30;
  numeros[3] := 40;

  for i := 0 to 3 do
    writeln(numeros[i]);
end.

array[0..3] of integer declara um array de 4 posições (índices 0 a 3, inclusive) — o intervalo é explícito na declaração, diferente do int numeros[4] de C onde só o tamanho aparece.

🧩 Procedures e Functions

Pascal distingue explicitamente dois tipos de sub-rotina, algo que C não faz (em C, tudo é função, mesmo quando não retorna nada):

// procedure: não retorna valor (equivalente a "void" em C)
procedure Saudar(nome: string);
begin
  writeln('Ola, ', nome, '!');
end;

// function: retorna um valor
function Somar(a, b: integer): integer;
begin
  Somar := a + b;  // o nome da function recebe o valor de retorno
end;

begin
  Saudar('Ana');
  writeln(Somar(2, 3));
end.

Dentro de uma function, atribuir um valor ao próprio nome da function (Somar := a + b) é como o valor de retorno é definido — não existe uma palavra-chave return obrigatória (embora exit(valor) também funcione em implementações modernas como o Free Pascal).

🏢 E o Delphi?

Delphi é o ambiente de desenvolvimento comercial da Embarcadero (antes Borland) construído em cima do Object Pascal — um Pascal estendido com orientação a objetos, usado principalmente para aplicações desktop Windows com interface gráfica via VCL (Visual Component Library), no estilo RAD (Rapid Application Development, arrastar-e-soltar componentes visuais):

type
  TPessoa = class
  private
    FNome: string;
  public
    constructor Create(nome: string);
    procedure Cumprimentar;
  end;

constructor TPessoa.Create(nome: string);
begin
  FNome := nome;
end;

procedure TPessoa.Cumprimentar;
begin
  writeln('Ola, meu nome eh ', FNome);
end;

O prefixo T em TPessoa é uma convenção universal do ecossistema Delphi/Object Pascal para nomear tipos (classes). Delphi ocupou, nos anos 1990-2000, o mesmo nicho que C#/.NET ocupa hoje: desenvolvimento rápido de aplicações Windows com formulários visuais.

🔤 E o BASIC?

BASIC (Beginner’s All-purpose Symbolic Instruction Code) nasceu em 1964 em Dartmouth com o mesmo objetivo pedagógico de Pascal — mas para um público ainda mais amplo, sem formação técnica prévia. Ficou popular nos anos 1980 embutido em quase todo computador doméstico (Commodore 64, MSX, IBM PC com GW-BASIC), com uma característica hoje rara: números de linha obrigatórios, que definem tanto a ordem de execução quanto o alvo de comandos de desvio como GOTO.

10 INPUT "Digite a hora (0-23): "; HORA
20 IF HORA < 12 THEN
30   PRINT "Bom dia!"
40 ELSEIF HORA < 18 THEN
50   PRINT "Boa tarde!"
60 ELSE
70   PRINT "Boa noite!"
80 END IF
90 END

Saída (para entrada 9): Digite a hora (0-23): ? Bom dia!

💡 O ? depois do prompt não é um erro — é o comportamento padrão do INPUT clássico: ele sempre acrescenta ? após o texto do prompt antes de esperar a digitação.

Laços em BASIC clássico usam FOR/NEXT, sem a flexibilidade do for de C — sempre incremento fixo sobre uma variável numérica:

10 INPUT "Quantos numeros? "; N
20 SOMA = 0
30 FOR I = 1 TO N
40   INPUT "Valor: "; VALOR
50   SOMA = SOMA + VALOR
60 NEXT I
70 PRINT "Soma total = "; SOMA
80 END

Saída (para N=3, valores 10, 20, 30): Soma total = 60

⚠️ Variáveis sem declaração e sem tipo explícito. Diferente de Pascal (seção var obrigatória) e C (int/double explícitos), BASIC clássico cria uma variável na primeira vez que ela é usada — SOMA = 0 já a declara. Isso é mais rápido para escrever, mas elimina a rede de segurança que Pascal e C dão contra erros de digitação em nomes de variáveis (SOMA vs SOMMA viram duas variáveis diferentes silenciosamente).

🔷 De BASIC ao VB.NET

O Visual Basic .NET (VB.NET) é a evolução direta dessa família — mantém a sintaxe “quase-inglês” do BASIC clássico (If/Then/End If, sem chaves {}), mas roda sobre a mesma plataforma .NET que C#, com tipagem estática, orientação a objetos completa e sem números de linha:

Imports System

Module Program
    Sub Main(args As String())
        Console.Write("Digite seu nome: ")
        Dim nome As String = Console.ReadLine()
        Console.WriteLine("Ola, " & nome & "!")

        Dim idade As Integer = 25

        If idade >= 18 Then
            Console.WriteLine("Maior de idade")
        Else
            Console.WriteLine("Menor de idade")
        End If

        Dim soma As Integer = 0
        For i As Integer = 1 To 5
            soma += i
        Next

        Console.WriteLine("Soma de 1 a 5: " & soma)
    End Sub
End Module

Saída (para entrada Maria):

Digite seu nome: Ola, Maria!
Maior de idade
Soma de 1 a 5: 15

💡 For i As Integer = 1 To 5 já é diferente do FOR I = 1 TO N clássico — em VB.NET a variável do laço é tipada e escopada ao próprio For, uma herança da disciplina de tipos do .NET, não do BASIC dos anos 80. É o mesmo salto que Delphi deu sobre o Pascal original: sintaxe familiar, fundamentos modernizados.

⚠️ Erros Comuns de Iniciantes

Confundir := (atribuição) com = (comparação)

idade = 25;   // ERRO de compilação: "=" sozinho não atribui
idade := 25;  // Correto

Esquecer o begin/end em blocos com mais de um comando

if hora < 12 then
  writeln('Bom dia!');
  writeln('Aproveite o café da manhã!');  // ERRO: essa linha SEMPRE executa,
                                            // não faz parte do "if" sem begin/end

Esquecer o ; entre comandos ou o . final do end

begin
  writeln('Ola')   // ERRO: falta ";" antes do próximo comando
  writeln('Mundo');
end.                // O PONTO aqui é obrigatório — "end;" sozinho não fecha o programa

🧠 Pascal x C

Característica Pascal C
Delimitador de bloco begin / end { }
Atribuição := =
Comparação de igualdade = ==
Operadores lógicos Palavras (and, or, not) Símbolos (&&, ||, !)
Sub-rotina sem retorno procedure void função()
Sub-rotina com retorno function tipo função()
do-while repeat ... until (condição invertida) do { } while()
Declaração de variáveis Todas juntas em var, no início do bloco Em qualquer ponto do bloco
Números de linha obrigatórios Não Não (mas BASIC clássico exige)
Variável declarada implicitamente Não (var obrigatório) Não (int/double obrigatório) — BASIC clássico sim, VB.NET não

🎓 Conclusão

Pascal prioriza legibilidade e disciplina estrutural acima de concisão — cada decisão de sintaxe (begin/end por extenso, := separado de =, procedure separado de function) existe para tornar o código mais explícito e mais difícil de escrever errado, ao custo de mais digitação que C. Domine os fundamentos daqui e compare com C, a linguagem que resolve os mesmos problemas de programação estruturada com uma filosofia de sintaxe oposta: mais compacta, menos palavras reservadas por extenso.

BASIC percorreu o caminho inverso ao de Pascal→Delphi em um aspecto: nasceu ainda mais permissivo (sem tipos, sem declaração), e só ganhou disciplina de tipos décadas depois, ao virar VB.NET sobre a plataforma .NET — hoje tão rigoroso quanto C# na prática, apesar da sintaxe “quase-inglês” que preservou por herança.