UNIVERSIDADE EDUARDO MONDLANE

FACULDADE DE ENGENHARIA

DEPARTAMENTO DE ENGENHARIA ELECTROTÉCNICA

Curso: Engenharia Informática (PL)

2º Ano

Cadeira: Linguagens de programação

2º Grupo

Tema 2: Arrays

Discentes: Docentes:

Cossa, Amina Alberto dr. Benildo Joaquim

Das Neves, António

Nhantumbo, Amelia da Sonia

Mucumbe, Blandino

Ramijane, Juvenaldo Andrade

Maputo, Maio de 2016

Índice
1. Introdução..................................................................................................................1
2. Objectivos..................................................................................................................2
2.1. Objectivo geral....................................................................................................2
2.2. Objectivo específicos..........................................................................................2
3. Metodologia...............................................................................................................3
4. Arrays.........................................................................................................................4
4.1. Arrays Unidimensionais.....................................................................................4
4.2. Arrays multidimensionais ou matrizes...............................................................7
5. Conclusão...................................................................................................................9
6. Bibliografia..............................................................................................................10
1. Introdução
A linguagem de programação Pascal fornece-nos uma estrutura de dados chamada a
arrays, que pode armazenar um conjunto de dados de Tamanho Fixo, em colecção
sequêncial de elementos do mesmo tipo. Um array é utilizado para armazenar um
conjunto de dados, mas muitas vezes é mais útil pensar em um array como um conjunto
de variáveis do mesmo tipo.

O programador não terá que se preocupar com o endereço de memória onde fica cada
elemento do array, pois acesso de um dado elemento será feito através de índices.

Podemos alocar memória para vários arrays do mesmo tipo com uma única declaração
ao em vez de declarar variáveis individuais como número1, número2, ..., e número100.

1
2. Objectivos
Para realização do presente trabalho tem-se os seguintes objectivos:
2.1. Objectivo geral
 Armazenar um conjunto de dados de Tamanho Fixo, em colecção sequêncial de
elementos do mesmo tipo.
2.2. Objectivo específicos
 Estudo de arrays em linguagem de programação Pascal;
 Arrays Unidimensionais e Bidimensionais.

2
3. Metodologia
Para a concretização do presente trabalho, a principio, usou-se como metodologia a
pesquisa em sites de internet, entretanto surgiram várias dificuldades devido a
contradição entre as paginas consultadas porém, introduziu-se uma nova fonte de
pesquisa para o trabalho, a qual serviu não só como fonte mas também como modelo de
pesquisa em outras fontes bibliográficas e bem como em algumas paginas de internet.

3
4. Arrays
Em sua forma elementar, o array é utilizado para armazenar, sob um mesmo nome de
variável, uma quantidade fixa de elementos do mesmo tipo. Por isto, o array também é
conhecido como um arranjo homogêneo.

Com a utilização de arrays o computador consegue dispor os bytes que representam os

valores das posições do array sequencialmente na memória, optimizando a sua gestão
pelo sistema operativo. Quando declaramos um array precisamos definir seu tamanho
(quantos elementos irão compor o array).
Por restrição dos tipos enumeráveis, os valores devem ser do tipo ordinal e conhecidos
em tempo de compilação. Os casos mais comuns de arrays são de uma e de duas
dimensões, embora possam ser declaradas com dimensões maiores. As de uma única
dimensão são costumeiramente denominadas vectores, as de duas dimensões são
chamadas de matrizes propriamente ditas.

4.1. Arrays Unidimensionais

São vectores ou conjuntos de elementos que podem ser identificados pelo seu nome e
apenas um índice. Este tipo de estrutura é também chamado de matriz unidimensional.
Um vector ou mesmo um array, é representado por seu nome, tamanho e seu tipo.

Sintaxe:
<array> : array [tamanho] of <tipo_de_dado>;
Onde o <array> é o nome atribuído ao array, tamanho é o tamanho atribuído ao array,
em número de elementos e tipo_de_dado é o tipo de elemento armazenado (inteiro,
real...).

Como vimos, uma variável somente pode conter um valor por vez. No caso dos arrays,
estes poderão armazenar mais de um valor por vez, pois são dimensionados
exactamente para este fim.
Em função do tamanho do array, todo o espaço necessário para armazená-lo é reservado
pelo programa quando o mesmo entra em execução. Em linguagem Pascal, o comando
array é utilizado para definir uma variável estruturada com valores homogêneos.
Exemplo de como poderíamos declarar um array para armazenar cinco valores:

4
num : array[1..5] of real;
A leitura e exibição de arrays são feitas indicando individualmente quais elementos se
deseja ler ou imprimir e como um exemplo prático de um programa com a utilização de
arrays unidimensionais em Pascal teremos:
var
diasDaSemana : array[1..7] of string;
i : integer;
Begin
diasDaSemana[1] := ‘dom’;
diasDaSemana[2] := ‘seg’;
diasDaSemana[3] := ‘ter’;
diasDaSemana[4]:= ‘qua’;
diasDaSemana[5] := ‘qui’;
diasDaSemana[6] := ‘sex’;
diasDaSemana[7] := ‘sab’;
for i := 1 to 7 do
writeln(diasDaSemana[i]);
End

Vejamos também como inserir nomes e as notas de alunos:

var
notas : array[1..5] of real;
nomes: array[1..5] of string;
i : integer;
Begin
nomes[1]:= ’João’;
nomes[2]:=’António’;
nomes[3]:=’Almeida’;
nomes[4]:=’Ferreira’;
nomes[5]:=’Santos’;
notas [1] := 5.2;
notas [2] := 8.0;
notas [3] := 9.2;
notas [4] := 7.5;

5
 notas [5] := 8.3;
writeln(‘Nomes e Notas dos Alunos: ’);
for i:=1 to 5 do
begin
write (nomes[i],’-’);
writeln(notas[i]);
end;
End.

O nome ou a variável é uma só, o que muda é a informação indicada dentro dos
parenteses rectos. A esta informação dá-se o nome de índice, sendo este o endereço
onde o valor está armazenado. Podemos ilustrar o array como uma tabela com cinco
colunas:

1 2 3 4 5
nomes João António Almeida Ferreira Santos
notas 5.2 8.0 9.2 7.5 8.3

Um outro exemplo de arrays inserindo os dados via teclado:

var
l: Integer;
nomes: array [1..10] of string;
Begin
For l := 1 to 10 do
Begin
Write ('Digite nome ',l, ' : ');
Read (nomes [l]);
End;
For L := 1 to 10 do
Begin
Writeln (nomes [l]);
End;
End.

6
4.2. Arrays multidimensionais ou matrizes
Para os arrays unidimensionais cada elemento é acedido através de um índice enquanto,
para cada elemento do array multidimensional pode ser acedido através de dois ou mais
índices. A forma mais simples da matriz multidimensional é a matriz bidimensional.
Uma matriz bidimensional é, em essência, uma lista de matrizes unidimensionais onde
teremos um índice que indica a linha e outro a coluna.

Como forma de aceder aos elementos do array, deve se utilizar dois ciclos for um
dentro do outro. O primeiro serve para fazer várias linhas e o segundo para fazer várias
colunas.
Quando declaramos um array multidimensional também precisamos definir seu
tamanho (quantos elementos irão compor o array em linhas e colunas).
Uma matriz ou array de duas dimensões estará sempre fazendo menção a linhas e
colunas e será representada por seu nome e seu tamanho.
Sintaxe:
<array> : array [tamanho_de_linhas, tamanho_de_colunas] of <tipo_de_dado>;

Exemplo: Ler 6 valores em uma matriz de 2 linhas e 3 colunas e depois disto emitir a
soma dos valores. 
var
m: array[1..2,1..3] of integer;
soma, contl, contc: integer;
Begin
writeln('Digite os 6 valores');
soma := 0;
for contl := 1 to 2 do
for contc:=1 to 3 do
readln(m[contl,contc]);
for contl:=1 to 2 do
for contc:=1 to 3 do
soma := soma + m[contl,contc];
writeln('Soma=',soma);

7
End.

Um outro exemplo concreto de arrays bidimensionais que preenche valores através de

um ciclo numa matriz quadrada:
var
a: array [0..3, 0..3] of integer;
i,j : integer;
Begin
for i:=0 to 3 do
for j:=0 to 3 do
a[i,j]:= i * j;
for i:=0 to 3 do
begin
for j:=0 to 3 do
write(a[i,j]:2,' ');
writeln;
end;
End.

Podemos ilustrar o array bidimensional também como uma tabela ou matriz de 3 (três)
linhas e 3 (três) colunas:
COLUNAS

1 2 3
4 5 6
7 8 9

LINHAS

8
Tal como explicado acima, pode se ter matrizes com qualquer número de dimensões,
embora seja provável que a maior parte das matrizes criada será de uma ou duas
dimensões.

9
5. Conclusão
Array é uma das estruturas de dados mais simples que existe e uma das mais utilizadas
também. Conclui-se que todas as linguagens de programação têm arrays, porém, os
índices podem mudar dependendo da linguagem, algumas começam os índices do array
com 1 e outras com 0, essa é a grande diferença que geralmente encontramos entre
linguagens. No caso das linguagens que começam os arrays com o índice 0, o último
elemento do array recebe o índice (<tamanho do array> – 1).

10
6. Bibliografia
MECLER, Ian; MAIA, Luiz Paulo. (1989) Programação e lógica com Turbo Pascal. Rio
de Janeiro: Campus.

CASTILHO, Marcos; GOMES, Everaldo; GONÇALVES JÚNIOR, José Ivan; DOS

SANTOS, Loirto Alves; KULTZ, Rene; KRYNSKI, Eleandro Maschio. Guia rápido de
referência da linguagem Pascal (Dezembro de 2009) (Versão Free Pascal) tirado do site
http://www.inf.ufpr.br – 01/05/2016 as 10:28min.

11