Creare una matrice dinamica e stamparla

di
Anonimizzato18783
il
5 risposte
/
Anonimizzato18783
Utente anonimizzato

Creare una matrice dinamica e stamparla

Vorrei creare una matrice (provvisoriamente quadrata di ordine 5 e con dentro tutti degli 1) in una funzione e stamparla tramite il main ma non ho idea di cosa far ritornare dalla funzione, questo è il codice...

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


int** matrice(int righe, int colonne){

int **matrix;
int i, k, j;

matrix = (int**) malloc(righe*sizeof(int*));

for(i=0; i<righe; i++) matrix = (int*) malloc(colonne*sizeof(int));


for(j=0; j<righe; j++){
for(k=0; k<colonne; k++) matrix[j][k] = 1;
}

return matrix;
}



int main(){

printf("%d", matrice(5, 5));

return 0;
}

5 Risposte

  • /
    Anonimizzato9336
    Utente anonimizzato

    Re: Creare una matrice dinamica e stamparla

    Questo è un classico assoluto in ambito didattico. Questa versione contiene anche tutto il codice per la programmazione difensiva e le relative #define per la simulazione dei faults, che per il momento possono essere tranquillamente ignorate privilegiando la comprensione della logica di base, ma vanno comunque tesaurizzate per il futuro. 
    
/************************************************************************/
/** Scopo del programma:                                               **/
/** Allocazione didattica di array nested (multidimensionali)          **/
/************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#define ASIZE (8)

typedef enum {FALSE, TRUE} Bool_t;

#ifdef ALLOC_FAIL_02
  #ifdef ALLOC_FAIL_01
    #undef ALLOC_FAIL_01
  #endif
  #pragma message (">> TEST VERSION compiled with ALLOC_FAIL_02 defined")
#endif
#ifdef ALLOC_FAIL_01
  #pragma message (">> TEST VERSION compiled with ALLOC_FAIL_01 defined")
#endif

Bool_t matrix_alloc(int ***m, const unsigned int row, const unsigned int col)
{
    unsigned int i;

    assert(row > 0);
    assert(col > 0);

    /*
    ** PRIMO STEP: allocazione array di base
    */
#ifdef ALLOC_FAIL_01
    *m = NULL;
#else
    *m = (int **)malloc(row * sizeof(int *));
#endif

    if (NULL == *m)
    {
        fputs("Errore di allocazione base array !\n", stderr);
        return (FALSE);
    }

    for (i = 0; i < row; ++i)
    {
        int *p;
        /*
        ** SECONDO STEP: allocazione di ogni singolo array-riga
        */
        p = (int *)malloc(col *sizeof(int));
#ifdef ALLOC_FAIL_02
        if (row -1 == i)
        {
            free(p);
            p = NULL;
        }
#endif
        if (NULL != p)
        {
            /*
            ** TERZO e ULTIMO STEP: collegamento riga ad array base
            */
            (*m)[i] = p;
        }
        else
        {
            fprintf(stderr, "Errore di allocazione alla riga %d!\n"
                    "Deallocazione array: ", i);
            while (i--)
            {
                free((*m)[i]);
                fprintf(stderr, "%d ", i);
            }
            free(*m);
            return (FALSE);
        }
    }

    return (TRUE);
}

int main(void)
{
    int **array, righe, colonne;
    int i, j;
    Bool_t status;

    righe   = ASIZE;
    colonne = ASIZE;

    printf("Allocazione dinamica di un array "
           "bidimensionale %d x %d\n",
           righe, colonne);

    status = matrix_alloc(&array, righe, colonne);

    if(status)
    {
        printf("** Allocazione effettuata. "
               "Inizializzazione di %d celle in corso...\n",
               righe * colonne);

        for (i = 0; i < righe; ++i)
        {
            for (j = 0; j < colonne; ++j)
            {
                array[ i ][ j ] = i * 10 + j;
            }
        }

        puts("** Contenuto dell'array:");
        for (i = 0; i < righe; ++i)
        {
            for (j = 0; j < colonne; ++j)
            {
                printf( "array[%d][%d] = %02d\n", i, j, array[ i ][ j ]);
            }
            puts("");
            free(array[i]);
        }
        free(array);
    }

    return (EXIT_SUCCESS);
}/* EOF: alloc_array.c */

    PS: quando presenti codice sorgente, devi usare gli appositi tag Code.
  • /
    Anonimizzato18783
    Utente anonimizzato

    Re: Creare una matrice dinamica e stamparla

    Credo di non aver capito nulla, in sintesi cos'ha di sbagliato il mio codice?
  • /
    Anonimizzato9336
    Utente anonimizzato

    Re: Creare una matrice dinamica e stamparla

    Leoddio ha scritto:

    credo di non aver capito nulla, in sintesi cos'ha di sbagliato il mio codice?
    Un po' di tutto, partendo dal fatto che non controlli che ogni allocazione vada a buon fine, fino al "return matrix" eseguito nel bel mezzo di un inner loop, totalmente privo di senso.
  • /
    Anonimizzato18783
    Utente anonimizzato

    Re: Creare una matrice dinamica e stamparla

    ...
  • O
    oregon
    Super Famoso
    Iscritto da
    nov, 2011
    Messaggi:
    21896

    Re: Creare una matrice dinamica e stamparla

    Leoddio ... il codice che hai mostrato è sbagliato solo nella parte del main in cui visualizzi. Non puoi usare una sola printf per visualizzare tutti gli elementi della matrice. Devi impostare due cicli esattamente come quando la riempi. Ad esempio così
    
int** matrice(int righe, int colonne)
{
	int **matrix;
	int i, j;

	matrix = (int**) malloc(righe*sizeof(int*));
	for(i=0; i<righe; i++) 
		matrix[i] = (int*) malloc(colonne*sizeof(int));

	for(i=0; i<righe; i++)
		for(j=0; j<colonne; j++) 
			matrix[i][j] = 1;

	return matrix;
}

int main()
{
	int i, j;

	int **m = matrice(5, 5);
	
	for(i=0; i<5; i++)
	{
		for(j=0; j<5; j++)
			printf("%d\t", m[i][j]);

		printf("\n");
	}

	return 0;
}
    Questo è il "minimo" che devi fare ma dovresti prevedere - come ti ha detto MAW - anche del codide per prevedere i casi in cui la malloc fallisca (per mancanza di memoria).
Devi accedere o registrarti per scrivere nel forum
5 risposte