[C] Array bidimensionale e dubbio su allocazione

[hurricane86]

Salve a tutti. Ho questo problema:

int (*rows)[2];

E' un array bidimensionale (X righe e 2 colonne) e per alloccare e reallocare memoria uso:

rows = (int (*)[2])malloc(4*sizeof(int(*)[2]));

rows = (int (*)[2])realloc(rows, 4 * (totrows+1) * sizeof(int*));

Il tutto mi funziona ma sono obbligato a mettere quel (4*........) .... la mia logica dice che c'è qualcosa che non va....

Dove sto sbagliando? :berto:

grazie mille

[hurricane86]

nessuno?

[oregon]

Scusa ... mi spieghi il senso della riga dell'allocazione ?

rows = (int (*)[2])malloc(4*sizeof(int(*)[2]));

[CannaDark]

int (*rows)[2];
io invece ero dubbioso proprio su questa dichiarazione qui...
mi ci sto scervellando da un pò... :|

Ma per quello che vuoi fare mi sa che stai cercando di saltare un pò le tappe... o sbaglio?

mi sa che ti ci vogliono 2 puntatori, oppure fai un puntatore unico e riallochi la memoria ogni volta come se fosse di una singola dimensione. Poi gestisci le colonne con l'artificio del modulo no?

non so se mi sono spiegato bene...

EDIT: si anche l'allocazione mi sembra strana :|

[hurricane86]

Originariamente inviato da CannaDark
int (*rows)[2];
io invece ero dubbioso proprio su questa dichiarazione qui...
mi ci sto scervellando da un pò... :|

Ma per quello che vuoi fare mi sa che stai cercando di saltare un pò le tappe... o sbaglio?

mi sa che ti ci vogliono 2 puntatori, oppure fai un puntatore unico e riallochi la memoria ogni volta come se fosse di una singola dimensione. Poi gestisci le colonne con l'artificio del modulo no?

non so se mi sono spiegato bene...

EDIT: si anche l'allocazione mi sembra strana :|

il dubbio è proprio questo...

int (*rows)[2]; è così e non posso cambiarla


voi come allochereste la memoria?


grazie

[oregon]

Io penso che probabilmente intendevi una cosa del genere

   int *rows[2];

   for(int r = 0; r < 2; r++)
      rows[r] = new int[20];

[CannaDark]

in che senso è cosi e non puoi cambiarla?
Il mio problema nasce dal fatto che in fondo un array è un puntatore (se si tolgono le parentesi quadre...)
quindi quando scrivi:
int (*rows)[2];

non riesco a capire in realtà cosa fai...
cioè tu dovresti allocare memoria per un puntatore a un array di due interi...
quindi non è come dire che devi allocare memoria per un puntatore a un puntatore a interi?

Cioè secondo me quella dichiarazione li non funge... :| non so perchè...
ho fatto anche un paio di prove stampando gli indirizzi di memoria, mettendo e togliendo quel 4*.... dalla malloc, ma alla fine mi assegna sempre la stessa memoria per entrambe le soluzioni...
Secondo me ripeto, stai cercando di saltare un paio di tappe...
Comunque cercando di imitarti, o almeno di darti un consiglio ho tirato fuori un pò di codice con puntatori a puntatori, ma non funziona... prima o poi lo posto :P (ma prima lascio che si sistemi questo.. :|)

EDIT:
se fa int *rows[2];
alloca memoria per un array di puntatori...
il risultato potrebbe essere lo stesso, basta poi ragionare con una matrice ruotata di 90 gradi...
solo che a quanto ho capito lui quando fa int (*rows)[2]; vorrebbe fare in modo di allocare con una sola malloc e una sola realloc le due colonne modificando il puntatore rows...
secondo me ha scelto la strada sbagliata...

[CannaDark]

Mi ci sono messo d'impegno perchè mi piace l'allocazione dinamica davvero tanto...
ed ecco quello che è saltato fuori a me...
prova a darci un'occhiata, perchè secondo me è più o meno quello che ti serve...
Notare ovviamente l'uso di un puntatore a puntatore...


DA NOTARE che le colonne sono sempre allocate da zero (mai riallocate!), ma che puoi comunque modificarle prima della compilazione cambiando la riga col define... (attenzione alle free, non sono sicuro che funzionino bene)...
Nota bene anche che per allocare le righe nuove e le colonne ci sono sempre le stesse tre righe di codice... fai una funzione e via! :P

#include <stdlib.h>
#include <stdio.h>

#define COLONNE 3 //qui puoi cambiare il numero di colonne in qualsiasi momento...

int main(){

    int **rows2; //puntatore a puntatore a intero.
    int rows=1; //numero di righe
    int j,i; //contatori
    
    rows=1;  //parto da una riga
    printf("Alloco memoria per riga %d\n",rows-1);
    rows2 = (int**)malloc(rows * sizeof(int*)); //alloco memoria per puntatore riga (memoria per la riga)
    *(rows2+(rows-1)) = (int*)malloc(COLONNE*sizeof(int)); //alloco memoria per interi o meglio alloco la memoria per le colonne
    /*provo a inserire qualche valore*/
    rows2[0][0]=999;
    rows2[0][1]=888;
    rows2[0][2]=555;
    
    rows++; //aggiungo una riga
    printf("Alloco memoria per riga %d\n",rows-1);
    rows2 = (int**)realloc(rows2,rows*sizeof(int*)); //riallogo le righe
    rows2[rows-1] = (int*)malloc(COLONNE*sizeof(int)); //alloco le colonne
    /*provo a inserire qualche valore*/    
    rows2[1][0]=777;
    rows2[1][1]=666;
    rows2[1][2]=444;

    /*aggiungo ancora una riga... sarebbe comodo fare una funzione per queste tre righe di codice...*/
    rows++; //aggiungo una riga
    printf("Alloco memoria per riga %d\n",rows-1);
    rows2 = (int**)realloc(rows2,rows*sizeof(int*));//rialloco le righe
    rows2[rows-1] = (int*)malloc(COLONNE*sizeof(int)); //alloco le colonne
    /*provo a inserire qualche valore*/
    rows2[2][0]=333;
    rows2[2][1]=222;
    rows2[2][2]=111;
    
    /*stampa valori matrice*/
    for(i=0;i<=rows-1;i++)
    {
        j=0;
        while(j<COLONNE) 
        {
        printf("%d ",rows2[i][j]);
        j++;
        }    
        printf("\n");
    }    
    
    /*Libero memoria*/    
    for(i=0;i<=rows-1;i++)
    {
        free(rows2[i]);
    }      
    free(rows2);
    
    /*conclusione*/
    printf("\nFINE\n\n");
    system("pause");
}

[hurricane86]

per prima cosa grazie per le risposte e il codice

int **rows2;

è un array bidimensionale dinamico, è per quello che uso int (*rows)[2]; poichè il numero di colonne è fisso (2) mentre quello che voglio variare è il numero di righe

[CannaDark]

Ho capito, solo che secondo me quello che vuoi fare tu non è molto comodo, e tantomeno elegante (ma è un'opinione mia..)

Il problema è che il metodo che hai scelto tu secondo me non funziona lo stesso...

Anche perchè ti ridpeto che scrivere
int ciao[2];

e scrivere
int *ciao;
ciao = (int*)malloc(2*sizeof(int));

praticamente cambia poco... tranne per il fatto che alla fine col puntatore è dinamico e molto più comodo...


Comunque per quello che vuoi fare tu mi sa che non c'è soluzione diversa... non puoi allocare le righe dinamicamente allocandogli spazio per colonne staticamente...
o fai tutto dinamico o nada...

Al massimo ripeto puoi fare un puntatore dinamico e tutte le volte allocare lo spazio per due interi, poi gestisci tutto con l'operatore modulo....