Variáveis multi-dimensionais

• Podemos declarar variáveis com várias dimensões
• Por exemplo, com duas dimensões
  
  int a[3][4]; // uma matriz 3x4
  
  
• Uma tabela com 3 linhas e 4 colunas
• Os índices de linhas e colunas começam em zero \[ \begin{array}{|c|c|c|c|} \hline a[0][0] & a[0][1] & a[0][2] & a[0][3] \\ \hline a[1][0] & a[1][1] & a[1][2] & a[1][3] \\ \hline a[2][0] & a[2][1] & a[2][2] & a[2][3] \\ \hline \end{array} \]

Indexação

• Para aceder ao elemento na linha i e coluna j escrevemos a[i][j]
  • a[i] escolhe a linha i
  • a[i][j] escolhe o elemento j dessa linha
• Atenção: não podemos usar a[i,j]
  • a vírgula avalia o lado esquerdo e dá o resultado do lado direito
  • a[i,j] é equivalente a a[j]

Organização em memória

• Embora visualizemos a matriz como em duas dimensões, a organização em memória é sequencial
• Em C, uma matriz é organizada em memória por linhas: primeiro a linha 0, depois linha 1 e assim sucessivamente

\[ \scriptsize \overbrace{\begin{array}{|cc|} \hline a[0][0] ~\cdots~ a[0][3] \\ \hline \end{array}}^{\text{linha 0}} \scriptsize \overbrace{\begin{array}{|c|} \hline a[1][0] ~\cdots~ a[1][3] \\ \hline \end{array}}^{\text{linha 1}} \scriptsize \overbrace{\begin{array}{|c|} \hline a[2][0] ~\cdots~ a[2][3] \\ \hline \end{array}}^{\text{linha 2}} \]

Processar variáveis multi-dimensionais

• Ciclos for embricados são convenientes para processar variáveis multi-dimensionais
• Exemplo: inicializar a matriz identidade
  • valores 1.0 na diagonal
  • valores 0.0 nas outras posições

Inicializar a matriz identidade

#define N  5
...
double mat[N][N];   // matriz N*N
int i, j;           // linhas e colunas

for (i = 0; i < N; i++) {  // para cada linha
  for(j = 0; j < N; j++) { // para cada coluna
    if(i == j)             // diagonal?
      mat[i][j] = 1.0;
    else
      mat[i][j] = 0.0;
 }
}

Inicializadores

• Ao declarar variáveis multi-dimensionais podemos inicializar com valores por linha

int a[3][4] = { {1,2,3,4},   // linha 0
                {5,6,7,8},   // linha 1
                {9,10,11,12} // linha 2
                };

• Linhas ou valores omitidos são zero:

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

Inicializadores (cont.)

• Podemos ainda omitir as chavetas interiores:

int a[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
  // equivalente a
  // { {1,2,3,4},{5,6,7,8},{9,10,11,12} }

• O compilador preenche os valores por linhas
• Cuidado: valores a mais ou menos alteram a posição dos restantes
• Podemos omitir valores para inicializar com zeros

int a[3][4] = { 0 };
  // inicializa todas as posições com 0

Exemplo: cartas na mão

• Vamos escrever um programa para escolher aleatoriamente uma mão de um jogo de cartas
• O número de cartas a sortear é dado pelo utilizador

Exemplo de execução:

Quantas cartas? 5
5 de PAUS
3 de COPAS
6 de ESPADAS
J de PAUS
10 de PAUS

Problemas

• Como escolher aleatoriamente uma carta?
• Como evitar escolher duas vezes a mesma carta?

Representação das cartas

• Cada carta tem um naipe e um valor
  • 4 naipes (paus, espadas, copas, ouros)
  • 13 valores (2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K, A)
• Vamos representar
  • os naipes por inteiros de 0 a 3
    (0=paus, 1=espadas, 2=copas, 3=ouros)
  • os valores por inteiros de 0 a 12
    (0=A, 1=J, 2=2, 3=3, ...etc, 11=Q, 12=K)
• Estas escolhas são algo arbitrárias
• Podiamos escolher outras codificações
  (mas: os códigos de valores ajudam a impressão)

Imprimir uma carta

• Imprime a descrição duma carta numa linha de texto

void imprime_carta(int naipe, int valor)
{
  imprime_valor(valor);
  printf(" de ");
  imprime_naipe(naipe);
  printf("\n");
}

• Exemplo: imprime_carta(2, 5) escreve a linha

5 de COPAS

Imprimir um naipe

void imprime_naipe(int naipe)
{
  switch(naipe) {
  case 0: printf("PAUS"); 
    break;
  case 1: printf("ESPADAS");
    break;
  case 2: printf("COPAS");
    break;
  case 3: printf("OUROS");
    break;
  default: printf("naipe inválido");  // erro
  }
}

Imprimir um valor

void imprime_valor(int valor)
{
  switch(valor) {
  case 0:  printf("A");
    break;
  case 1:  printf("J");
    break;
  case 11: printf("Q");
    break;
  case 12: printf("K");
    break;
  default: printf("%d", valor);
    // valores 2, 3 .. 10
  }
}

Escolher aleatoriamente uma carta

• Basta escolher um naipe e um valor
• Vamos usar a função rand() para gerar inteiros pseudo-aleatórios
• Transformamos o resultado para os intervalos certos:

  #define NAIPES     4
  #define VALORES    13
  
  naipe = rand() % NAIPES;
      // naipe entre 0 e 3
  valor = rand() % VALORES;
      // valor entre entre 0 e 12

Evitar repetidos

• Vamos guardar as cartas que já sairam numa matriz

  int cartas[NAIPES][VALORES];

• Cada entrada cartas[n][v] contém:
  • 1 se a carta com naipe n e valor v já saiu
  • 0 caso contrário
• Inicialmente todas as entradas são 0
• Quando sai uma carta marcamos a entrada correspondente
• Se sair uma carta previamente marcada, tentamos novamente

Programa

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(void) {
  int cartas[NAIPES][VALORES] = { 0 };
  int num; // número de cartas a sortear

  srand((unsigned)time(NULL));
    // inicializar a "semente" de aleatórios

  printf("Quantas cartas? ");
  scanf("%d", &num);

(continua)

Programa (cont.)

  while(num > 0) {
    int valor, naipe;
    naipe = rand() % NAIPES;
    valor = rand() % VALORES;
    // verificar se a carta ainda não saiu
    if(!cartas[naipe][valor])  {
      imprime_carta(naipe, valor);
      // marcar a carta
      cartas[naipe][valor] = 1;
      num--;  // menos uma carta a sortear
    }
  }
}

Argumentos de funções

• Declarações de funções com variáveis multi-dimensionais como argumentos pode omitir o tamanho da 1ª dimensão

double somar(double a[][M], int n);  // OK

• Não podemos omitir as restantes dimensões:

double somar(double a[][], int n, int m);
    // ERRO: ..........^^
    // não podemos omitir a 2ª dimensão

Argumentos de funções (cont.)

• O compilador necessita da 2ª dimensão para determinar a posição de memória de um elemento a[i][j]

\[ \scriptsize \underbrace{\overbrace{\begin{array}{|cc|} \hline \!a[0][0] \cdots a[0][M-1]\\ \hline \end{array}}^{\text{linha}~0}}_{M ~\text{valores}} \scriptsize \underbrace{\overbrace{\begin{array}{|c|} \hline \!a[1][0] \cdots a[1][M-1] \\ \hline \end{array}}^{\text{linha}~1}}_{M~\text{valores}} \scriptsize \cdots \overbrace{\begin{array}{|c|} \hline \!a[i][0] ~\cdots a[i][j]~\cdots \\ \hline \end{array}}^{\text{linha}~i} \]

• A posição de a[i][j] é i*M + j

Argumentos de funções

• A necessidade de fixar dimensões de variáveis multi-dimensionais é inconveniente
  • e.g. dificulta a definição de funções genéricas para matrizes
• Os programadores de C ultrapassam isto usando variáveis indexadas de apontadores (veremos mais tarde)

Exemplo: somar uma matriz

• Declarando um número fixo de linhas e colunas:

#define LINHAS   3
#define COLUNAS  3

double soma_matriz(double a[LINHAS][COLUNAS])
{
    int i, j;
    double s = 0.0;
    for (i = 0; i < LINHAS; i++)
      for(j = 0; j < COLUNAS; j++)
          s += a[i][j];
    return s;
}

Exemplo (cont.)

• Podiamos omitir a 1ª dimensão; assim podemos ter um número variável de linhas

#define COLUNAS  3

double soma_matriz(double a[][COLUNAS], int n)
{
    int i, j;
    double s = 0.0;
    for (i = 0; i < n; i++)
      for(j = 0; j < COLUNAS; j++)
          s += a[i][j];
    return s;
}