Arrays (vetores)

1.Array

Uma array (vetor) é uma potente ferramenta que armazena dados do mesmo tipo (real, integer, string, etc). É como pequenas caixas enfileiradas, numeradas e guardando valores. O tamanho declarado no início do programa não pode ser alterado, sendo assim, uma array tem um tamanho fixo, mas podemos usá-la por inteiro ou não.
Cada uma dessas "caixas" recebem um número para diferenciar uma da outra.

Uma array é declarada assim:

var
      nomedaarray : array [n..m] of tipo;

(onde nomedaarray é o nome da array, n é o valor inicial do índice, m é o valor máximo do índice e tipo é a natreza dessa array - real, integer, string, char, etc)

Exemplo:

var
        vetor1 : array [1..10] of integer;

Nesse caso, a array chama-se vetor1, seu índice começa em 1 e termina em 10 (ou seja, temos dez caixas enfileiradas, com números para identificá-las), podendo receber apenas valores inteiros (integer).

 
Para colocar um valor dentro de cada caixa, temos que abrir (chamar pelo nome e número) e colocar o valor dentro, desse modo:

vetor1[4]:=10;

Isso quer dizer que dentro da caixa número 4, foi colocado o valor 10.

Então, o comando fica assim:

nomedovetor[índice]:=valor;

Desse modo, para colocar qualquer valor em alguma caixa, precisamos abrir essa caixa que tem um nome e um número, ou seja, um endereço.
De acordo com o exemplo, podemos recuperar um valor (já armazenado) chamando pelo nome (como se fosse uma variável comum).
No exemplo abaixo, quero somar 12 ao valor da caixa 4:

vetor1[4]:=vetor1[4]+12;

Ou seja, o novo valor da caixa 4 (vetor1[4]) é a soma do valor antigo (vetor1[4])) com 12, o que resultará em 22.
 

A partir de agora, vamos fazer as operações do mesmo modo como fazíamos com variáveis normais, mas com um detalhe: temos que usar um índice para cada parte (caixa) desse vetor.

Assim, ao trabalhar com o vetor, o índice (número da caixa) vai variar de um em um (de acordo com a necessidade), o que nos permite usar um "FOR".
Por exemplo, quero imprimir na tela todos os valores do vetor:

Supondo que:

Comandos:

for ind:=1 to 10 do
       writeln(vetor1[ind]);

Explicação: o comando "FOR" é um comando de repetição que, inicialmente, dá ao "ind" o valor 1 e a cada execução aumenta seu valor em 1 unidade.
Seguindo a sequência, o writeln imprime na tela o valor do vetor1[1], que vale 3.
Na sequência, a execução volta e altera o valor de "ind" para 2, fazendo com que o valor a ser impresso seja o que está contido em vetor1[2], que é 5.
Veja que o valor do índice varia de 1 até 10, ou seja, todos os valores do vetor serão impressos.

Lembre-se que toda operação a ser feita com um vetor, obrigatoriamente devemos chamá-lo pelo nome e índice.

2.Matriz

Uma matriz diferencia-se de uma array por ter dois índices.

Exemplo: 

 

Declaração:

var
      mat1: array [1..3,1..10] of integer;

Nossa matriz chama-se "mat1", com o primeiro índice variando de 1 a 3 e o segundo índice variando de 1 a 10, podendo armazenar valores inteiros. (Obs: é possível declarar uma matriz ou mesmo vetor para outros tipos de variáveis, inclusive letras e caracteres especiais)

Todas as operações com uma matriz são semelhantes às operações com vetores, porém, devemos utilizar dois comandos "for". O primeiro varia a linha da matriz e o segundo varia a coluna:

for lin:=1 to 3 do
     for col:=1 to 10 do
         ...

Supondo que queremos ler do teclado todos os valores dessa matriz, temos:

for lin:=1 to 3 do
     for col:=1 to 10 do
          readln(mat1[lin,col]);

Assim, na primeira execução, lin=1 e col=1, ou seja, estamos trabalhando em mat1[1,1], em azul:

Depois da coluna variar até 10, ela volta a valer 1, mas com a linha valendo 2:

Até que linha=3 e coluna=10 (lin:=3 e col:=10):

Portando, foram armazenados valores em todos as "caixas" da matriz.

Para imprimir na tela usamos os comandos:

for lin:=1 to 3 do
   for col:=1 to 10 do
      writeln(mat1[lin,col]);

Conclusão: com o exemplo do vetor, economizamos tempo declarando 10 variáves de uma só vez. Com a matriz, declaramos trinta variáveis de uma só vez também.

Exemplos:

Vetor

01 program vetor;
02 uses crt;
03 var
04       vet1: array [1..10] of integer;
05       ind: integer;
06 begin
07       writeln('Leitura do vetor:');
08       for ind:=1 to 10 do
09             readln(vet1[ind]);
10       clrscr;
11       writeln('Impressão do vetor:');
12       for ind:=1 to 10 do
13             writeln(vet1[ind]);
14 end.

Explicação:

Linha 4: Declaração do vetor (o vetor tem nome vet1, com índice mínimo 1 e máximo 10, e receberá valores inteiros).
Linha 5: Declaração do índice que deve ser inteiro.
Linha 6: Início do programa.
Linha 8: Início do laço de repetição, onde o primeiro valor de ind é 1, que será acrescido de 1 unidade a cada volta desse laço, com o valor de ind na ultima execução igual a 10.
Linha 9: Leitura do valor que será armazenado dentro da "caixa" ind (ind começa valendo 1 e vai até 10).
Linha 10: Limpeza da tela (é sempre bom ser organizado).
Linha 12: Novamente, início do laço que inicialmente coloca ind=1 e a cada execução aumenta 1 unidade em seu valor que vai até 10.
Linha 13: Impressão do valor contido na "caixa" de número ind (o ind vai variar de 1 até 10 de acordo com o comando "FOR" da linha acima).
Linha 14: Fim do programa.

Esse programa leu e armazenou os 10 valores nas caixas numeradas, um a um (abre a caixa 1 e armazena um valor, abre a caixa 2 e armazena outro valor...). Depois, o programa reabriu cada "caixa" e jogou o valor na tela.

Matriz

01 program matriz;
02 uses crt;
03 var
04       mat1: array [1..3,1..10] of integer;
05       lin,col: integer;
06 begin
07       writeln('Leitura da matriz:');
08       for lin:=1 to 3 do
09             for col:=1 to 10 do
10                   readln(mat1[lin,col]);
11       clrscr;
12       writeln('Impressão da matriz:');
13       for lin:=1 to 3 do
14             for col:=1 to 10 do
15                   writeln(mat1[lin,col]);
16 end.

Explicação:

Linha 4: Declaração da matriz, que tem nome mat1, com o primeiro índice valendo de 1 até 3 e o segundo índice valendo de 1 até 10, e que receberá valores inteiros (dentro de cada "caixa").
Linha 5: Declaração dos índices lin e col como inteiros (obrigatório que sejam inteiros).
Linha 8: Início do laço que vai variar a linha de 1 até 3 (valor inicial de lin=1, que será acrescido de 1 unidade a cada volta desse laço)
Linha 9: Início do laço que vai variar a coluna de 1 até 10 (valor inicial de col=1, que será acrescido de 1 unidade a cada volta desse laço). Com a linha valendo 1(do primeiro laço (FOR)), a coluna varia de 1 até dez (do segundo laço), fazendo a leitura de um valor (pelo readln) e armazenando na "caixa lin,col". Isso é feito 10 vezes e daí volta ao laço 1, muda o valor da linha (lin) para 2 e entra novamente no segundo laço com a coluna (col) valendo 1 novamente e fazendo todas as leituras de valores (10 leituras). Isso é feito até que lin=3 (linha) e col=10 (coluna), com um total de 30 valores lidos.
Linha 11: limpa a tela.
Linha 13: Início de um novo laço para variar a linha (lin) de 1 até 3.
Linha 14: Início de outro laço para variar a coluna (col) de 1 até 10. Esses valores de lin e col são usados para identificar a "caixa" a ser aberta, onde o programa pega o valor contido e joga na tela (pelo writeln na linha 15).
Linha 16: fim do programa.

Portanto, esse programa precisa identificar a caixa a ser aberta (pela lin e col), para aí sim jogar um valor dentro. Repare que em três linhas de comando foi possível lar e armazenar trinta valores. Seria como se colocássemos um rótulo em cada caixa, com dois índices impressos nesses rótulos, abríssemos a caixa (devidamente identificada) e jogássemos um valor lá dentro. A única diferença para um vetor, é que temos duas ou mais linhas, ao invés de uma única linha.

Procedures e Functions II

Como o assunto é complicado, vou explicar 2 programas, o primeiro usando uma procedure e o segundo usando um function.

Programa com Procedure

01 program ex1;
02 uses crt;
03 var
04       icol,ilin:integer;
05       stext:string;
06
07 procedure msg;
08 begin
09       clrscr;
10       gotoxy(icol,ilin);
11       write(sText);
12 end;
13
14 begin {programa principal}
15       clrscr;
16       writeln('Digite a coluna e a linha respectivamente:');
17       readln(icol,ilin);
18       writeln('Digite a mensagem:');
19       readln(stext);
20       msg;
21       readkey;
22 end.

Explicação:
Linhas 1 e 2: cabeçalho do programa.
Linhas 3 a 5: declaração das variáveis (globais).
Linha 7: declaração da procedure "msg".
Linha 8: início da procedure "msg".
Linha 9: comando para limpar a tela.
Linha 10: comando que posiciona o cursor na coluna iCol e linha iLin (que serão lidos no programa principal).
Linha 11: comando que imprime na tela o conteúdo de sText (que será lido no programa principal).
Linha 12: fim da procedure.
Linha 14: início do programa principal.
Linha 15: comando para limpar a tela.
Linha 16: comando para imprimir o texto que está entre aspas.
Linha 17: comando que vai ler iCol e iLin respectivamente. Podem ser escritos com um espaço em branco entre os dois valores ou digita-se um valor, aperta ENTER, e digita-se o próximo valor.
Linha 18: comando para imprimir o texto que está entre aspas.
Linha 19: comando que lê a mensagem (ou um conjunto de caracteres posicionados um ao lado do outro).
Linha 20: comando que "chama" a procedure "msg". Esse comando muda a sequência de execução normal (que é linha a linha) e coloca a execução na linha 7. Depois de passar pela linha 12, a execução do programa volta para a linha 21, ou seja, continua de onde parou).
Linha 21: comando que espera uma tecla qualquer para continuar.
Linha 22: fim do programa.

Considerações: Por que usamos uma procedure e não uma function? A procedure não retornou nenhum valor. Nesse caso, ela só serve para imprimir o texto na tela, na posição desejada. Se eu precisasse de um valor obtido depois de fazer uma conta para continuar o programa, usaria uma function, pois o nome da function passa a funcionar como uma "variável" com um valor atribuído a ela.

Programa com Function

01 program ex2;
02 uses crt;
03 var
04       sNome:string;
05       rP1,rP2:real;
06
07 function media(rP1,rP2:real):real;
08 begin
09       media:=(rP1*0.6)+(rP2*0.4);
10       end;
11
12 begin {PP}
13       clrscr;
14       writeln('Digite a nota da Prova 1:');
15       readln(rP1);
16       writeln('Digite a nota da Prova 2:');
17       readln(rP2);
18       writeln(media(rP1,rP2):5:2);
19       readkey;
20 end.

Explicação:

Linhas 1 e 2: cabeçalho do programa.
Linhas 3 a 5: declaração de variáveis globais.
Linha 7: Declaração da function "media". Essa linha diz: o nome da função é media, que será executada utilizando os valores atribuídos para rP1 (prova 1) e rP2 (prova 2), ambos reais e lidos pelo programa principal e retornarão um valor real (números reais).
Linha 8: início da function media.
Linha 9: cálculo da media, com a nota da prova 1 multiplicada pelo peso 0,6 mais a nota da prova 2 multiplicada pelo peso 0,4. Ao final da conta, será atribuído um valor para "media" (que é o nome da função, e que "funcionará" a partir daí como uma "variável").
Linha 10: fim da function.
Linha 12: início do programa principal.
Linhas 14 a 17: impressão do texto e leitura das variáveis: as nota das duas provas.
Linha 18: comando que chama a function "media", levando os valores de rP1 e rP2 para a function. A function então será executada e retornará somente o valor obtido e atribuído para media, que será impresso com 5 casas, sendo 2 depois da vírgula (:5:2). Ao voltar, como tudo está dentro do "writeln", será impresso o valor final, ou seja, a média calculada e formatada.
Linha 20: fim do programa.

Considerações: Observe que a function é chamada, executada, e quando volta para o programa, ela tem um valor. Esse valor foi impresso no fim do programa principal. Não esqueça: eu disse que a função media volta como se fosse uma variável, mas é errado falar que é uma variável pois não podemos atribuir valor a ela pelo programa principal (por exemplo media:=10 - isso não pode ser feito). Ela "funciona" como variável por poder ser chamada pelo seu nome e por poder operar outras variáveis, como por exemplo, se eu precisasse multiplicar uma variável X pela média.

Portanto, essa é a diferença entre procedure e function. A function tem um valor de retorno, que não necessariamente precisa ser numerica, mas pode ser string, char, boolean, etc, enquanto que a procedure faz um procedimento qualquer sem precisar retornar algo para o programa (pode imprimir algo na tela, ou mandar para a impressora, etc).

Qualquer dúvida, postar como comentário ou enviar por e-mail.

Procedures e Functions I (PASCAL)

Definição:

Uma das técnicas mais utilizadas e tida como vantajosa na confecção de programas grandes é a modularização. Consiste em dividir o programa em diversos módulos ou subprogramas, de certa forma dependentes uns dos outros. Existe um módulo que é o principal, a partir do qual são chamados os outros módulos. Esse módulo principal recebe o nome de programa principal, enquanto que os outros são chamados de subprogramas. No Pascal, existem dois tipos de subprogramas:
- Procedures (procedimentos)
- Functions (funções)

Procedure:
A procedure é como se fosse um programa. Ela tem a estrutura praticamente igual a de um programa. Ela deve ser ativada (chamada) pelo programa principal ou por uma outra procedure, ou até por ela mesma. Ela contém um cabeçalho, área de declarações e o corpo da procedure. Devemos lembrar que tudo que for declarado dentro das sub-áreas só será reconhecido dentro da procedure.
Todos os elementos (constantes, variáveis, etc.) que forem definidos antes de começar o corpo do programa, são considerados globais e podem ser utilizados por todas as procedures, functions e o próprio programa. O espaço para tais elementos é criado durante a compilação. Já os elementos declarados dentro de uma procedure, só existem dentro da procedure, exemplo: ao declararmos uma variável dentro de uma procedure, toda vez que ativarmos a procedure, tal variável será criada e ao sairmos da procedure ela será destruída.
Quando estivermos dentro do programa, teremos acesso à variável global e quando estivermos dentro da procedure, teremos acesso à variável local.

Exemplo:

Program Exemplo_1; {cabeçalho do programa}
uses crt;
procedure testando; {cabeçalho da procedure testando}
var {sub-área Var da procedure testando}
begin
   ...{corpo da procedure testando}
end; {fim do corpo da procedure testando}

var {declaração de variáveis do programa principal}
begin {início do porgrama principal}
   ...
   testando; {procedure sendo chamada pelo programa}
   ...
end. {fim do programa principal}

Function:
As funções são muito parecidas com as procedures. A principal diferença é que o identificador de uma função assume o valor de retorno da função (ou seja, essa função fará um determinado cálculo e retornará ao programa principal tendo um valor armazenado que foi calculado dentro dessa função) . Uma função deve sempre retornar um valor e em Turbo Pascal, este valor é retornado no nome da função.
A declaração de uma função é muito parecida com de uma procedure que por sua vez é parecida com a de um programa:

Exemplo:

Program Exemplo_2;
uses crt;
Function Nome_da_função(parâmetros) : Tipo_da_função; {cabeçalho da função}
var {declaração de variáveis da função}
begin
   ... {corpo da função}
end;

var {declaração das variáveis do programa principal (caso queira usar as mesmas variáveis para o programa e para a função, tem que declarar antes da function}

begin {início do programa principal}
   ...
   rTotal:=Nome_da_função(parametros); {function sendo chamada e atribuindo o valor calculado para rTotal}
   ...
end.

A formação do nome da função deve seguir as mesmas regras para formação de identificadores em Turbo Pascal. Dentro dos parênteses devemos declarar os parâmetros (variáveis a serem utilizadas) e seus respectivos tipos dos quais a função depende (real, integer, etc). O tipo de valor retornado pela função também deve ser declarado (real, integer, etc).
Na área de declarações, podemos declarar labels, constantes, variáveis e até mesmo Procedures e Functions. Devemos lembrar que tais elementos só poderão ser utilizados dentro do corpo da função, pois são locais a ela.

Importante: na hora de "chamar"a function, é necessário que o programa já tenha os valores (parãmetros) já lidos ou definidos peolo programa principal.

Exemplo:

program exemplo_3;
uses crt;
var
   res,a,b:real; {essas variáveis do programa principal podem ser usadas pela function, por isso, nesse caso, não precisa declará-las novamente dentro da function}

function soma(a,b:real):real; {essa linha diz que a function chama-se soma, e vai utilizar duas variáveis: a e b, que são reais. O resultado obtido também será real}

begin
   soma:=a+b; {cálculo do valor "soma"}
end;

begin {inicio do programa principal}
   readln(a);
   readln(b);
   res:=soma(a,b); {a variável res vai receber o valor calculado pela function soma, que vai somar a e b}
   writeln(res);
end. {fim do programa}

Pascal

Com o fim do MS-DOS, será necessário instalar o DOSBox que é um emulador do MS-DOS para poder rodar o Turbo Pascal em linha de comando.
Funciona no Windows XP, Vista, Seven e 10, em 32 ou 64 bits.

Download: Aqui (Clique em Baixar no canto superior direito!)

1. Descompacte o Turbo Pascal, pode ser na área de trabalho (desktop).
2. Descompacte o DOSBox e execute o arquivo para instalar e assim criar um atalho na área de trabalho.

Para abrir o turbo Pascal vá até a pasta BIN (que fica dentro da pasta descompactada do Pascal) e arraste o arquivo TURBO.EXE para cima do atalho do DOSBox que foi criado na área de trabalho.

Para testar, escreva o código abaixo.
exemplo:
----------------------------------------------
program teste1;
begin
  writeln('Olá Mundo!');
end.
----------------------------------------------

1. Clique em Compile ou aperte CTRL+F9.
2. Clique em Debug e depois em User Screen (ou ALT_F5) para exibir a tela da interface onde vão aparecer os resultados da impressão da mensagem feita pelo writeln.
3. ESC para voltar.

Utilidade:
Sobre o MS-DOS (wikipedia).