Newsgroup: it.comp.lang.c
Titolo: newbie, matrici e puntatori

Sono un "non" programmatore C (devo usarlo per forza per utilizzare una
libreria C in un mio programma python.) e quindi ho problemi con le cose
basilari.
La libreria mi restituisce un buffer di N unsigned char e la sua
dimensione in "altezza" e "larghezza" ogni volta che la chiamo.
Vorrei fare in modo di avere un buffer finale con "sommati" in larghezza
tutti i buffer, richiamabili in qualche modo poi dal mio programma
python. (posso richiamare tutti i tipo del C)
Qualcosa tipo: 20x85 + 40x85 + 10x85 = 70x85 (85 è definito a priori)
Guardando un po su questo ng, ho provato a fare un po' di cose, ma alla
fine sempre access violation mi ritrovo...
Per me sarebbe ideale una cosa tipo:
array di N puntatori a N matrici di larghezza variabile (aventi le
misure di prima)
Ho provato con:
unsigned char * MM[num_chars];
for ( n = 0; n < num_chars; n++ ) {
  unsigned char matrice[larghezza][altezza];
  matrice[n] = *matrice;
  riempi(MM[n], buffer, dimensioni, altro...)
riempi( unsigned char * matrice, buffer, ....) {
  unsigned char ** myarray = &matrice;
  for ( i = L, p = 0; i < x_max; i++, p++ ) {
     //colonne
     for ( j = startP, q = 0; j < maxAlto; j++, q++ ) {
       myarray[j][i] |= buffer[q * P + p];
     }
   }
Posso dire che il problema non è buffer.
Grazie a chi vorrà aiutarmi.
Michele

 Qualcosa tipo: 20x85 + 40x85 + 10x85 = 70x85 (85 è definito a priori)
Non capisco cosa intendi per " "sommati" in larghezza ", la libreria.. una 
funzione di questa immagino.. ti restituirà presumo un puntatore ad un array 
di N unsigned char e la sua dimensione in altezza e larghezza .. che ci devi 
fare??? Qualcosa tipo 20x85 + 40x85 ... non chiarifica affatto ciò che 
intendi fare.. non a me per lo meno...
Se intendi dire che chiami più volte la funzione e lavori quindi con più 
buffer già mi sembra di essere più vicino a capire.. ipotizzando che sia 
cosi ancora non mi è molto chiaro cosa to intenda per sommare in larghezza:
supponiamo che tu abbia delle matrici di ritorno xi di dimensioni MxN 
variabili a questo punto che ci devi fare? 

InuY4sha ha scritto:

Forse la sua domanda sembra piu' difficile di quello che e' perche' l'ha 
posta nel modo piu' contorto possibile :-) Quello che mi sembra di 
capire e' che date n matrici x*y vuole ottenere un'unica matrice 
(x1+x2+...xn)*y
In questo caso, senza modificare le funzioni di libreria crei una 
matrice unica e ci copi quelle restituite in ordine. E ricorda che in C 
non vengono passate o restituite le matrici intere ma solo puntatori.
-- 
Devaraja (Xdevaraja87^gmail^c0mX)
Linux Registerd User #338167
http://counter.li.org

  variabili a questo punto che ci devi fare?
Con un for chiamo N volte la libreria, che ogni volta mi ritorna un
buffer e le sue dimensioni.
Io vorrei avere. alla fine del ciclo, un buffer unico esterno all
libreria che chiamo, in una forma qualsiasi, diciamo se è possibile il
più semplice possibile. La forma del buffer finale potrebbe essere
quella che intendevo con "sommato in larghezza", quindi se chiamo tre
volte la libreria che mi restituisce tre buffer buffer di dimensioni
20x85,  40x85, 10x85, io vorrei, tramite un funzione esterna, avere un
buffer di dimensioni 70x85 [1]
Oppure, come cercavo di fare nel codice precedentemente postato è creare
un array di puntatori a carattere (tanti quanti sono i miei cicli), che
conterranno i puntatori alle mie matrici create al volo quando conosco
le dimensioni del buffer.
Alla funzione incaricata di inserire i valori nella mia matrice, passo
il puntatore alla matrice stessa e la funzione "dovrebbe" (visto che non
sono riuscito a farlo) riempire la matrice stessa. Il codice non lo sto
a riscrivere, visto che lo riscriverei uguale.
Grazie.
Michele
[1]
es con numeri righe e colonne un po' più piccole :) :
primo buffer 3x5
---
---
---
---
---
secondo 4x5
++++
++++
++++
++++
++++
terzo 2x5
**
**
**
**
**
risultato cercato:
---++++**
---++++**
---++++**
---++++**
---++++**

 ma solo puntatori.
Sembra facile :)
Ci riprovo...
Grazie,
Michele

Michele Petrazzo ha scritto:

Potresti creare un array di puntatori, poi in un for richiami la tua 
funzione x volte e ogni volta metti il puntatore restituito in un nuovo 
elemento dell'array e sommi la larghezza dell'array corrente. Alla fine 
del for avrai un array di puntatori a matrici dell'altezza specificata e 
un intero che ti dice quanto deve essere larga la matrice "somma". A 
questo punto basta allocare lo spazio per la m finale e copiarci le m 
precedenti una dopo l'altra.


> Potresti creare un array di puntatori
Penso che sia l'unico metodo essendo le matrici di dimensione aleatoria: 
cioč te lasci le matrici dove sono e ti memorizzi l'indirizzo di ognuna in 
un array definito cosi tipo
unsigned char* array[100];
array[0] = &matrice1[0]; // = matrice1;
array[1] = &matrice2[0];
//....
Quindi se devi accedere alla quarta riga della terza colonna della decima 
matrice CONOSCENDONE LE DIMENSIONI M e N fai cosě:
unsigned char access(int matrix, int row, int column){
    return *(array[10] + M*4 + 3);
}
L'associazione della matrice ai dati sulla sua dimensione la farei mediante 
una STRUCT ( e qua ti leggi una guidarella ..): in questo modo te avresti un 
tipo di dato contenente matrice, n. di righe e n di colonne e modificheresti 
access indicando come parametro di ingresso non int matrix ma l'indirizzo 
della STRUCT.. come non mi chiedere che nn l'ho usata quasi mai e non son 
pratico ( ma č facile) 

> Penso che sia l'unico metodo essendo le matrici di dimensione aleatoria:
Non solo, ma se anche le matrici avessero una dimensione massima sarebbe 
poco efficiente ricopiarne tutti i dati di volta in volta per accostarle... 
meglio aggiungere una dimensione :)