Matriz sem tamanho fixo [RESOLVIDO]

ianclever
(usa Arch Linux)

Enviado em 28/05/2013 - 16:43h

é os seguinte, to começando a fazer uns execícios com funções, estou fazendo um programa para ler uma matriz nxn, onde o usuário vai informar o valor de 'n' desta matriz tenho que tirar a transposta, depois ler outra matriz de mesmo tamanho comparar para ver se ela é inversa da outra e imprimir tudo isso, já fiz a maior parte, e fui fazer o teste para ver se a transposta estava saindo correta, quando compilei as matrizes não estão aceitando o tamanho 'n'(obvio pq ele nao tem nenhum valor ainda) porém essas variáveis são globais se eu mudar para dentro da função as outras não vao ver, alguma dica? (lembrando que ainda não está tudo pronto)

segue o código:

#include <stdio.h>

int cont, cont2,n,matrizp[n][n], matrizt[n][n] ,matrizi[n][n] ,matrizin[n][n], matriza[n][n],matrizb[n][n];
void lermatrizprincipal()
    {
        int i,j;
        printf("\nDigite o tamanho 'n' de uma matriz quadrada n x n: ");
        scanf("%d",&n);
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {
                        printf("\nDigite o número da posição %d,%d : ",i,j);
                        scanf("%d",&matrizp[i][j]);
                    }
            }
    }
void transportar()
    {
        int i,j;
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {
                        matrizt[i][j]=matrizp[j][i];
                    }
            }
    }
void lerinversa()
    {
        int i,j;
        printf("\nInforme os números de uma matriz para \npodermos conferir se é inversa da primeira");
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {

                        printf("\nDigite o numero da posição %d,%d",i,j);
                        scanf("%d",&matrizin[i][j]);
                    }
            }
    }
void gerar_m_identidade()
    {
        int i,j;
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {
                        if(i==j)
                            {
                                matrizi[i][j]=1;
                            }
                        else
                            {
                                matrizi[i][j]=0;
                            }
                    }
            }
    }
void conferir_inversa()
    {
        int a,b,c;
        cont=0;
        for(a=0;a<n;a++)
            {
                for(b=0;b<n;b++)
                    {
                        for(c=0;c<n;c++)
                            {
                                matriza[a][b]+=matrizp[a][b]*matrizin[c][b];
                                matrizb[a][b]+=matrizin[a][b]*matrizp[c][b];
                            }
                    }
            }
        for(a=0;a<n;a++)
            {
                for(b=0;b<n;b++)
                    {
                        if(matriza[a][b]!=matrizb[a][b])
                            {
                                cont++;
                            }
                    }
            }
        if(cont>0)
            {
                for(a=0;a<n;a++)
                    {
                        for(b=0;b<n;b++)
                            {
                                if(matriza[a][b]!=matrizi[a][b])
                                    {
                                        cont2++;
                                    }
                            }
                    }
            }
    }
void imprimirtransposta()
    {
        int i,j;
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {
                        if(j==3)
                            {
                                printf("\tT =");
                            }
                        printf("\t\t\t\n");
                        if(j==0)
                            {
                                printf("|");
                            }
                        printf("%d ",matrizt[i][j]);
                        if(j==n-1)
                            {
                                printf("|");
                            }
                    }
            }
    }
main()
    {
        lermatrizprincipal();
        transportar();
        imprimirtransposta();
    }
 

WhiteHawk
(usa Ubuntu)

Enviado em 29/05/2013 - 09:38h

Olá. Como você mesmo disse, o programa não está rodando porque "n" ainda não possui um valor definido. Acredito que pra resolver esse problema você tenha que criar ponteiros para as matrizes, receber do usuário o valor de "n" e alocar dinamicamente a memória.

Veja: http://bit.ly/1ayyKej

ianclever
(usa Arch Linux)

Enviado em 29/05/2013 - 16:09h

bom ainda não tinha visto ponteiro, mas é uma das alternativas pelo visto, porém para mim ainda tá um pouco dificil de entender por enquanto.
Por hora estou usando uma gambiarra para sanar isso(declaro a matriz com um tamanho fixo grande 200x200) só que isso é ruim pq fica ocupando memória sem necessidade.

teria alguma forma de depois de ter lido o n realocar(mudar) o tamanho ?

EnzoFerber
(usa FreeBSD)

Enviado em 29/05/2013 - 16:52h

Não.

Pra realocação de memória, só ponteiros.

Enzo Ferber
[]'s

EnzoFerber
(usa FreeBSD)

Enviado em 29/05/2013 - 17:06h

Quanto a exercícios de programação, antes de ver ponteiros, você sempre usa matrizes de tamanho ridiculamente grandes para os exercícios de 'n entradas'.

Se você estiver seguindo um livro/apostila, provavelmente encontrará exercícios pedindo para você rescrever os programas anteriores usando ponteiros e alocação dinâmica de memória. ;)

E para programas de matrizes múltiplas, você pode usar um ponteiro e dois indicadores de índice, x e y.

int x, y;

int *matrix;

scanf ( 'x' e 'y' );

matrix = (int*)malloc( (x * y ) * sizeof(int));

...

// para acessar
matrix[x * y] = ...;

 

Claro que também pode usar ponteiros para ponteiros (int **matrix), que permitirão o acesso por meio de matrix[x][y]. Só que é bem mais complicado o processo todo, e cheio de detalhes, que abrem espaço para muitos erros difíceis de serem encontrados.

Qualquer dúvida posta denovo,
Enzo Ferber
[]'s

ianclever
(usa Arch Linux)

Enviado em 29/05/2013 - 21:54h

ok! vou usar a gambiarra aqui, se surgir mais alguma duvida posto aqui.

ianclever
(usa Arch Linux)

Enviado em 30/05/2013 - 22:03h

pronto feito!
ta aí:

#include <stdio.h>

int cont, cont2,n,matrizp[200][200], matrizt[200][200] ,matrizi[200][200] ,matrizin[200][200], matriza[200][200],matrizb[200][200];
void lermatrizprincipal()
    {
        int i,j;
        printf("\nDigite o tamanho 'n'(no máximo 200) de uma matriz quadrada n x n: \n");
        scanf("%d",&n);
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {
                        printf("\nDigite o número da posição %d,%d : ",i,j);
                        scanf("%d",&matrizp[i][j]);
                    }
            }
    }
void transportar()
    {
        int i,j;
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {
                        matrizt[i][j]=matrizp[j][i];
                    }
            }
    }
void lerinversa()
    {
        int i,j;
        printf("\nInforme os números de uma matriz para \n\npodermos conferir se é inversa da primeira\n");
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {

                        printf("\nDigite o numero da posição %d,%d: ",i,j);
                        scanf("%d",&matrizin[i][j]);
                    }
            }
    }
void gerar_m_identidade()
    {
        int i,j;
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {
                        if(i==j)
                            {
                                matrizi[i][j]=1;
                            }
                        else
                            {
                                matrizi[i][j]=0;
                            }
                    }
            }
    }
void conferir_inversa()
    {
        int a,b,c;
        cont=0;
        cont2=0;
        for(a=0;a<n;a++)
            {
                for(b=0;b<n;b++)
                    {
                        for(c=0;c<n;c++)
                            {
                                matriza[a][b]+=matrizp[a][b]*matrizin[c][b];
                                matrizb[a][b]+=matrizin[a][b]*matrizp[c][b];
                            }
                    }
            }
        for(a=0;a<n;a++)
            {
                for(b=0;b<n;b++)
                    {
                        if(matriza[a][b]!=matrizb[a][b])
                            {
                                cont++;
                            }
                    }
            }
        for(a=0;a<n;a++)
            {
                for(b=0;b<n;b++)
                    {
                        if(matriza[a][b]!=matrizi[a][b])
                            {
                                cont2++;
                            }
                    }
            }
    }
void imprimirprincipal()
    {
        int i,j;
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {
                        if((j==0)&&(i!=1))
                            {
                                printf("\n\t");
                                printf("|");
                            }
                        else
                            {
                                if((j==0)&&(i==1))
                                    {
                                        printf("\n A=\t");
                                        printf("|");
                                    }
                            }
                        printf(" %d ",matrizp[i][j]);
                        if(j==n-1)
                            {
                                printf("|");
                            }
                    }
            }
        printf("\n ");

    }
void imprimirtransposta()
    {
        int i,j;
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {
                        if((j==0)&&(i!=1))
                            {
                                printf("\n\t");
                                printf("|");
                            }
                        else
                            {
                                if((j==0)&&(i==1))
                                    {
                                        printf("\n T=\t");
                                        printf("|");
                                    }
                            }
                        printf(" %d ",matrizt[i][j]);
                        if(j==n-1)
                            {
                                printf("|");
                            }
                    }
            }
        printf("\n ");
    }
void imprimirinversa()
    {
        int i,j;
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {
                        if(j==0)
                            {
                                printf("\n |");
                            }
                        printf(" %d",matrizp[i][j]);
                        if((j==n-1))
                            {
                                printf("|");
                            }
                    }
            }
        printf("\n\n  ><\n");
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {
                        if(j==0)
                            {
                                printf("\n |");
                            }
                        printf(" %d",matrizin[i][j]);
                        if(j==n-1)
                            {
                                printf("|");
                            }
                    }
            }
        printf("\n\n   __");
        printf("\n   __\n");
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {
                        if(j==0)
                            {
                                printf("\n |");
                            }
                        printf(" %d",matriza[i][j]);
                        if(j==n-1)
                            {
                                printf("|");
                            }
                    }
            }
        printf("\n_____________________________________________________________\n");
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {
                        if(j==0)
                            {
                                printf("\n |");
                            }
                        printf(" %d",matrizin[i][j]);
                        if(j==n-1)
                            {
                                printf("|");
                            }
                    }
            }
        printf("\n\n  ><\n");
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {
                        if(j==0)
                            {
                                printf("\n |");
                            }
                        printf(" %d",matrizp[i][j]);
                        if((j==n-1))
                            {
                                printf("|");
                            }
                    }
            }
        printf("\n\n   __");
        printf("\n   __\n");
        for(i=0;i<n;i++)
            {
                for(j=0;j<n;j++)
                    {
                        if(j==0)
                            {
                                printf("\n |");
                            }
                        printf(" %d",matrizb[i][j]);
                        if(j==n-1)
                            {
                                printf("|");
                            }
                    }
            }
        printf("\n______________________________________________________________\n");
        if(cont!=0)
            {
                for(i=0;i<n;i++)
                    {
                        for(j=0;j<n;j++)
                            {
                                if(j==0)
                                    {
                                        printf("\n |");
                                    }
                                printf(" %d",matriza[i][j]);
                                if(j==n-1)
                                    {
                                        printf("|");
                                    }
                            }
                    }
                printf("\n\n   --/--");
                printf("\n   -/---\n");
                for(i=0;i<n;i++)
                    {
                        for(j=0;j<n;j++)
                            {
                                if(j==0)
                                    {
                                        printf("\n |");
                                    }
                                printf(" %d",matrizb[i][j]);
                                if(j==n-1)
                                    {
                                        printf("|");
                                    }
                            }
                    }
                printf("\n\n   --/--");
                printf("\n   -/---\n");
                for(i=0;i<n;i++)
                    {
                        for(j=0;j<n;j++)
                            {
                                if(j==0)
                                    {
                                        printf("\n |");
                                    }
                                printf(" %d",matrizi[i][j]);
                                if(j==n-1)
                                    {
                                        printf("|");
                                    }
                            }
                    }
                printf("\n\nNÃO É INVERSA!");
                printf("\n______________________________________________________________\n");
            }
        else
            {
                if(cont==0)
                    {
                        if(cont2==0)
                            {
                                for(i=0;i<n;i++)
                                    {
                                        for(j=0;j<n;j++)
                                            {
                                                if(j==0)
                                                    {
                                                        printf("\n |");
                                                    }
                                                printf(" %d",matriza[i][j]);
                                                if(j==n-1)
                                                    {
                                                        printf("|");
                                                    }
                                            }
                                    }
                                printf("\n\n   ----");
                                printf("\n   ----\n");
                                for(i=0;i<n;i++)
                                    {
                                        for(j=0;j<n;j++)
                                            {
                                                if(j==0)
                                                    {
                                                        printf("\n |");
                                                    }
                                                printf(" %d",matrizb[i][j]);
                                                if(j==n-1)
                                                    {
                                                        printf("|");
                                                    }
                                            }
                                    }
                                printf("\n\n   ----");
                                printf("\n   ----\n");
                                for(i=0;i<n;i++)
                                    {
                                        for(j=0;j<n;j++)
                                            {
                                                if(j==0)
                                                    {
                                                        printf("\n |");
                                                    }
                                                printf(" %d",matrizi[i][j]);
                                                if(j==n-1)
                                                    {
                                                        printf("|");
                                                    }
                                            }
                                    }
                                printf("\n\nÉ INVERSA!");
                                printf("\n______________________________________________________________\n");

                        }
                    else
                        {
                            for(i=0;i<n;i++)
                                {
                                    for(j=0;j<n;j++)
                                        {
                                            if(j==0)
                                                {
                                                    printf("\n |");
                                                }
                                            printf(" %d",matriza[i][j]);
                                            if(j==n-1)
                                                {
                                                    printf("|");
                                                }
                                        }
                                }
                            printf("\n\n   ----");
                            printf("\n   ----\n");
                            for(i=0;i<n;i++)
                                {
                                    for(j=0;j<n;j++)
                                        {
                                            if(j==0)
                                                {
                                                    printf("\n |");
                                                }
                                            printf(" %d",matrizb[i][j]);
                                            if(j==n-1)
                                                {
                                                    printf("|");
                                                }
                                        }
                                }
                            printf("\n\n   --/--");
                            printf("\n   -/---\n");
                            for(i=0;i<n;i++)
                                {
                                    for(j=0;j<n;j++)
                                        {
                                            if(j==0)
                                                {
                                                    printf("\n |");
                                                }
                                            printf(" %d",matrizi[i][j]);
                                            if(j==n-1)
                                                {
                                                    printf("|");
                                                }
                                        }
                                }
                            printf("\n\nNÃO É INVERSA!");
                            printf("\n______________________________________________________________\n");
                        }
                    }
            }
    }
void menu()
    {
        int opc;
        lermatrizprincipal();
        system("clear");
        do
            {
                printf("\n\n");
                printf("\n|>>>>>>>>>>>>>>- MENU -<<<<<<<<<<<<<<<<<<|");
                printf("\n|>                                      <|");
                printf("\n|>   1)Imprimir matriz transposta;      <|");
                printf("\n|>   2)Descobrir se matriz é inversa ;  <|");
                printf("\n|>   3)Limpar a tela;                   <|");
                printf("\n|>   4)Sair;                            <|");
                printf("\n|>                                      <|");
                printf("\n|>>>>>>>>>>>>>>- MENU -<<<<<<<<<<<<<<<<<<|");
                printf("\n\nDigite uma opção: ");
                scanf("%d",&opc);
                __fpurge(stdin);
                switch(opc)
                    {
                        case 1:
                            {
                                system("clear");
                                transportar();
                                printf("\n\n");
                                imprimirprincipal();
                                printf("\n\n");
                                imprimirtransposta();
                                break;
                            }
                        case 2:
                            {
                                system("clear");
                                lerinversa();
                                gerar_m_identidade();
                                conferir_inversa();
                                imprimirinversa();
                            }
                            break;
                        case 3:
                            system("clear");
                            break;
                        case 4:
                            break;

                    }
            }while(opc!=4);
    }
main()
    {
        menu();
    }