Problema na identificação de uma matriz

[tipoBoolean]

Boas, tou com um problema q nao sei como resolver

O meu objectivo é fazer um subprograma ou metodo wtv para ler uma matriz com o tamanho inserido pelo utilizador,mas nao sei como identificar a matriz nesse mesmo.

void lerMatriz(int matriz[][], int linha, int coluna)

mas isto da erro

no caso de um vetor funciona

void lerVetores(int t[],int tamanho)

alguem me pode ajudar?

[HappyHippyHippo]

int** matrix;

[falk0n]

void lerMatriz(int matriz[][], int linha, int coluna)

mas isto da erro

Se não estou em erro, acho que apenas podes declarar arrays multidimensionais em que apenas a sua ultma dimensão é desconhecida.

Assim se quisesses declarar a variavel matriz dessa forma teria que ser algo assim:

void lerMatriz(int matriz[FSIZE][], int linha, int coluna);

em que FSIZE seria um valor inteiro sem sinal maior que zero.

No entanto penso que o que queres fazer necessita da forma que o hippo te indicou:

int** matrix;

Ou seja, a tua função lerMatriz deverá ser algo assim:

void lerMatriz(int **matriz, unsigned int linha, unsigned int coluna);

Boas programações,

Nuno

[tipoBoolean]

Sim, só dá para para criar uma matriz multidimensional, somente com uma variável desconhecida

Consegui por a funcionar com o codigo:

void lerMatriz(int **matriz, unsigned int linha, unsigned int coluna);

Mas surgiu-me um novo problema, como é que consigo imprimir esta matriz?

Está me a devolver o endereço de memoria, estou a usar a declaração identica:

void escreverMatriz (int **matriz, unsigned int linha, unsigned int coluna)

e já tentei:

printf("%d ",&matriz);
printf("%d ",*matriz);
printf("%d ",matriz);

porque é que um duplo apontador funciona neste caso? porque esta a apontar para dois endereços de memoria?

[HappyHippyHippo]

porque é que um duplo apontador funciona neste caso? porque esta a apontar para dois endereços de memoria?

isto são duas perguntas, das quais vou ignorar completamente a segunda (razão fica por dizer)

isto não é um "duplo apontador", não é mais do que um apontador que aponta para uma posição de memória que deverá ser interpretada como um ponteiro para inteiro(s).

esta é a explicação do que é, e é para ter atenção a todas as palavras da explicação (todas mesmo).

antes de mais, nem sei se estás a alocar a memória necessária correctamente assim como a libertar quando já não a necessitas. mas para fazer a apresentação dos dados necessitas de fazer como de um array se tratasse, isto é, tens de iterar pelos elementos e fazer o output do valor.

não faço ideia tem de disse que para fazer a saida de dados não numéricos naturais à linguagem, é feita dessa forma.

[tipoBoolean]

este é o meu codigo para imprimir uma matriz

void escreverMatriz (int **matriz, unsigned int linha, unsigned int coluna)
{
int i,j;
for(i=0;i<linha;i++) {
 for(j=0;j<coluna;j++)
 printf("%d ",matriz);
 printf("\n");
}
system("pause");
}

nao sei mesmo o que fazer, Acho que vou pela saida mais facil... fazer um #define ao numero de colunas e só deixa o user mexer no numero de linhas

[HappyHippyHippo]

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

typedef struct
{
   int** valores;
   size_t linhas;
   size_t colunas;
} Matrix;

Matrix*
matrix_criar(const size_t linhas, const size_t colunas)
{
   if (   linhas == 0
       || colunas == 0)
   {
       return NULL;
   }

   Matrix* matrix;
   if ((matrix = malloc(sizeof(Matrix))) == NULL)
   {
       return NULL;
   }

   if ((matrix->valores = malloc(sizeof(int) * linhas)) == NULL)
   {
       free(matrix);
       return NULL;
   }

   for (size_t linha = 0; linha < linhas; ++linha)
   {
       if ((matrix->valores[linha] = malloc(sizeof(int) * colunas)) == NULL)
       {
           for (size_t aux = 0; aux < linha; ++aux)
           {
               free(matrix->valores[aux]);
               free(matrix->valores);
               free(matrix);

               return NULL;
           }
       }
   }

   matrix->linhas = linhas;
   matrix->colunas = colunas;

   return matrix;
}

void
matrix_destruir(Matrix** matrix)
{
   if (   matrix == NULL
       || *matrix == NULL)
   {
       return;
   }

   Matrix* aux = *matrix;
   for (size_t linha = 0; linha < aux->linhas; ++linha)
   {
       free(aux->valores[linha]);
   }
   free(aux->valores);
   free(aux);

   *matrix = NULL;
}

int*
matrix_valor(Matrix* matrix, const size_t linha, const size_t coluna)
{
   if (   matrix == NULL
       || linha >= matrix->linhas
       || coluna >= matrix->colunas)
   {
       return NULL;
   }

   return &matrix->valores[linha][coluna];
}

void
matrix_rand(Matrix* matrix, const int min, const int max)
{
   if (matrix == NULL)
   {
       return;
   }

   srand(time(NULL));

   for (size_t linha = 0; linha < matrix->linhas; ++linha)
   {
       for (size_t coluna = 0; coluna < matrix->colunas; ++coluna)
       {
           matrix->valores[linha][coluna] = (rand() % (max - min + 1)) + min;
       }
   }
}

void
matrix_imprimir(Matrix* matrix)
{
   if (matrix == NULL)
   {
       return;
   }

   for (size_t linha = 0; linha < matrix->linhas; ++linha)
   {
       for (size_t coluna = 0; coluna < matrix->colunas; ++coluna)
       {
           printf("%d ", matrix->valores[linha][coluna]);
       }
       printf("\n");
   }
}

int main(int argc, char** argv)
{
   Matrix* matrix = matrix_criar(3, 4);

   matrix_rand(matrix, 5, 8);
   matrix_imprimir(matrix);
   matrix_destruir(&matrix);

   return 0;
}