Variáveis indexadas

Variáveis indexadas

• Uma variável indexada (ou vector, array) é um agregado de valores todos dum mesmo tipo
• Os valores (elementos) podem ser acedidos por índices

Variáveis indexadas

• A forma mais simples de variável indexada tem apenas uma dimensão
• Exemplo: declarar uma variável indexada com 4 elementos
  
  int a[4];
  
  \(\begin{array}{|c|c|c|c|} \hline \texttt{a[0]} & \texttt{a[1]} & \texttt{a[2]} & \texttt{a[3]} \\ \hline \end{array}\)
  
  
• Todos os elementos são do mesmo tipo (neste caso int)
• O índice do primeiro elemento é 0
• O índice do último é o número de elementos menos 1

Declarações

• O tamanho duma variável indexada deve ser uma constante inteira positiva:

   int a[4], b[5];

• Podemos usar macros para melhorar a legibilidade e facilitar modificações do programa:

   #define SIZE 10
   ...
   
   int a[SIZE], b[SIZE+1];

Indexação

• Acedemos a um elemento com a[i]
  • i é o índice (inteiro)
• a[i] pode ser usado tal como uma variável simples:
  • numa expressão;
  • no lado esquerdo de uma atribuição;
  • com operadores de incremento; etc.

   a[i] = 1;
   printf("%d", a[i]);
   ++ a[i];

Indexação

• Os ciclos for são convenientes para processar elementos de variáveis indexadas
• Exemplos com uma variável indexada de tamanho N:

for(i = 0; i < N; i++) // Colocar zeros
    a[i] = 0;

for(i = 0; i < N; i++) // Ler valores
   scanf("%d", &a[i]);

soma = 0;
for(i = 0; i < N; i++) // Somar elementos
    soma += a[i];

Índices válidos

• A linguagem C não faz verificação dos índices de variáveis indexadas
• Isto permite que a implementação seja o mais eficiente possível
• Mas se programa aceder a índices inválidos, o comportamento é indefinido: - pode terminar abruptamente - pode não terminar - pode dar resultados errados
• Erro comum: aceder ao elemento a[N] duma variável com tamanho N

Onde está o erro?

int main(void) {
   int a[10], i;
   
   for(i = 0; i <= 10; i++)
       a[i] = 0;
   ...
}

Indexação

• Podemos usar expressões como índices (desde que o seu valor seja inteiro):

  a[i+j*10] = 0;

• Podemos também usar expressões com efeitos colaterais (e.g. incrementos):

  i = 0;
  while (i < N)
     a[i++] = 0;

Inicialização

• Tal como as variáveis simples, podemos inicializar as variáveis indexadas na declaração
• A inicialização mais comum é com uma lista de valores (entre chavetas e separados por vírgulas):

   int a[5] = {1, 2, 3, 4, 5};

Inicialização

• Se a lista de valores for mais curta do que a variável, os restantes elementos são preenchidos com zeros

   int a[10] = {1, 2, 3, 4, 5};
     /* valores iniciais são
        {1, 2, 3, 4, 5, 0, 0, 0, 0, 0} */

• Isto é útil para inicializar todos os elementos com zero:

   int a[10] = {0};
     /* valores iniciais são
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}

Inicialização

• Podemos omitir o tamanho da variável; nesse caso o compilador infere o tamanho pela lista de valores

   int a[] = {1, 2, 3, 4, 5};
      // equivalente a declarar a[5]

Cuidados com efeitos colaterais

Qual o problema?

i = 0;
while (i < N)
   a[i] = b[i++];

Cuidados com efeitos colaterais

Evitamos o problema separando o incremento da indexação.

i = 0;
while (i < N) {
    a[i] = b[i];
    i++;
}

Em alternativa podemos usar um ciclo for:

for (i = 0; i < N; i++)
    a[i] = b[i];

Exemplo: escrever dígitos binários

• Converter um inteiro positivo para binário
• Semelhante ao exercício 4.8 das folhas mas escrevendo os algarismos do mais significativo para o menos significativo

Exemplos

Ideia do algoritmo

• Efectuar divisões sucessivas por 2
• Guardar os restos numa variável indexada (são os algarismos binários)
• No final imprimir os restos por ordem inversa

Variáveis

#include <stdio.h>
#define NUM_BITS 32  // número máximo de bits

int main(void) {
  unsigned n, size, bit[NUM_BITS] = {0};
  scanf("%u", &n);  // inteiro sem sinal
  /* obter os algarismos binários */
  size = 0;
  while (n > 0) {
    bit[size++] = n%2;
    n = n/2;
  }
  /* imprimir por ordem contrária */
  while(size > 0) {
    printf("%u", bit[--size]);
  }
  putchar('\n'); // terminar a linha
} 

Observações

• Qual o maior valor para o qual o programa funciona corretamente?
  • NUM_BITS é 32, logo podemos guardar até 32 bits
• O que acontece se o valor lido for zero?
  • o programa imprime apenas uma linha vazia!

Funções e variáveis indexadas

• Podemos passar variáveis indexadas como argumentos a uma função
• Uma função não pode retornar uma variável indexada
  • mais tarde vamos ver que pode retornar um apontador
• Mas a função pode modificar o conteúdo de uma variável indexada passada como argumento

Argumentos de funções

• Quando uma função tem variável indexada como argumento não necessitamos de especificar o seu tamanho:

   int fun(int a[]) {
      //  tamanho de a[] não especificado
      ...
   }

• Contudo, desta forma a função não tem forma de saber o tamanho com que foi declarada da variável indexada
• Se necessitarmos de saber o tamanho dentro da função, temos de o passar explicitamente

Exemplo: somar valores

   int somar_vec(int a[], unsigned size) {
      int i, soma = 0;
      for (i = 0; i < size; i++)
          soma += a[i];
      return soma;
   }

Usar somar_vec

Para usar esta função devemos passar dois argumentos:

• a variável indexada a somar;
• o seu tamanho.

    int v[100];
    ...
    s = somar_vec(v, 100);
    // somar todos os valores:

NB: na chamada passamos apenas o nome da variável (sem parêntesis rectos)

Usar somar_vec

Também podemos usar somar_vec para somar apenas um segmento inicial:

    int v[100];
    // ...
    s = somar_vec(v, 50);
    // somar os primeiros 50 valores

Desta forma podemos:

• declarar a variável com um tamanho máximo
• operar com um tamanho variável (desde que não ultrapasse ao máximo)

Modificar variáveis indexadas

• Se uma função modificar uma variável indexada isso reflete-se no argumento passado
• Exemplo:

void colocar_zeros(int a[], unsigned size) {
    int i;
    for(i = 0; i < size; i++) {
        a[i] = 0;
    }
}

Modificar variáveis indexadas

• Executar colocar_zeros modifica a variável indexada passada como argumento:

    int v[100];
    // ...
    colocar_zeros(v, 100);
    // v[0], v[1], ... v[99] são agora 0

• Isto parece contraditório com o o caso das variáveis simples (passagem por valor)
• Quando estudarmos apontadores veremos a razão deste comportamento

Exemplo revisitado

Vamos rever o exemplo de conversão para binário e decompô-lo em duas funções:

compute_bits

obter os algarismos binários usando divisões sucessivas

print_bits

imprimir os algarismos binários por ordem inversa

Vamos começar pela segunda função.

Função print_bits

void print_bits(unsigned b[], unsigned size) {
    while(size > 0) {
        printf("%u", b[--size]);
    }
    putchar('\n');
}

• O primeiro argumento é a variável indexada com bits (0/1)
• O segundo argumento é o número de elementos da variável indexada
  • pode ser declarada com tamanho máximo superior

Função compute_bits

int compute_bits(unsigned n, unsigned b[]) {
    unsigned size = 0;
    while(n > 0) {
        b[size++] = n%2;
        n = n/2;
    }
    return size;
}

• O primeiro argumento n é o inteiro a decompor
• O segundo argumento é uma variável indexada para preencher com os bits
• O resultado da função é o número de bits usados

Programa principal

#define NUM_BITS 32
...

int main(void) {
    unsigned n, size, bit[NUM_BITS];

    scanf("%d", &n);
      // ler um inteiro; deve ser positivo
    size = compute_bits(n, bit);
      // preencher "array" com algarismos de n
      // valor retornado é o número de bits
    print_bits(bit, size);
      // imprimir algarismos 
}

Pesquisa sequencial

Dados:

• uma variável indexada vec com size valores (e.g. inteiros);
• um valor qualquer val

Queremos:

• testar se val ocorre em vec
• resultado sim/não (1/0)

Pesquisa sequencial (2)

int ocorre(int vec[], int size, int val) {
    for(int i = 0; i < size; i++) {
       if(vec[i] == val)
           return 1; // encontrou
    }
    return 0;    // não encontrou
}

Alternativa

• Retornar o índice e não apenas sim/não
• Podemos usar um índice inválido se não ocorre - e.g. retornar -1 se não ocorre

Pesquisa sequencial (alternativa)

int pesquisa(int vec[], int size, int val) {
    for(int i = 0; i < size; i++) {
       if(vec[i] == val)
           return i; // encontrou
    }
    return -1;    // não encontrou
}

Eliminar repetidos

Dado: uma variável indexada vec de inteiros

Queremos:

• eliminar ocorrências repetidas em vec
• deixar ficar apenas a primeira ocorrência de cada valor

{2, 3, 4}          ->  {2, 3, 4}
{2, 3, 2, 2, 4, 2} ->  {2, 3, 4}
{4, 3, 2, 2, 4}    ->  {4, 3, 2}
{3, 3, 3}          ->  {3}

Eliminar repetidos (2)

• O tamanho da sequência final é sempre menor ou igual ao tamanho da sequência original
• Logo: podemos re-utilizar o espaço da variável indexada original

Eliminar repetidos (3)

Vamos definir uma função

   int elimrep(int vec[], int size);

cujo resultado será o número \(k\) de valores distintos na variável indexada vec.

Além disso, modificamos vec:

• o segmento inicial de \(k\) valores tem todos os valores da sequência sem repetidos;
• os restantes valores não são modificados.

Eliminar repetidos (3)

Exemplo

int a[7] = {2, 3, 3, 2, 4, 3, 5};
k = elimrep(a, 7);
// a[] :  {2, 3, 4, 5, 4, 3, 5}
// k   :  4

Eliminar repetidos (4)

Variáveis

vec

variável indexada para eliminar repetidos

size

tamanho de vec (número de valores)

i

índice do próximo valor (possívelmente repetido)

k

número de valores diferentes já encontrados

Eliminar repetidos (5)

int elimrep(int vec[], int size) {
   int i, k = 0;
   // i: índice do próximo valor 
   // k: número de valores distintos
   for(i = 0; i < size; i++) {
      int val = vec[i];
      if(!ocorre(vec, k, val)) {
           // encontramos um novo valor
           // distinto dos anteriores
         vec[k++] = val;
      }
   }
   return k;
}

Invariantes

\[ \scriptsize \overbrace{\begin{array}{|c|c|c|} \hline \texttt{v[0]} & \cdots & \texttt{v[k-1]} \\ \hline \end{array}}^{\text{sem repetidos}} \overbrace{\begin{array}{|c|c|c|c|c|} \hline \texttt{v[k]} & \cdots &\texttt{v[i]}&\cdots & \texttt{v[size-1]} \\ \hline \end{array}}^{\text{?}} \]

1. A sequência \(\texttt{vec[0]}, \ldots, \texttt{vec[k-1]}\) não tem repetidos
2. O conjunto \[ \{\texttt{vec[0]}, \ldots, \texttt{vec[i-1]}\} \] é igual a \[ \{\texttt{vec[0]}, \ldots, \texttt{vec[k-1]}\} \]