Ir ao conteúdo
  • Cadastre-se

C Codigo não compila na linguagem C


Posts recomendados

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;
}

 

Link para o post
Compartilhar em outros sites

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.

  • Curtir 1
  • Confuso 1
Link para o post
Compartilhar em outros sites
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?

Link para o post
Compartilhar em outros sites
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;
}

 

Link para o post
Compartilhar em outros sites
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.
 

image.png.99892defa4ed0716e93c90924ba4de74.png

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

um livro texto clássico no mundo todo.

 

 

 

 

 

 

 

Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisa ser um usuário para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...

Redes-Wi-Fi-capa-3d-newsletter.png

EBOOK GRÁTIS!

CLIQUE AQUI E BAIXE AGORA MESMO!