[C] Allocazione memoria per array/matrici

[alex1986]

Buonasera a tutti!!!

Il mio problema è il seguente: sto cercando di creare una funzione che mi permetta di girare una matrice di dimensioni l x h verso destra o verso sinistra...

Dato che non si tratta appunto di una matrice "quadrata", pensavo di creare un secondo array con le dimensioni invertite h x l..

quindi, per prima cosa alloco la memoria necessaria per il secondo array r, metto il contenuto del primo array p in r, svuoto p, alloco memoria per un nuovo p di dimensioni h x l, metto il contenuto di r in p e infine svuoto r...alla fine return p...

Ovviamente metto in pratica il tutto e non funziona -.-''

Secondo voi dove sbaglio??

Posto il codice:

char** destra(int l, int h, char **p){


int i, j;
char **r;


r=(char **) malloc( l * sizeof(char *));
for (i=0; i<l; i++){
r[i]=(char *) malloc( h * sizeof(char));
}


for(i=0; i<l; i++){
for(j=0; j<h; j++){
r[i][j]=p[h-j-1][i];
}
}


for (i=0;i<h;i++)
free(p[i]);
free(p);


p=(char **) malloc( l * sizeof(char *));
for (i=0; i<l; i++){
p[i]=(char *) malloc( h * sizeof(char));
}


for(i=0; i<l; i++){
for(j=0; j<h; j++){
p[i][j]=r[i][j];
}
}


for (i=0;i<l;i++)
free(r[i]);
free(r);
return p;
}

Spero si capisca il problema...grazie per l'attenzione

[alex1986]

Cioè ho fatto delle prove e l' array r viene stampato correttamente, quindi vuol dire che la prima parte funziona...

quando però devo rimettere il contenuto di r in p non stampa nulla...

[YuYevon]

Il mio problema è il seguente: sto cercando di creare una funzione che mi permetta di girare una matrice di dimensioni l x h verso destra o verso sinistra...

Dato che non si tratta appunto di una matrice "quadrata", pensavo di creare un secondo array con le dimensioni invertite h x l..

Che significa "ruotare"? Devi fare la matrice trasposta?

http://it.wikipedia.org/wiki/Matrice_trasposta

Forse è meglio se posti ance main(), per vedere come hai definito la matrice p.

[alex1986]

No non intendo la trasposta, ma proprio il risultato di una rotazione verso destra o verso sinistra...cioè non saprei come spiegarlo, ma è semplice...anche perchè la matrice rappresenta lo schema di un labirinto, quindi ci sono uni e zeri(o comunque dei numeri), e per rotazione vuol dire che se la matrice è:

0 1 2 3
4 5 6 7
8 9 0 1

il risultato di una rotazione verso destra sarebbe:

8 4 0
9 5 1
0 6 2
1 7 3

Ma fortunatamente il problema non è questo, cioè la rotazione me la fa perfettamente e così il riempimento dell' array r...

Il main è il seguente:

int main(){
int l, h, s, i, j;
char mode[3], **matrice;

// Fase di acquisizione input

scanf("%s", mode);
scanf("%d%d", &l, &h);
scanf("%d", &s);

// Allocazione memoria per matrice labirinto

matrice=nuova(l, h, matrice);

// Riempimento matrice labirinto

for (i=0; i<h; i++){
for (j=0;j<l;j++){
scanf("%s", &matrice[i][j]);
}
}

// Risolvi labirinto

destra(l, h, matrice);

// Stampa soluzione

printf("\n\n\n%s\n", mode);
printf("%d %d\n", l, h);
printf("%d\n", s);
soluzione(l, h, matrice);
azzera(h, matrice);

return 0;
}

e la funzione che definisce la matrice è:

char** nuova(int l, int h, char **p){
int i, j;
p=(char **) malloc( h * sizeof(char *));
for (i=0; i<h; i++){
p[i]=(char *) malloc( l * sizeof(char));
}
return p;
}

[alex1986]

Ops...funziona!!!

Ho sbagliato io, nel commentare delle parti ho incluso anche parte del codice necessario

Grazie comunque

[YuYevon]

Se dici che funziona non perdo tempo a controllarlo, anche perché non ho capito il senso di alcune variabili (tipo "s" o "mode"...) e funzioni (azzera() e soluzione())

Comunque in tutta sincerità questa funzione

char** nuova(int l, int h, char **p){
   int i, j;

   p=(char **) malloc( h * sizeof(char *));

   for (i=0; i<h; i++){
      p[i]=(char *) malloc( l * sizeof(char));
   }

   return p;
}

scritta così non mi piace molto, perché quando un parametro è sia di input che di output è "carino" passarlo per riferimento... ora poiché il parametro in questione è già un puntatore a puntatore, passarlo per riferimento significa passare un puntatore a puntatore a puntatore, e se non si fa attenzione si rischia di invecchiare presto

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

void my_alloc(int ***x)
{
	int i;
	*x = (int **) malloc ( 10 * sizeof(int *) );

	for ( i = 0; i < 10; i++ )
		*(*x+i) = (int *) malloc( 10 * sizeof(int) );
}

void my_free(int ***x)
{
	int i;

	for ( i = 0; i < 10; i++ ) {
		free(*(*x+i));
		*(*x+i) = NULL;
	}

	free(*x);

	*x = NULL;
}

int main(void)
{
	int **x, i, j;

	my_alloc(&x);

	for ( i = 0; i < 10; i++ )
		for ( j = 0; j < 10; j++ )
			x[i][j] = rand()%10;

	for ( i = 0; i < 10; i++ ) {
		for ( j = 0; j < 10; j++ )
			printf("%d ", x[i][j]);
		putchar('\n');
	}

	my_free(&x);

	return 0;
}

(è chiaro che sia l'esempio di sopra che il prossimo ricorrono a dimensioni fisse della matrice - 10x10 - ma non ci vuole nulla a generalizzarli...)

Il modo più "cristiano" di operare in questo caso sarebbe quello di ricordare che, almeno in C (e ovviamente non è così per tutti i linguaggi) una matrice non è nient'altro che un array costituito dalle colonne della matrice stessa una dopo l'altra, quindi la matrice

1 2 3
4 5 6
7 8 9

in memoria viene salvata come

1
2
3
4
5
6
7
8
9

quindi a questo punto la matrice x di cui sopra si può dichiarare come un semplice puntatore e poi utilizzare la mappa di memorizzazione per accedere ai suoi elementi. Il programma di sopra diventa quindi

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

void my_alloc(int **x)
{
	*x = (int *) malloc ( 10 * 10 * sizeof(int) );
}

void my_free(int **x)
{
	free(*x);
	*x = NULL;
}

int main(void)
{
	int *x, i, j;

	my_alloc(&x);

	for ( i = 0; i < 10; i++ )
		for ( j = 0; j < 10; j++ )
			*(x + i*10 + j) = rand() % 10;

	for ( i = 0; i < 10; i++ ) {
		for ( j = 0; j < 10; j++ )
			printf("%d ", *(x + i*10 + j));
		putchar('\n');
	}

	my_free(&x);

	return 0;
}

dove la mappa di memorizzazione (che si può vedere in entrambi i for) in generale è la seguente:

*(indirizzo_base_array + indice_di_riga * n_colonne + indice_di_colonna)

[alex1986]

Ma no le variabili e le funzioni che hai citato servono a fare altro...non son stato lì a spiegarle perchè non centravano con il problema

comunque grazie per tutta la spiegazione...me la studierò

non sono un esperto di C, sto facendo un esame di uni e quindi incappo in errori o sintassi poco carine...

piano piano imparerò

grazie ancora!!!

[alex1986]

Eccomi di nuovo, come suggerito da YuYevon ho modificato le funzioni in void e volevo chiedervi gentilmente se queste poche righe di codice sono scritte giuste:

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

// Funzione per allocare memoria

void crea(int h, int l, int ***p)
{
int i;
*p = (int **) malloc ( h * sizeof(int *) );

for ( i = 0; i < h; i++ )
*(*p+i) = (int *) malloc( l * sizeof(int) );
}

// Funzione per liberare memoria

void libera(int h, int ***p)
{
int i;

for ( i = 0; i < h; i++ ) {
free(*(*p+i));
*(*p+i) = NULL;
}

free(*p);

*p = NULL;
}

// Funzione per stampare soluzione

void soluzione(int l, int h, int **p){
int i, j;
for (i=0; i<h; i++){
for (j=0; j<l; j++){
printf("%d ", p[i][j]);
}
printf("\n");
}
}

int main(void){
int **p, l, h, i, j;

// Fase di acquisizione input

scanf("%d%d", &l, &h);

// Allocazione memoria per matrice

crea(h, l, &p);

// Riempimento matrice

for (i=0; i<h; i++){
for (j=0;j<l;j++){
scanf("%d", &p[i][j]);
}
}

// Stampa soluzione

printf("%d %d\n", l, h);
soluzione(l, h, &p);
libera(h, &p);

return 0;
}

Ve lo chiedo perchè non funziona come dovrebbe

Grazie!!!

[LeleFT]

@alex1986: il tag da usare quando si posta il codice è CODE, non QUOTE.
Inoltre, il linguaggio di programmazione usato va espressamente indicato nel titolo.

Correggo io il titolo.


Ciao.

[MacApp]

Originariamente inviato da alex1986
volevo chiedervi gentilmente se queste poche righe di codice sono scritte giuste:

Il tuo compilatore non ti dice nulla?

$ gcc main.c 
main.c: In function 'main':
main.c:66: warning: passing argument 3 of 'soluzione' from incompatible pointer type

nel tuo codice:

void soluzione(int l, int h, int **p){
...
int main(void){
...
int **p, l, h, i, j;
...
soluzione(l, h, &p);

anziché passare l'indirizzo di un puntatore ad intero, passi l'indirizzo di un puntatore di un puntatore ad intero.