Funções, procedimentos e tipos primitivos básicos

Posted on 2026年7月13日 by

Modifique o arquivo dpr da aula anterior com o conteúdo abaixo

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
program MyProgram;
procedure MyProcedure(const A: Integer);
begin
  WriteLn('A + 10 is: ', A + 10);
end;
function MyFunction(const S: string): string;
begin
  Result := S + 'strings are automatically managed';
end;
var
  X: Single;
begin
  WriteLn(MyFunction('Note: '));
  MyProcedure(5);
  // A barra "/" sempre retorna ponto flutuante, use "div" para divisão inteira
  X := 15 / 5;
  WriteLn('X is now: ', X); // notação científica
  WriteLn('X is now: ', X:1:2); // 2 casas decimais
end.Code language: PHP (php)
D:\fpcdemo>fpc mydemo.dpr
Free Pascal Compiler version 3.2.2 [2021/05/15] for i386
Copyright (c) 1993-2021 by Florian Klaempfl and others
Target OS: Win32 for i386
Compiling mydemo.dpr
Linking mydemo.exe
20 linhas compiladas, 0,0 seg, 39248 bytes código, 2484 bytes dados

D:\fpcdemo>mydemo
Note: strings are automatically managed
A + 10 is: 15
X is now:  3.000000000E+00
X is now: 3.00

D:\fpcdemo>Code language: CSS (css)

Abaixo está a explicação dos comentários. Caracteres não ingleses podem aparecer com falhas de renderização; configure o console para exibir chinês corretamente.

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
program MyProgram; 
// Nome personalizado do programa. Programas de console Pascal iniciam com program nome; depois declarar variáveis, procedimentos e lógica principal

// Sem valor de retorno: procedure procedimento. Procedimentos e funções só executam se forem chamados
procedure MyProcedure(const A: Integer);
begin
  WriteLn('A + 10 =：', A + 10);
end;

// Com valor de retorno: function função
function MyFunction(const S: string): string;
begin
  Result := S + 'a memória das strings é gerenciada automaticamente pelo sistema';
end;

// Object Pascal não tem função main, o bloco mais externo begin...end. é o ponto de entrada do programa, este é o bloco principal
var
  X: Single; // Tipo primitivo de ponto flutuante simples
begin 
  // Toda lógica executável fica aqui
  WriteLn(MyFunction('Aviso：'));
  MyProcedure(5);

  // O operador "/" sempre gera valor flutuante, use div para divisão inteira
  X := 15 / 5;
  WriteLn('X is now：', X); // Saída automática em notação científica
  WriteLn('X is now：', X:1:2); // Limitar para 2 casas decimais
end. // end. com ponto marca o encerramento total do programaCode language: PHP (php)

Cada função e procedimento usa um par begin e end para delimitar seu corpo, equivalente às chaves { } de C, C++, Java e outras linguagens.

WriteLn imprime conteúdo no console, aspas simples ‘ ‘ envolvem literais de string. WriteLn('A + 10 =：', A + 10); imprime sequencialmente a string A + 10 =： e o resultado do cálculo A + 10.

Um programa só pode ter um único bloco externo begin e end. com todo o código principal, que chama outras funções e procedimentos internamente.

X := 15 / 5;
WriteLn(‘X is now: ‘, X); // notação científica
WriteLn(‘X is now: ‘, X:1:2); // duas casas decimais

/ representa divisão de ponto flutuante, o quociente é sempre um número decimal.

As duas primeiras linhas são diretivas de pré-compilação

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}Code language: PHP (php)

Esta é uma diretiva de compilação condicional exclusiva do FPC

  • {$ifdef FPC}: Executa as configurações intermediárias apenas se o compilador for o Free Pascal
  • {$mode objfpc}: Alterna para o modo de sintaxe ObjFpc
  • {$H+}: Habilita strings longas (tipo string moderno com gerenciamento automático de memória, obrigatório)
  • {$J-}: Desativa constantes modificáveis (constantes não podem ser alteradas durante execução, maior segurança)
  • {$endif}: Fim do bloco condicional

Objetivo: Ativar sintaxe moderna apenas na compilação com FPC; o compilador Delphi ignora todo este bloco.

{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}Code language: PHP (php)

Compilação condicional multiplataforma

  • MSWINDOWS: Válido apenas no sistema operacional Windows
  • {$apptype CONSOLE}: Define o programa como aplicativo de console (abre janela de terminal preta em vez de janela gráfica). Esta linha é ignorada ao compilar em Linux/macOS.

Conhecimentos centrais

  • string tipo nativo primitivo; FPC/Delphi gerencia memória automaticamente, não precisa liberar manualmente
  • procedure procedimento: Sem valor de retorno; function função: Com valor de retorno armazenado na variável nativa Result
  • Diferença de divisões: / divisão flutuante; div divisão inteira truncada
  • Saída formatada variável:larguraTotal:casasDecimais para controlar exibição de floats
  • Funções recursivas sem parâmetros precisam de parênteses vazios () para evitar ambiguidade sintática
  • Exit(valor) define diretamente o retorno e encerra a função antecipadamente
  • Funções podem ser chamadas ignorando o valor de retorno, ideal para lógica com efeitos colaterais como alterar variáveis globais

Regras de valor de retorno de funções

  1. A variável especial embutida Result guarda o valor retornado pela função, leitura e escrita idêntica a variáveis locais
function MyFunction(const S: string): string;
begin
  Result := S + 'One';
  Result := Result + 'Two';
end;
Code language: PHP (php)
  1. A sintaxe antiga permite atribuir diretamente ao nome da função (MyFunction := xxx), não recomendada por baixa legibilidade; use sempre Result.

C/C++/Java/C# usam = para atribuição e == para comparação de igualdade. Pascal funciona ao contrário: := para atribuir variáveis, um único = para comparação, igual à notação matemática.

Pascal não possui o operador ==

Substitua a antiga MyFunction do exemplo por esta versão. Esta função adiciona primeiro “One” e depois “Two” no final da string recebida na chamada.

A string final retornada será: string original + One + Two

Chamadas recursivas

Funções sem parâmetros em recursão devem ter parênteses vazios () para diferenciar “executar função” e “ler valor de retorno atual”:

function SumIntegersUntilZero: Integer;
var I: Integer;
begin
  ReadLn(I);
  Result := I;
  if I <> 0 then
    Result := Result + SumIntegersUntilZero(); // chamada recursiva com ()
end;
Code language: JavaScript (javascript)

Para a função sem parâmetros SumIntegersUntilZero:

  1. SumIntegersUntilZero() → Executa a função recursivamente e captura o valor de retorno
  2. SumIntegersUntilZero → Acessa a variável interna Result (próprio valor de retorno da função)

Código sem parênteses:

Result := Result + SumIntegersUntilZero;

O compilador interpreta como:

Result := Result + Result;

Equivale a Result := Result * 2, toda lógica recursiva quebrada, laço infinito e valores dobrando constantemente.

Neste exemplo, a função se chama repetidamente até que a entrada seja zero para sair; enquanto o valor for diferente de zero, a recursão continua.

Exit: Saída antecipada

  1. Exit sem parâmetros: Sai da função imediatamente, retorna o valor já atribuído a Result
  2. Exit(valor): Define diretamente o valor de retorno e encerra a função, equivalente ao return x do C
function AddName(const ExistingNames, NewName: string): string;
begin
  if ExistingNames = '' then
    Exit(NewName); // Retorna NewName diretamente e finaliza
  Result := ExistingNames + ', ' + NewName;
end;
Code language: PHP (php)
{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
program MyProgram;
procedure MyProcedure(const A: Integer);
begin
  WriteLn('A + 10 is: ', A + 10);
end;

function AddName(const ExistingNames, NewName: string): string;
begin
  if ExistingNames = '' then
    Exit(NewName); 
  Result := ExistingNames + ', ' + NewName;
end;

var
  X: Single;
begin
  WriteLn(AddName('Tom','Jack'));
  WriteLn(AddName('Tom',''));
  WriteLn(AddName('','Jack'));
end.Code language: PHP (php)

Chamar funções como procedimentos (ignorar retorno)

Mesmo funções com retorno podem ser executadas só pela lógica, ignorando o resultado; adequado para lógica com efeitos colaterais como alterar variáveis globais:

var
  Count, MyCount: Integer;
function CountMe: Integer;
begin
  Inc(Count); // Efeito colateral: incrementar variável global
  Result := Count;
end;
begin
  Count := 10;
  CountMe;   // Descartar retorno, só executar lógica, Count vira 11
  MyCount := CountMe; // Armazena valor retornado, Count vira 12
end.
Code language: PHP (php)

Exemplo completo funcional

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
program MyProgram;

var
  Count, MyCount: Integer;

function CountMe: Integer;
begin
  Inc(Count); 
  Result := Count;
end;

begin
  Count := 10;
  WriteLn(CountMe);   
  MyCount := CountMe;
  WriteLn(MyCount);
end.Code language: PHP (php)

Inc é função padrão nativa Pascal (FPC/Delphi), incrementa variável em 1.

var é a palavra-chave de declaração de variáveis do Pascal, serve para definir variáveis.

var
  Count, MyCount: Integer;Code language: JavaScript (javascript)

var: Abre a seção de declaração de variáveis

Count, MyCount: Dois nomes de variáveis

Integer: Tipo inteiro

As variáveis declaradas no bloco var deste exemplo são globais, acessíveis por todas as procedimentos e funções de todo o programa.

Funções, procedimentos e tipos primitivos básicos

POSTED IN Free Pascal Tutorial

Deixe um comentário

O seu endereço de email não será publicado. Campos obrigatórios marcados com *