INSTITUTO DE INFORMÁTICA

Universidade Federal de Goiás

Tipo de Dados
Linguagens e Paradigmas de Programação

Prof Bruno Silvestre

brunoos@inf.ufg.br
Introdução
● Um tipo de dado define uma coleção de valores e um conjunto pré-
definido de operações sobre esses valores
● A facilidade de manipular dados pode ser determinado pela facilidade
que os tipos de dados têm em expressar os problemas reais
● ALGOL 68 introduziu a abordagem de poucos tipos básicos que
podem ser usados para criar novas estruturas
○ Desenvolvedor podia finalmente criar seus tipos

● Avançando mais na definição de tipos, chegamos nos Tipos Abstratos

de Dados

2
Introdução
● Podemos ter então:
○ Primitivos (Exemplo: ???)
○ Estruturados (Exemplo: ???)

● Sistema de tipos de uma linguagem define como um tipo é associado

com cada expressão e regras de equivalência e compatibilidade
● Sistema de tipos ajuda na detecção de erros, modularidade e
documentação

3
Introdução
● Podemos ter então:
○ Primitivos (integer, real, boolean, ...)
○ Estruturados (array, struct, union, object, ...)

● Sistema de tipos de uma linguagem define como um tipo é associado

com cada expressão e regras de equivalência e compatibilidade
● Sistema de tipos ajuda na detecção de erros, modularidade e
documentação

4
Tipos Primitivos

5
Tipos Primitivos

● Tipos que não são definidos em termos de outros tipos

● Alguns refletem o hardware, outros já oferecem suporte a
abstrações de mais alto nível
● Tipos de dados primitivos são usados juntamente com
construtores de tipos para fornecer os tipos estruturados
○ Exemplo: struct ou classes usam tipos primitivos para montar
novos tipos de dados

6
 ● Inteiro
● Ponto-flutuante
Tipos
Primitivos ● Booleano
● Caractere
● Decimal
● Complexo

7
Tipos Primitivos de C
Tipo Tamanho Faixa de Valor
char 1 byte -128 a 127 ou 0 a 255
unsigned char 1 byte 0 a 255
signed char 1 byte -128 a 127
short 2 bytes -32.768 a 32.767
unsigned short 2 bytes 0 a 65.535
int 4 bytes -2.147.483.648 a 2.147.483.647
unsigned int 4 bytes 0 a 4.294.967.295
long 4 ou 8 bytes
unsigned long 4 ou 8 bytes
-9.223.372.036.854.775.808 a
long long 8 bytes
9.223.372.036.854.775.807
unsigned long long 8 bytes 0 a 18.446.744.073.709.551.615
float 4 byte 1.2E-38 a 3.4E+38
double 8 byte 2.3E-308 a 1.7E+308

8
Tipo String

● Valor consiste de uma sequência de caracteres

● Questões de projeto:
○ Strings devem ser um tipo especial de array ou um tipo primitivo?
○ Strings devem ter tamanho estático ou dinâmico?

9
Tipo String

● C/C++ usando array de char para armazenar strings

● Manipulação por strcpy, strcmp, strdup, strlen

● Unsafe: fonte de bugs e explorado por hackers

● Uso do terminador nulo ( '\0' ou 0 ou 0x0 ou 00)

● C++ disponibiliza a classe string no STL

10
Tipo String
● Java tem a classe String imutável e StringBuffer mutável
● Em Python, string é tipo primitivo (imutável), mas pode-se
usar a notação “[ ]” para acessar caracteres (visão de array
de caracteres)

str = "foo bar baz"

print str[1]

# ERRO!
str[3] = ","

11
Operações com Strings
● Operações comuns: concatenação, atribuição, substring,
comparação e casamento de padrão
● Substrings → slices
● Problema geralmente com atribuição e comparação
○ Comparação varre toda a string?
○ Atribuição copia uma string sobre a outra?
■ E se as strings são de tamanhos diferentes?

12
Operações com Strings

● Perl, JavaScript, Ruby e PHP oferecem construções

built-in para operações com casamento de padrões
○ Também conhecidas como expressões regulares

● Exemplo:
○ /\d+\.?\d*|\.\d+/
○ /^[\w][\w\.-]*[\w]@[\w][\w\.-]*[\w]\.[a-zA-Z][a-zA-Z\.]*[a-zA-Z]$/

13
Operações com Strings

sub valid
{
my $digit = @_[0];
if ($digit =~ /\d+\.?\d*|\.\d+/) {
print "Valid digit: $digit \n";
}
}

valid("8.847");
valid(".9843");
valid("84737");
valid("8.8.47");
14
Padrão?
(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \
000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\
["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\
n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\
n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\
031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:
[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \
t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:
(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|
(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:
(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+
(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\
["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.
(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\
n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\
r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \
t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \
t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|
(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:
[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\
n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[\t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \
t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \
t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\]
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\
["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:
(?:\r\n)?[ \t])*))*)?;\s*)

15
Tamanho da String
● Tamanho estático
○ Tamanho é especificado na criação e não muda

○ Exemplo: Python, Java, Ruby, C#, Lua

● Tamanho dinâmico limitado

○ String pode variar até um tamanho máximo

○ Exemplo: C

● Tamanho dinâmico
○ Sem limite

○ Exemplo: JavaScript, Perl e C++ (classe “string”)

16
Tipo String

● Custo atual de manipulação de string não justifica a ausência de um

tipo básico string

● Tratar uma string como um array pode ser incômodo em relação a

tratá-la como um tipo primitivo
○ “strcpy(a, b)” VS “a = b”

○ “a.equals(b)” VS “a == b”

17
Tipos Ordinais

18
Tipos Ordinais Definidos pelo Usuário

● Tipos ordinais são aqueles cujos valores podem ser

associados com um conjunto de números positivos
○ Enumeração
○ Subfaixa

19
Enumeração

● Os valores da enumeração são conhecidos como

constantes da enumeração
○ enum days {Mon, Tue, Wed, Thu, Fri, Sat, Sun}

● Tipicamente são associados valores de 0, 1, 2,... de

forma implícita aos nomes

20
Enumeração
● Contribuem para legibilidade e confiabilidade
○ int red = 0, blue = 1; // Não fazer!
○ enum colors {red, blue, green};

○ int mycolor = red; // C

○ colors mycolor = red; // C++
○ mycolor++; // C++ → erro, C → ok

○ mycolor = (colors)1; // C++ → ok

21
Enumeração
● Enumerações em Java são subclasses de Enum
● Por ser uma classe:
public enum Fruta {
○ Pode ter construtor Banana, Maca, Pera;
○ Pode ter métodos
○ Pode ter atributos private int value;

Fruta() { value = 123; }

public enum Fruta { Banana, Maçã, Pera; }
public int getValue() {
Fruta f; return value;
f = Fruta.Maçã; }
}
22
Tipo Subfaixa

● É uma subsequência contínua de um tipo ordinal

● Incluídos em Pascal e Ada
○ type Days is (Mon, Tue, Wed, Thu, Fri, Sat, Sun);
○ subtype Weekdays is Days range Mon..Fri;
○ subtype Index is Integer range 1..100;

● Compilador deve gerar uma verificação para cada

atribuição em tempo de execução.

23
Array

24
Tipo Array
● Agregado homogêneo de elementos de dados
● Todo elemento de um array é do mesmo tipo
○ int vet[10];
○ Person people[20];

...

25
Array e Índices
● Uma referência a um elemento de array em um programa inclui
um ou mais subscritos, os quais determinam a localização

● Sintaxe das referências a arrays é “universal”

○ base[ i ][ j ][ k ]...[ z ]

○ Algumas linguagens usam “( )” em vez de “[ ]”

● Algumas linguagens fazem verificação da faixa

26
Array e Índices
● Índices geralmente são faixas de inteiros
● Ada permite qualquer tipo ordinal como índice
○ boolean, caractere, enumeração
○ Permite definir o intervalo do índice (além do tipo)

type Week_Day_Type is (Mon, Tue, Wed, Thu, Fri);

type Sales is array (Week_Day_Type) of Float;

27
Array e Índices

● Perl permite índices negativos

○ Ordem inversa

@list = ( 'A', 'B', 'C', 'D', 'E' );

if ( $list[-2] == $list[3] ) {
print 'ok';
}

28
Categorias de Arrays

● Array estático
● Array pilha­-dinâmico fixo
● Array pilha­-dinâmico
● Array heap-­dinâmico fixo
● Array heap­-dinâmico

29
 Layout
de
Memória

30
Array Estático
● Faixas de subscrito são estaticamente amarradas e a
alocação de armazenamento é estática.

● Vantagem: eficiência (sem alocação dinâmica)

● Desvantagem: ativo durante todo o programa

int vet[10];

int main() {
...
}

31
Array Pilha­-dinâmico Fixo
● Faixas de subscrito são estaticamente amarradas e a
alocação de armazenamento é feita na execução

● Vantagem: eficiência quanto ao espaço

● Desvantagem: tempo de alocação

int main() {
int vet[10];
...
}

32
Array Pilha-­dinâmico (1)
● Faixas de subscrito são dinamicamente amarradas e a alocação de
armazenamento é dinâmica

● Vantagem: flexibilidade no tamanho

● Desvantagem: tempo de alocação

Pascal C99
procedure MyArray (N : Integer) is void myarray(int n) {
Vals : array (1 .. N) of Integer; int i;
begin int vet[n];

end MyArray; }
33
Array Pilha-­dinâmico (2)
● Faixas de subscrito são dinamicamente amarradas e a alocação de
armazenamento é dinâmica

● Vantagem: flexibilidade no tamanho

● Desvantagem: tempo de alocação

C#
void DeclareStackBasedArraySafe(int size) {
Span<int> stackArray = stackalloc int[size];

stackArray[0] = 123;
}
34
Array Heap-­dinâmico Fixo
● Amarração das faixas de subscrito e de
alocação de armazenamento é dinâmica,
// C
mas não podem variar durante a int *vet = (int*) malloc(size);
execução
// C++
● Vantagem: flexibilidade de criar arrays int *vet = new int[size];
não temporários

● Desvantagem: tempo de alocação

35
Array Heap-­dinâmico
● Amarração das faixas de subscrito e de
alocação de armazenamento é dinâmica e
pode mudar qualquer número de vezes
durante o seu tempo de vida // Java
ArrayList a = new ArrayList();
● Vantagem: possibilidade de variar o a.add(obj);
tamanho do array

● Desvantagem: tempo de alocação

36
Quem é Quem?
● Array estático int main() {
int vet[10];
● Array pilha­-dinâmico fixo }

● Array pilha­-dinâmico
ArrayList a = new ArrayList();
● Array heap-­dinâmico fixo
● Array heap­-dinâmico int vet[10];
int main() { ... }
void func(int n) {
int *vet = (int*) malloc(size);
char str[n];
} 37
Inicialização de Arrays
● Linguagens permitem a inicialização durante a alocação

● C, C++, Java, C# → int list [ ] = {4, 5, 7, 83}

● String em C/C++ → char name[ ] = “Frederico”;
● Arrays de strings em C/C++ → char *names[ ] = {“A”, “B”};
● Inicialização de string em Java → String[ ] names = {“A”, “B”};

38
Inicialização de Arrays
● Python: list comprehensions
○ [ expr for var in array ]
○ [ expr for var in array if condition ]
● Exemplo
○ v = [0,1,2,3,4,5,6,7,8,9]
○ w = [x*x for x in v if x%3 == 0]
○ Resultado → w = [0, 9, 36, 81]

39
Inicialização de Arrays
● Exemplo
○ v = [9, 36, 81, 121]
○ w=[ expressão? ]
○ Resultado → w = [3, 6, 9, 11]

40
Array: Implementação
● Compilador deve gerar código para acesso em tempo de
execução
○ list[k] → deve ser gerado endereço de memória

● Como array usa memória adjacente

addr(list[k]) = addr(list[0]) + (k * sizeof(tipo))
● Linguagens que verificam os limites do array devem manter
essa informação durante a execução do programa

41
Array: Implementação

● Array multidimensionais 3 4 7

○ Ordem de linhas: C 6 2 5
1 3 8
○ Ordem de colunas: Fortran

42
Array: Ordem de Linha
● Armazenamento na memória é linear
● Endereço do array multidimensional em ordem de linha,
com índice começando em zero
○ Exemplo: matriz de int em C

0 1 2
Memória
0 3 4 7
100 104 108 112 116 120 124 128 132
1 6 2 5 3 4 7 6 2 5 1 3 8

2 1 3 8

43
Array: Cálculo da Posição
● Ordem de linha (estilo C)

addr(m[i,j]) = addr(m[0,0])
+ (i * ncols * sizeof(tipo))
+ (j * sizeof(tipo))

0 1 2
Memória
0 3 4 7
100 104 108 112 116 120 124 128 132
1 6 2 5 3 4 7 6 2 5 1 3 8

2 1 3 8

44
Array: Ordem de Coluna
● Armazenamento na memória é linear
● Endereço do array multidimensional em ordem de coluna,
com índice começando em zero
○ Exemplo: matriz de inteiro em Fortran

0 1 2
Memória
0 3 4 7
100 104 108 112 116 120 124 128 132
1 6 2 5 3 6 1 4 2 3 7 5 8

2 1 3 8

45
Array Associativo
● Um conjunto não-ordenado de dados acessado por uma chave
○ Perl → hashes

○ Lua → tabelas

○ Python → dicionários

● Geralmente são usadas funções hash

● Cada elemento no array é de fato um par (chave,valor)
○ Chave também deve ser armazenada

46
Array Associativo
● Um conjunto não-ordenado de dados acessado por uma chave
○ Perl → hashes

○ Lua → tabelas

○ Python → dicionários

● Exemplo:
○ person = { name = “Joao”, age = 45, address = { street = “Av Xyz” } }

○ age = person[“age”]

○ name = person[“name”]

47
Resumo
● Introdução
● Tipos primitivos
○ Inteiros, FP, booleanos, caractere, string, complexo, decimal

● Tipos Ordinais
● Array

48