Pagina 1 di 2 1 2 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 11
  1. #1

    Allocazione memoria per array/matrici

    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

  2. #2
    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...

  3. #3
    Utente di HTML.it
    Registrato dal
    Jul 2008
    Messaggi
    1,326
    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.
    every day above ground is a good one

  4. #4
    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;
    }

  5. #5
    Ops...funziona!!!

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

    Grazie comunque

  6. #6
    Utente di HTML.it
    Registrato dal
    Jul 2008
    Messaggi
    1,326
    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

    codice:
    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

    codice:
    #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

    codice:
    #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:

    codice:
    *(indirizzo_base_array + indice_di_riga * n_colonne + indice_di_colonna)
    every day above ground is a good one

  7. #7
    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!!!

  8. #8
    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!!!

  9. #9
    Moderatore di Programmazione L'avatar di LeleFT
    Registrato dal
    Jun 2003
    Messaggi
    17,320

    Moderazione

    @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.
    "Perchè spendere anche solo 5 dollari per un S.O., quando posso averne uno gratis e spendere quei 5 dollari per 5 bottiglie di birra?" [Jon "maddog" Hall]
    Fatti non foste a viver come bruti, ma per seguir virtute e canoscenza

  10. #10
    Originariamente inviato da alex1986
    volevo chiedervi gentilmente se queste poche righe di codice sono scritte giuste:
    Il tuo compilatore non ti dice nulla?
    codice:
    $ gcc main.c 
    main.c: In function 'main':
    main.c:66: warning: passing argument 3 of 'soluzione' from incompatible pointer type
    nel tuo codice:
    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.

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.