C Codigo não compila na linguagem C

[paulo luz magalhaes]

Escreva um programa que lê todos os elementos de uma matriz N × N e mostra a matriz e a sua transposta na tela. Obs: O tamanho (N) da matriz deve ser lido do teclado e sua alocação deve ser dinâmica através da função malloc.

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

int main() {
 // alocando matriz
 int n = 3, m = 2;
 int **matriz = malloc(n * sizeof(int*));
 for (int i = 0; i < n; i++)
 matriz[i] = malloc(m * sizeof(int));

 // código omitido: lê os dados de matriz

 int **transp = transposta(matriz, n, m);

  // código omitido: imprime ou faz algo com transp

 // libera a memória alocada
 for(int i = 0; i < n; i++)
 free(matriz[i]);
 for (int j = 0; j < m; j++)
 free(transp[j]);
 free(matriz);
 free(transp);

 return 0;
}

 

[devair1010]

@paulo luz magalhaes   está faltando a função transposta .

 

[kgin]

Reservar uma matriz assim está errado.

1 hora atrás, paulo luz magalhaes disse:

int **matriz = malloc(n * sizeof(int*));

O correto seria.

Spoiler

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

int main(void)
{
    int linhas, colunas, contador = 0;
    /* Matriz dinamica */
    int (*matriz)[6] = malloc(sizeof(int[6][6]));
    if (matriz == NULL) {
        perror("Nao foi possivel reservar memoria!");
        return(1);
    }

    /* Preenche a matriz */
    for (linhas = 0; linhas < 6; linhas++) {
        for (colunas = 0; colunas < 6; colunas++) {
            matriz[linhas][colunas] = contador;
            contador++;
        }
    }

    /* Mostra a matriz */
    for (linhas = 0; linhas < 6; linhas++) {
        for (colunas = 0; colunas < 6; colunas++) {
            printf("%i,", matriz[linhas][colunas]);
        }
        putchar('\n');
    }

    /* Libera a matriz */
    free(matriz);
    return(0);
}

 

 

Mas mesmo assim ainda não seria útil para você dessa maneira.

 

Outra maneira seria fazer igual o compilador faz.

Spoiler

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

#define T_BUFFER 512

int main(void)
{
    int *numeros, q_linhas = 0, q_colunas = 0, linhas, colunas;
    char buffer[T_BUFFER];
    /* Pega a quantidade de linhas da matriz */
    do {
        printf("Digite a quantidade de linhas da matriz\n");
        if (fgets(buffer, T_BUFFER, stdin) != NULL) {
            if (buffer[0] != '\n') {
                if (sscanf(buffer, "%i", &q_linhas) != 1) {
                    printf("Digite um numero\n");
                }
            } else {
                printf("Digite uma entrada valida!\n");
            }
        }
    } while (q_linhas <= 0);

    /* Pega a quantidade de colunas da matriz */
    do {
        printf("Digite a quantidade de colunas da matriz\n");
        if (fgets(buffer, T_BUFFER, stdin) != NULL) {
            if (buffer[0] != '\n') {
                if (sscanf(buffer, "%i", &q_colunas) != 1) {
                    printf("Digite um numero\n");
                }
            } else {
                printf("Digite uma entrada valida!\n");
            }
        }
    } while (q_colunas <= 0);

    /* Reserva memoria para a matriz */
    numeros = malloc(sizeof(*numeros)*q_linhas*q_colunas);
    if (numeros == NULL) {
        perror("Erro ao reservar memoria!");
        exit(EXIT_FAILURE);
    }

    /* Lê a matriz do úsuario */
    for (linhas = 0; linhas < q_linhas; linhas++) {
        for (colunas = 0; colunas < q_colunas; colunas++) {
            int pega_novamente = 1;
            /* Pega um numero */
            do {
                printf("[%i][%i]\n", linhas, colunas);
                if (fgets(buffer, T_BUFFER, stdin) != NULL) {
                    if (buffer[0] != '\n') {
                        if (sscanf(buffer, "%i", &numeros[(linhas*q_colunas)+colunas]) == 1) {
                            pega_novamente = 0;     /* Sai do "do {} while()" */
                        }
                    } else {
                        printf("Digite uma entrada valida!\n");
                    }
                }
            } while (pega_novamente);
        }
    }

    /* Mostra a matriz */
    printf("Matriz digitada\n");
    for (linhas = 0; linhas < q_linhas; linhas++) {
        for (colunas = 0; colunas < q_colunas; colunas++) {
            printf("%i,", numeros[(linhas*q_colunas)+colunas]);
        }
        putchar('\n');
    }

    getchar();      /* Espera o enter */
  	/* Libera a memoria */
    free(numeros);
    return(0);
}

 

 

Recomendo ler o livro C completo e total na pagina 105 sobre indexação de ponteiros.

[paulo luz magalhaes]

1 hora atrás, kgin disse:

Reservar uma matriz assim está errado.

O correto seria.

  Ocultar conteúdo

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

int main(void)
{
    int linhas, colunas, contador = 0;
    /* Matriz dinamica */
    int (*matriz)[6] = malloc(sizeof(int[6][6]));
    if (matriz == NULL) {
        perror("Nao foi possivel reservar memoria!");
        return(1);
    }

    /* Preenche a matriz */
    for (linhas = 0; linhas < 6; linhas++) {
        for (colunas = 0; colunas < 6; colunas++) {
            matriz[linhas][colunas] = contador;
            contador++;
        }
    }

    /* Mostra a matriz */
    for (linhas = 0; linhas < 6; linhas++) {
        for (colunas = 0; colunas < 6; colunas++) {
            printf("%i,", matriz[linhas][colunas]);
        }
        putchar('\n');
    }

    /* Libera a matriz */
    free(matriz);
    return(0);
}

 

 

Mas mesmo assim ainda não seria útil para você dessa maneira.

 

Outra maneira seria fazer igual o compilador faz.

  Ocultar conteúdo

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

#define T_BUFFER 512

int main(void)
{
    int *numeros, q_linhas = 0, q_colunas = 0, linhas, colunas;
    char buffer[T_BUFFER];
    /* Pega a quantidade de linhas da matriz */
    do {
        printf("Digite a quantidade de linhas da matriz\n");
        if (fgets(buffer, T_BUFFER, stdin) != NULL) {
            if (buffer[0] != '\n') {
                if (sscanf(buffer, "%i", &q_linhas) != 1) {
                    printf("Digite um numero\n");
                }
            } else {
                printf("Digite uma entrada valida!\n");
            }
        }
    } while (q_linhas <= 0);

    /* Pega a quantidade de colunas da matriz */
    do {
        printf("Digite a quantidade de colunas da matriz\n");
        if (fgets(buffer, T_BUFFER, stdin) != NULL) {
            if (buffer[0] != '\n') {
                if (sscanf(buffer, "%i", &q_colunas) != 1) {
                    printf("Digite um numero\n");
                }
            } else {
                printf("Digite uma entrada valida!\n");
            }
        }
    } while (q_colunas <= 0);

    /* Reserva memoria para a matriz */
    numeros = malloc(sizeof(*numeros)*q_linhas*q_colunas);
    if (numeros == NULL) {
        perror("Erro ao reservar memoria!");
        exit(EXIT_FAILURE);
    }

    /* Lê a matriz do úsuario */
    for (linhas = 0; linhas < q_linhas; linhas++) {
        for (colunas = 0; colunas < q_colunas; colunas++) {
            int pega_novamente = 1;
            /* Pega um numero */
            do {
                printf("[%i][%i]\n", linhas, colunas);
                if (fgets(buffer, T_BUFFER, stdin) != NULL) {
                    if (buffer[0] != '\n') {
                        if (sscanf(buffer, "%i", &numeros[(linhas*q_colunas)+colunas]) == 1) {
                            pega_novamente = 0;     /* Sai do "do {} while()" */
                        }
                    } else {
                        printf("Digite uma entrada valida!\n");
                    }
                }
            } while (pega_novamente);
        }
    }

    /* Mostra a matriz */
    printf("Matriz digitada\n");
    for (linhas = 0; linhas < q_linhas; linhas++) {
        for (colunas = 0; colunas < q_colunas; colunas++) {
            printf("%i,", numeros[(linhas*q_colunas)+colunas]);
        }
        putchar('\n');
    }

    getchar();      /* Espera o enter */
  	/* Libera a memoria */
    free(numeros);
    return(0);
}

 

 

Recomendo ler o livro C completo e total na pagina 105 sobre indexação de ponteiros.

como faço a transposta?

[Midori]

11 horas atrás, kgin disse:

Reservar uma matriz assim está errado.

13 horas atrás, paulo luz magalhaes disse:

int **matriz = malloc(n * sizeof(int*));

Não está errado.

 

Assim é alocado um vetor de n ponteiros. E depois para cada um é feita a alocação para os m elementos.

 

10 horas atrás, paulo luz magalhaes disse:

como faço a transposta?

Faça a alocação na função como fez para a matriz, só que agora troque a quantidade de linhas e colunas, p.ex,

 

int **transposta(int **matriz, int n, int m){
    int **T = (int **)malloc(m * sizeof(int *));
...
    return T;
}

 

[arfneto]

5 minutos atrás, Midori disse:

Não está errado.

 

Assim é alocado um vetor de n ponteiros. E depois para cada um é feita a alocação para os m elementos.

 

Você em razão @Midori não está errado. Mas pode estar errado. Não dá pra saber só com uma linha. E considerando que é uma matriz quadrada apesar de não estar sintaticamente errado está praticamente errado  . Vou tentar explicar

 

Ao declarar isso em 64 bits:
 

    int****     coisa; 

 

se está declarando um ponteiro. Só um. 8 bytes de estiver compilando em 64bits. Isso não é por exemplo uma "matriz multidimensional" como já li aqui e em alguns lugares. Nem existe isso em C. E ****coisa é apenas um int.

 

EXEMPLO

 

Veja a saída
 

O int:        30
O int*:       30
O int**:      30
O int***:     30
O int****:    30
Um **((int**)(**(int****):    30

sizeof(int****):         8

 

Desse programa

 

#include <stdio.h>
int main()
{
    int         trinta = 30;
    int*        coisa1 = &trinta;
    int**       coisa2 = &coisa1;
    int***      coisa3 = &coisa2;
    int****     coisa4 = &coisa3;
    printf("O int: %9d\n", trinta);
    printf("O int*: %8d\n", *coisa1);
    printf("O int**: %7d\n", **coisa2);
    printf("O int***: %6d\n", ***coisa3);
    printf("O int****: %5d\n", ****coisa4);
    printf("Um **((int**)(**(int****): %5d\n", **((int**)(**coisa4)) );
    printf("\nsizeof(int****): %9d\n", (int) sizeof(coisa4));
    return 0;
}

 

E acho que vai entender o que quero dizer, Pode estar certo se o programa construir tudo certinho. Pode estar errado.

 

27 minutos atrás, Midori disse:

Assim é alocado um vetor de n ponteiros. E depois para cada um é feita a alocação para os m elementos.

 

 

Como você disse. Assim é alocado um vetor de ponteiros. E aí precisa fazer esse vetor de ponteiros apontar para as linhas da "matriz" alocando o espaço correto para cada linha.

 

O exemplo óbvio para entender isso é o sistema e main(). main() é 
 

    int     main(int argc, char**argv);

e o sistema constrói cuidadosamente um vetor de ponteiros a partir de cada argumento passado para cada programa n mundo C. **argv é apenas um char. *argv é o primeiro argumento, o nome do programa.

 

E a parte do praticamente errado?

 

É que se espera a matriz contínua na memória e por isso se aloca para uma "matriz" 3x4x5 de double uma área de 3x4x5xsizeof(double). E se usa aritmética para achar os dados.

 

Ao construir passo a passo pode ser que os valores das linhas não sejam contínuos e não se pode calcular as posições dos elementos a partir do endereço de início.
 

Essa é a fórmula geral, aqui copiada de Estruturas de Dados usando C (1a ed. 1995)

um livro texto clássico no mundo todo.