Newsgroup: it.comp.lang.c
Titolo: Problema con le matrici

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
char buf[100];
int bufp = 0;
int getch(void)
{
    return (bufp > 0) ? buf[--bufp] : getchar();
}
void ungetch(int c)
{
     if (bufp >= 100)
        printf("Troppi caratteri");
     else buf[bufp++] = c;
}
int getint(int *pn)
{
        int c, sign;
        while (isspace(c = getch()))
                ;
        if (!isdigit(c) && c != EOF && c != '+' && c != '-') {
                ungetch(c);
                return 0;
        }
        sign = (c == '-') ? -1 : 1;
        if (c == '+' || c == '-')
                c = getch();
        for (*pn = 0; isdigit(c); c = getch())
                *pn = 10 * *pn + (c - '0');
        *pn *= sign;
        if (c != EOF)
                ungetch(c);
        return c;
}
int main()
{
    int o;
    printf("Pronto a creare la matrice\n");
    printf("Inserire l'ordine della matrice quadrata\n");
    int j, i = getint(&o);
    int matrice[i][j];
    for(j = 0; j < o; j++)
    {
          for(i = 0; i < o; i++)
          {
                if(i == j)
                matrice[i][j] = 1;
                else
                matrice[i][j] = 0;
                printf("%d ", matrice[i][j]);
          }
    printf("\n");
    }
    system("Pause");
}
Questo programma stampa delle matrici unitarie di rango definito
dall'utente. Il programma va che è una favola fino alle matrici di
ordine 10, mentre per quelle di ordine superiori a 10 crasha
inspiegabilmente. Non riesco proprio a capire come mai! Qualcuno può
darmi una mano?


Non ho potuto provarlo.... però .... int matrice[i][j] mi sembra una 
cosa da java (passatemi javata :-) )....non  bisognava usare malloc ? io 
avrei fatto cosi....
int *matrice=(int *)malloc(sizeof(int)*i*j);
e poi il pezzo del for lo trasformavo cosi...
for(j = 0; j < o; j++)
     {
           for(i = 0; i < o; i++)
           {
                 if(i == j)
                 matrice[i*o+j] = 1;
                 //matrice[i][j] = 1;
                 else
                 matrice[i*o+j] = 0;
                 //matrice[i][j] = 0;
                 printf("%d ", matrice[i*o+j]);
           }
     printf("\n");
     }
Ovviamente manca un controllo che malloc non ti ritorni NULL .... ma ho 
voluto fare in fretta :)


Ok, quello è per creare una matrice dinamicamente. Ma perchè la mia
matrice statica non funziona per ordini superiori a 10?

io ti butterei li che non funziona perchè la dichiarazione int a[i][j] 
non so esattamente cosa faccia in c ....(nn so se il compilatore C ha i 
vla e come sono gestiti) so solo che sostituita la tua matrice con una 
dinamica  il tutto va tranquillamente quindi mi viene da dire che il 
problema è nella allocazione di a[i][j].... ma di + nn ti so dire :)


Sostituita la matrice, la funzione va fino a ordine 39 non di più

io mi ero fermato a 20 :)
mi sa che ti ho detto una cavolata allora, sorry :)




comunque int a, b=0 inizializza soltanto b a zero: a rimane non inizializzato

 int matrice[i][j];
'j' non viene inizializzata.
Max

Ok grazie, risolto tutto. Adesso arrivo a una matrice di ordine 999,
una cosa immensa ghgh.

 Ok grazie, risolto tutto. Adesso arrivo a una matrice di ordine 999,
Capisco ben poco di C (a livello di esercizi universitari)
ma sto seguendo con interesse questo thread per vedere dove va a finire 
:-) Vorrei capire anche io (speriamo ci riesca) che cos'è che non va :-)

Franco Perilli ha scritto:

Questo inizializza solo i, non so cosa faccia getint, ma direi che non 
restituisce un valore costante, quindi il valore restituito non va bene 
come dimensione per una matrice AFAIK. C99 supporta i VLA, ma non 
ricordo se la cosa si estende alle matrici. Credo di no. Ricorda anche 
che anche nel caso in cui una matrice a dimensione variabile sia 
ammessa, e' molto probabilmente (non e' detto) allocata sullo stack, e 
quindi una matrice 999x999 andrebbe causerebbe uno stack overflow 
(veramente credo che basti molto meno). Io ti consiglio di usare malloc 
in questo modo:
/*seconda_dimensione deve essere costante*/
int (*mat)[seconda_dimensione];
... /*leggi prima_dimensione*/
mat=malloc(prima_dimensione*sizeof(*mat));
mat[primo_indice][secondo_indice]=10;
oppure:
/*entrambe le dimensioni variabili*/
int *mat;
.../*leggi prima e seconda dimensione*/
mat=malloc(prima_dimensione*seconda_dimensione*sizeof(int));
*(mat+seconda_dimensione*primo_indice+secondo_indice)=10;
Le ho scritte senza controllarle, non so se funzionano, comunque l'idea 
e' quella.
-- 
Devaraja (Xdevaraja87^gmail^c0mX)
Linux Registerd User #338167
http://counter.li.org

Sto provando delle funzioni per la somma membro a membro degli elementi
di una matrice creata dinamicamente con malloc. A parte i discorsi sul
free() (per adesso non mi interessa), come mai questa scrittura mi
visualizza sempre 2 come risultato, qualsiasi sia l'input che io do al
programma?
int main()
{
	int i, o;
	i = 0;
	int *matrix1 = (int *)malloc(sizeof(int));
	int *matrix2 = (int *)malloc(sizeof(int));
	matrix1[i] = scanf("%d", &o);
	matrix2[i] = scanf("%d", &o);
	printf("%d\n", (matrix1[i]+matrix2[i]));
	system("Pause");
	return 0;
}

Franco Perilli ha scritto:

Mi sfugge il significato di questo codice, soprattutto non capisco 
perche' allochi dinamicamente usando una dimensione costante, ma magari 
hai solo semplificato il codice prima di postare...
Comunque non c'e' niente di strano nel risultato.. ricorda che scanf 
ritorna il numero di elementi letti con successo, quindi se scanf("%d", 
&o) non ha avuto problemi ritorna 1. Tu assegni il valore di ritorno 
delle due scanf a due interi e poi li sommi.. 1+1=2.. tutto lineare :-)
Forse volevi sommare i due valori letti? Avresti dovuto fare cosi':
scanf("%d", &matrix1[i]);
scanf("%d", &matrix2[i]);
o=matrix1[i]+matrix2[i];


Accidenti che fesso!
Grazie mille!

 vla e come sono gestiti)
I VLA (variable length array)sono entrati a far parte del nuovo standard
C
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Un'ultima cosa: Perchè questo codice per calcolare il determinante di
una matrice, invece di calcolare il determinante visualizza valori
stranissimi?
		determ=matrice[0];
        for(k=1;k<=m;k++)
           { l=k+1;
             for(i=l;i<=o;i++)
               { for(j=l;j<=o;j++)
                matrice[i*o+j] = (
matrice[k*o+k]*matrice[i*o+j]-matrice[k*o+j]*matrice[i*o+k]
)/matrice[k*o+k]; }
        determ = determ * matrice[(k+1)*o+(k+1)];
           }
        printf("%f\n", determ);   
		}
		free(matrice);