Newsgroup: it.comp.lang.c++
Titolo: [Dubbio] Matrici

Esiste un modo per definire una matrice a 2 o più  dimensioni senza usare
alcuna libreria (neanche standard)?
Finora ho sempre usato array di puntatori oppure dichiaravo un array ad una
dimensione ed usavo una funzione che traformava gli indici di matrice in
indice dell'array.
Esiste un modo più semplice?
Grazie

Ma una cosa del genere non va bene?
int i, m=3, n=3;
float** A;
A = new float*[m];
for (i=0; i<m; i++)
    A[i] = new float[n];
A questo punto puoi accedere A[i][j] normalmente...
Nota che per deallocare poi devi fare:
for (i=0; i<m; i++)
    delete [] A[i];
delete [] A;
Al limite potresti scrivere una classe che wrappi tutto questo..
O meglio, trovarne una già fatta...
-Burattino-

 ha scritto nel messaggio
news:pm4J9.25944$t_1.2...@tornado.fastwebnet.it...



basterebbe mettere il tutto dentro una classe, condire con qualche variabile
privata che tiene conto di numero di righe e colonne e il piatto è servito!
Bye
Antonio


Guarda che nel codice che ti ho postato non c'è uso di nessuna libreria!
(o meglio.. new e delete se non erro fanno parte della lib. standard, che
però tutto sommato E' C++, o sbaglio? ..e cmq quello che ho fatto con new e
delete si può fare anche con malloc etc..)
-Bura-

 }
Per me sarebbe stato perfetto e naturale da scrivere, conoscendo già i
vettori! Mah: tra definire nel prototipo la dimensione e farlo a
runtime, a me piacerebbe molto di più la seconda! Del resto a me il
C/C++ piaceva anche e sopratutto perché non faceva il benché minimo
controllo se questo non era voluto! Come mai questa scelta? Necessaria?
Devo dire altre due cose:
la classe <vector> della stl è stupenda, ma fa schifo! ^_-
L'accesso all'i-simo elemento era fantastico con un semplice v[i] !
Adesso è ancora possibile farlo?
Esiste il concetto di "suono" per il C++ o dipende dalla piattaforma?
Se volessi inviare qualcosa (di breve e non sofisticato) alla sk audio,
dovrei mandare l'audio su /dev/audio in unix o usare qualche libreria
sotto win?
Come mai non fanno delle procedure standard?
Perché non creano un bel #include <standard_functions> in cui inserire
tutta sta robina, come pulitura dello schermo e così via?
L'ultima volta, quando ho visto quel system ("pause"); sotto win, non
c'ho visto più e ... ho usato __asm [...] per pulire lo schermo! ^_-
Non mi pare 'na cosa difficile da fare:
1- TUTTI i sistemi operativi devono definire una _stessa_ variabile
globale (magari una classe) OSNAME in cui c'è la descrizione completa
del S.O.!
2- Si crea quell'include di cui sopra in cui al valore di OSNAME associa
la determinata funzione di quel S.O.!
Così, potremo scrivere nel programma...
clear_screen( OSNAME.name );
Oppure
clear ( OSNAME.device.output(0) , OSNAME.name );
Ok, I'm going to kill me now. Ma prima di morire, spiegatemi questi
perché, pleeease! ^_^
Grazie mille!
Salvatore Ferri

 ossia si passava il nome del vettore e la sua lunghezza totale?
Una volta avevo risposto ad una domanda simile su una mailing list: 
faccio il copia&incolla di quel messaggio:
-- punto 1: cosa fa l'operatore [] ? --
cosa fa in realta` l'operatore []? Sappiamo tutti che serve per accedere 
agli elementi di un array, ma come funziona? Lo standard dice 
esplicitamente che la scrittura:
        a[10]
equivale *esattamente* a quest'altra:
        *(a+10)
(da notare che questa equivalenza rende possibile scrivere anche belle 
cose tipo 2["Antonio"])
-- punto 2: cosa fa l'operatore + sui puntatori? --
Se noi abbiamo
        some_type ptr*;
        ptr + n;
Lo standard dice che ptr deve essere incrementato di n*sizeof(some_type) 
byte. Ricordiamocelo, ci servira` in seguito.
-- punto 3: cosa succede quando scrivo array[x][y]? --
supponiamo di avere:
        int a[10][20];
        a[3][7] = 0;
Cosa fa il compilatore? Il tipo di a e` int[10][20], ma il compilatore 
puo` applicare l'operatore [] solo ed esclusivamente sui puntatori; 
fortunatamente esiste una conversione implicita da vettore a puntatore, 
quindi il compilatore la interpreta grosso modo in questo modo:
        int a[10][20];
        int (*ptr1)[20] = a; // ptr1 e` un puntatore a int[20]
ora il compilatore sa come applicare l'operatore [3] a ptr1, quindi 
diventa (cfr con il punto 1)
        (*(ptr1 + 3)) [7];
Sappiamo dal punto 2 che ptr1 + 3 vuol dire sommare 3*sizeof(ptr1) byte. 
Il tipo di ptr1 e` int(*)[20], quindi sizeof(ptr1) vale 20*sizeof(int).
Ci rimane solo da applicare anche l'operatore [7]. Per farlo il 
compilatore fa come prima: converte il vettore nel puntatore al suo 
primo elemento, poi applica l'operatore:
        int a[10][20];
        int (*ptr1)[20] = a;
        int *ptr2 = *(ptr1 + 3);
        ptr2[7] = 0;
Ora e` semplice: il compilatore trasforma la riga precedente in
        *(ptr2 + 7) = 0
il che equivale ad aggiungere 7*sizeof(int) a ptr2.
Se hai seguito tutto il discorso ti sei accorto che, dato:
        const x = ...;
        const y = ...;
        int a[x][y];
Per accedere alla locazione [a][b] dell'array il compilatore accede alla
        (a*y + b) * sizeof(int)
cella di memoria a partire dall'inizio dell'array. Questo significa due 
cose:
1) la memoria di una matrice e` tutta contigua.
2) per trovare un elemento il compilatore deve conoscere il valore della 
seconda dimensione (la costante y nell'esempio). Ecco il motivo per cui 
per passare un matrice ad una funzione devi specificare la seconda 
dimensione nella dichiarazione.
spero di essere stato chiaro,
ciao Anto
-- 
"Computer science is not about computers any more than astronomy
is about telescopes." -- EW Dijkstra

 spero di essere stato chiaro,
Chiarissimo, grazie; anche se già conoscevo come accedere in quel modo
agli elementi. :) Sulla parte restante alcun commento? (:
Ciao,
Salvatore

 agli elementi. :) Sulla parte restante alcun commento? (:
solo uno: puoi accedere agli elementi di un vector anche con [], come i 
normali array.
Ti consiglio di studiare con attenzione la libreria standard, e` 
veramente molto utile: i libri consigliati sono sempre i soliti 
(Stroustrup, Lippman, Eckel - c'e` anche il Josuttis che tratta *solo* 
della lib. standard); cmq se vuoi una "introduzione" a std::vector trovi 
un mio articolo su 
cpp.programmazione.it
: si intitola "Una panoramica 
sulla libreria standard".
