PASCAL
### Introdução ao Pascal
Pascal é uma linguagem de programação de alto nível, desenvolvida por Niklaus Wirth na
década de 1970. É conhecida por sua clareza e estrutura, sendo frequentemente utilizada para
ensinar conceitos de programação.
### Estrutura Básica de um Programa em Pascal
Um programa em Pascal tem a seguinte estrutura básica:
```pascal
program NomeDoPrograma;
begin
{ Instruções do programa }
end.
```
### Tipos de Dados
Pascal possui vários tipos de dados, incluindo:
- **Inteiros**: `integer`
- **Reais**: `real`
- **Caracteres**: `char`
- **Booleanos**: `boolean`
- **Strings**: `string`
### Variáveis
As variáveis devem ser declaradas antes de serem usadas. Exemplo:
```pascal
var
idade: integer;
nome: string;
```
### Estruturas de Controle
Pascal suporta várias estruturas de controle, como:
- **Condicional (if-then-else)**:
```pascal
if idade >= 18 then
writeln('Maior de idade')
else
writeln('Menor de idade');
```
- **Laços (for, while)**:
```pascal
for i := 1 to 10 do
writeln(i);
while idade < 18 do
begin
writeln('Ainda é menor de idade');
idade := idade + 1;
end;
```
### Procedimentos e Funções
Pascal permite a definição de procedimentos e funções:
```pascal
procedure ExibirMensagem;
begin
writeln('Olá, mundo!');
end;
function Soma(a, b: integer): integer;
begin
Soma := a + b;
end;
```
### Entrada e Saída
Para entrada e saída de dados, utilizamos `read` e `writeln`:
```pascal
var
numero: integer;
begin
writeln('Digite um número:');
read(numero);
writeln('Você digitou: ', numero);
end.
```
### Comentários
Os comentários podem ser feitos usando `{}` ou `(* *)`:
```pascal
{ Este é um comentário de uma linha }
(* Este é um comentário
de múltiplas linhas *)
```
Em Pascal, as estruturas de controle são fundamentais para a lógica de programação. Elas
permitem que você tome decisões, repita ações e organize seu código de maneira eficiente.
Aqui estão as principais estruturas de controle em Pascal:
### 1. Estruturas Condicionais
#### a. `if-then`
A estrutura `if` é usada para executar um bloco de código se uma condição for verdadeira.
```pascal
if condição then
begin
{ bloco de código }
end;
```
#### b. `if-then-else`
Permite executar um bloco de código se a condição for verdadeira e outro bloco se for falsa.
```pascal
if condição then
begin
{ bloco de código se verdadeiro }
end
else
begin
{ bloco de código se falso }
end;
```
#### c. `case`
A estrutura `case` é usada para selecionar um bloco de código a ser executado com base no
valor de uma variável.
```pascal
case variável of
valor1: { bloco de código para valor1 };
valor2: { bloco de código para valor2 };
valor3: { bloco de código para valor3 };
else
{ bloco de código padrão };
end;
```
### 2. Estruturas de Repetição
#### a. `for`
O laço `for` é usado para repetir um bloco de código um número específico de vezes.
```pascal
for variável := valor_inicial to valor_final do
begin
{ bloco de código }
end;
```
Exemplo:
```pascal
for i := 1 to 10 do
writeln(i);
```
#### b. `while`
O laço `while` repete um bloco de código enquanto a condição for verdadeira.
```pascal
while condição do
begin
{ bloco de código }
end;
```
Exemplo:
```pascal
while contador < 10 do
begin
writeln(contador);
contador := contador + 1;
end;
```
#### c. `repeat-until`
O laço `repeat` executa um bloco de código pelo menos uma vez e continua até que a condição
se torne verdadeira.
```pascal
repeat
{ bloco de código }
until condição;
```
Exemplo:
```pascal
repeat
writeln('Digite um número (0 para sair):');
read(numero);
until numero = 0;
```
### 3. Estruturas de Controle de Fluxo
#### a. `goto`
Embora não seja recomendado devido à sua capacidade de tornar o código confuso, o
comando `goto` pode ser usado para saltar para uma etiqueta específica no código.
```pascal
goto etiqueta;
etiqueta:
{ bloco de código }
```
### 4. Estruturas de Procedimentos e Funções
Além das estruturas de controle, você pode organizar seu código em procedimentos e funções,
que permitem a reutilização de código e a modularização.
#### a. Procedimentos
Um procedimento é um bloco de código que pode ser chamado em qualquer parte do
programa.
```pascal
procedure NomeDoProcedimento;
begin
{ bloco de código }
end;
```
#### b. Funções
Uma função é semelhante a um procedimento, mas retorna um valor.
```pascal
function NomeDaFuncao: TipoRetorno;
begin
{ bloco de código }
NomeDaFuncao := valor; { retorna um valor }
end;
```
### Conclusão
Essas estruturas são essenciais para controlar o fluxo de execução em um programa Pascal.
### Conclusão
Pascal é uma linguagem poderosa e didática, ideal para iniciantes. Com sua sintaxe clara e
estruturada, é uma excelente escolha para aprender os fundamentos da programação.