Peço pequena explicação do código

[Wild Bull]

Porque a função aloca_linhas é declarada e usada como **aloca_linhas?

E porque quando chamada é aloca_linhas mesmo?

Obrigado.

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

int **aloca_linhas(int );
void aloca_colunas (int **, int, int);
void le_dados(int **, int, int );
void imprime_matriz(int **, int, int );
void troca_linhas (int **, int, int);

int main () {
     int **matriz;   /* ponteiro para os ponteiros de cada uma das linhas */
     int lin, col;   /* número de linhas e colunas */
     int linha1, linha2; /* linhas da matriz que serao trocadas */
     char linha[80]; /* linha de caracteres com os dados */

     do {
        puts("Qual o numero de linhas?");
        gets(linha);
        lin = atoi(linha);
     } while (lin<=0);
     printf("Numero de linhas = %d\n", lin);

     printf("Alocando espaço para armazenar os ponteiros para as linhas.\n");
     matriz = aloca_linhas(lin);

     do {
        puts("Qual o numero de colunas?");
        gets(linha);
        col = atoi(linha);
     } while (col<=0);
     printf("Numero de colunas = %d\n", lin);

     printf("Alocando espaço para armazenar os vetores de linhas.\n");
     aloca_colunas(matriz, lin, col);

     le_dados(matriz, lin, col);

     puts("Imprimindo dados lidos");
     imprime_matriz(matriz, lin, col);

     getchar();

     do {
        puts("Qual a primeira linha a ser trocada?");
        gets(linha);
        linha1=atoi(linha);
     } while (linha1 >=lin);

     do {
        puts("Qual a segunda linha a ser trocada?");
        gets(linha);
        linha2=atoi(linha);
     } while (linha2 >=lin);

     troca_linhas(matriz, linha1, linha2);

     puts("Imprimindo dados trocados.");
     imprime_matriz(matriz, lin, col);
     getchar();
     return 0;
}
/*****************************************************************************/

int **aloca_linhas(int lin) {

  int **m;
     m = (int **) malloc (lin * sizeof(int *));
     if (!m) {
        puts("Nao há espaço para alocar memória");
        exit(1);
     }
     return m;
}
/*****************************************************************************/

void aloca_colunas(int **matriz, int lin, int col)
{
  int i;
     for (i=0; i<lin; i++)
     {
        *(matriz +i) = (int *) malloc(col * sizeof (int));
        if (! *(matriz+i) ){
           printf("Não há espaço para alocar a linha %d", i);
           exit(1);
        }
     }
}
/****************************************************************************/

void le_dados (int **matriz, int lin, int col)
{
  int i, j;
     puts("Entre com os dados");
     for (i=0; i<lin; i++)
     {
        printf("Entre com a linha %d\n", i);
        for (j=0; j<col; j++)
        {
            printf("Elemento %d %d\n", i, j);
            scanf("%d", *(matriz +i) +j);
        }
     }
}
/****************************************************************************/

void imprime_matriz (int **matriz, int lin, int col)
{
     int i, j;

     for (i=0; i<lin; i++)
     {
        for (j=0; j<col; j++)
        {
            printf("%7d ", *(*(matriz +i) +j));
        }
        printf("\n");
     }
}
/****************************************************************************/

void troca_linhas ( int **matriz, int linha1, int linha2)
{

  int *temp;

  temp = *(matriz + linha1);
  *(matriz + linha1) = *(matriz + linha2);
  *(matriz + linha2) = temp;
}

[crudo]

os dois asteriscos ** indicam que o retorno da função será um ponteiro de um ponteiro...

Você chama a função normalmente igual as outras funções...

Entenda int** como um tipo de variável.

[Wild Bull]

Muito obrigado pela explicação crudo!

O que me confundiu foi que os asteriscos estavam com o nome da função e não com o tipo, fica mais legível int** aloca_linhas... se retornasse um ponteiro seria int* aloca_linhas

Obrigado mais uma vez.