C/C++ - Creare vettori/matrici di puntatori con poco codice

Forum - C/C++ - Creare vettori/matrici di puntatori con poco codice

Pagine: [ 1 2 ]

AldoBaldo (Member)
Guru

Messaggi: 700
Iscritto: 08/01/2015

Postato alle 12:30
Domenica, 30/07/2017

E rieccomi con uno dei miei "esperimenti" per reinventare la ruota...

L'idea, questa volta, è avere a disposizione delle funzioni "stand alone" per allocare e deallocare in memoria dinamica vettori e matrici di qualsiasi tipo con il minor sforzo possibile (una riga di codice, una verifica). Dopo un po' di lavorio mentale (ho i miei limiti) sono arrivato a "sintetizzare" quattro funzioncine, due per creare/distruggere vettori e due per creare/distruggere matrici. Mentre le funzioni che riguardano i vettori non hanno bisogno nessun supporto esterno, quelle che riguardano le matrici s'appoggiano alle funzioni che riguardano i vettori.

Ve le propongo perché mi piacerebbe sapere se ci vedete qualche problema, soprattutto per quel che riguarda eventuali puntatori impazziti o memoria non deallocata a dovere. Nel frattempo continuo con i test, che finora ho completato solo in minima parte.

Edit: noto ora che per qualche ragione la formattazione del codice viene "disturbata" dalla presenza degli apostrofi all'interno dei commenti; per aggirare la questione metto i commenti DOPO il codice, sperando che funzioni.

Codice sorgente - presumibilmente C++

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h> /* vedi nota */
 
/*===> distruggi_vettore() <==================================================*/
 
int distruggi_vettore( void *vettore, size_t qEl ) {
    if( vettore && qEl ) {
        uintptr_t *v = vettore; /* puntatore ausiliario */
        size_t e; /* contatore per gli elementi del vettore */
 
        for( e=0; e<qEl; ++e )
            free( (void*)v[e] );
        free( vettore );
        return 1; /* 1 = tutto bene */
    }
 
    return 0; /* 0 = errore */
}
 
/*===> crea_vettore() <=======================================================*/
 
void *crea_vettore( size_t qEl, size_t dimEl ) {
    uintptr_t *v = NULL; /* v = vettore */
 
    if( qEl && dimEl ) {
        v = calloc( qEl, sizeof(uintptr_t) );
 
        if( v ) {
            size_t e; /* contatore per gli elementi  del vettore*/
 
            for( e=0; e<qEl; ++e ) {
                v[e] = (uintptr_t) calloc( 1, dimEl );
                if( !v[e] ) break;
            }
 
            if( e < qEl ) { /* allocazione non completata */
                distruggi_vettore( v, e );
                v = NULL;
            }
        }
    }
 
    return v;
}
 
/*===> distruggi_matrice() <==================================================*/
 
int distruggi_matrice( void *matrice, size_t qRighe, size_t qColonne ) {
    if( matrice && qRighe && qColonne ) {
        uintptr_t **m = matrice; /* puntatore ausiliario */
        size_t r; /* contatore per le righe della matrice */
 
        for( r=0; r<qRighe; ++r )
            distruggi_vettore( m[r], qColonne );
        free( m );
        return 1; /* 1 = tutto bene */
    }
 
    return 0; /* 0 = errore */
}
 
/*===> crea_matrice() <=======================================================*/
 
void *crea_matrice( size_t qRighe, size_t qColonne, size_t dimEl ) {
    uintptr_t **m = NULL; /* m = matrice */
 
    if( qRighe && qColonne && dimEl ) {
        m = calloc( qRighe, sizeof(uintptr_t) );
 
        if( m ) {
            size_t r; /* contatore delle righe della matrice */
 
            for( r=0; r<qRighe; ++r ) {
                m[r] = crea_vettore( qColonne, dimEl );
                if( !m[r] ) break;
            }
 
            if( r < qRighe ) { /* allocazione non completata */
                for( --r; r<((size_t)-1); --r )
                    distruggi_vettore( m[r], qColonne );
                free( m );
                m = NULL;
            }
        }
    }
 
    return m;
}
 
/*==============================================================================
ESEMPI DI USO
==============================================================================*/
 
void esempio_vettore( void ) {
    const int qe = 10;
    int **vettore = NULL; // doppia indirezione! (qualsiasi tipo)
    int e;
 
    vettore = crea_vettore( qe, sizeof(**vettore) );
 
    if( vettore ) {
        /* "popola" il vettore con valori crescenti */
        for( e=0; e<qe; ++e )
            *vettore[e] = e+1;
 
        /* mostra in console il contenuto del vettore */
        printf( "\nVETTORE\n" );
        for( e=0; e<qe; ++e )
            printf( "%d%c", *vettore[e], e<qe-1?' ':'\n' );
 
        /* libera la memoria allocata */
        if( !distruggi_vettore(vettore,qe) )
            printf( "\nVettore non distrutto.\n" );
    }
    else {
        printf( "\nVettore non creato.\n" );
    }
}
 
void esempio_matrice( void ) {
    const int qr = 5, qc = 5; /* qr = quantita righe; qc = quantita colonne */
    int ***matrice = NULL; // tripla indirezione! (qualsiasi tipo)
    int r, c; /* contatori per le righe e per le colonne */
 
    matrice = crea_matrice( qr, qc, sizeof(***matrice) );
 
    if( matrice ) {
        /* "popola" la matrice con valori dei quali la prima cifra
           rappresenta la riga e la seconda cifra la colonna */
        for( r=0; r<qr; ++r )
            for( c=0; c<qc; ++c )
                *matrice[r][c] = (r+1)*10 + c+1;
 
        /* mostra in console il contenuto della matrice */
        printf( "\nMATRICE\n" );
        for( r=0; r<qr; ++r )
            for( c=0; c<qc; ++c )
                printf( "%d%c", *matrice[r][c], c<qc-1?' ':'\n' );
 
        /* libera la memoria allocata */
        if( !distruggi_matrice(matrice,qr,qc) )
            printf( "\nMatrice non distrutta." );
    }
    else {
        printf( "\nMatrice non creata.\n" );
    }
}
 
int main() {
    esempio_vettore();
    esempio_matrice();
 
    printf( "\nPremi \"invio\" per lasciare il programma...\n\n" );
    while( getchar() != '\n' );
 
    return 0;
}

NOTA su stdint.h e uintptr_t
Le funzioni fanno uso del tipo uintptr_t, definito nel file di include stdint.h. La descrizione di uintptr_t che viene data in quel file è: "Integer type capable of holding object pointers".

Commento su distruggi_vettore()
Dato un vettore di puntatori generici che puntano a memoria allocata dinamicamente con malloc, calloc o realloc, la funzione libera la memoria puntata dai singoli puntatori elementi del vettore e quella allocata dall'array di puntatori stesso.
Ne consegue che, in uscita, TUTTA la memoria dinamica risulterà liberata e il puntatore passato come parametro in "vettore" sarà un puntatore non valido.
Se la funzione ha successo restituisce 1, in caso d'errore restituisce 0.
N.B. Nonostante il puntatore passato nel parametro "vettore" sia indicato come void* per evitare la necessità di un cast esplicito, ci si attende che il parametro sia un puntatore a doppia indirezione (ad esempio, char** o int**).

Commento su crea_vettore()
Crea un vettore di puntatori generici e per ciascun elemento di quel vettore alloca con calloc uno spazio di memoria dinamica pari a dimEl byte.
Ne consegue che, in uscita, sarà allocata una memoria complessiva pari a qEl moltiplicato per la dimensione di un puntatore (nei sistemi a 32 bit, 4 byte) PIU' dimEl*qEl byte.
Se la funzione ha successo restituisce 1, in caso d'errore restituisce 0.
N.B. Nonostante il valore di ritorno sia indicato come void* per evitare la necessità di un cast esplicito, si tenga presente che la sua reale natura è quella di un puntatore a doppia indirezione, per cui deve essere assegnato a una variabile (ad esempio) di tipo char** o int**.

Commento su distruggi_matrice()
Data una matrice bidimensionale di puntatori generici che puntano a memoria allocata dinamicamente con malloc, calloc o realloc, la funzione libera la memoria puntata dai singoli puntatori elementi della matrice e quella allocata dalla matrice di puntatori stessa.
Ne consegue che, in uscita, TUTTA la memoria dinamica risulterà liberata e il puntatore passato come parametro in "matrice" sarà un puntatore non valido.
Se la funzione ha successo restituisce 1, in caso d'errore restituisce 0.
N.B. Nonostante il puntatore passato nel parametro "matrice" sia indicato come void* per evitare la necessità di un cast esplicito, ci si attende che il parametro sia un puntatore a tripla indirezione (ad esempio, char*** o int***).

Commento su crea_matrice()
Crea una matrice di puntatori generici e per ciascun elemento di quella matrice alloca con calloc uno spazio di memoria dinamica pari a dimEl byte.
Ne consegue che, in uscita, sarà allocata una memoria complessiva pari a qEl moltiplicato per la dimensione di un puntatore (nei sistemi a 32 bit, 4 byte)
PIU' dimEl*qRighe*qColonne byte.
Se la funzione ha successo restituisce 1, in caso d'errore restituisce 0.
N.B. Nonostante il valore di ritorno sia indicato come void* per evitare la necessità di un cast esplicito, si tenga presente che la sua reale natura è quella di un puntatore a tripla indirezione, per cui deve essere assegnato a una variabile (ad esempio) di tipo char*** o int***.

Ultima modifica effettuata da AldoBaldo il 30/07/2017 alle 13:31

ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.

Mikelius (Member)
Expert

Messaggi: 525
Iscritto: 14/04/2017

Postato alle 17:18
Domenica, 30/07/2017

Salve,,,

ho fatto una prova con questo main()
e mi da qualche problema, ma credo che sia sopratutto perchè non uso bene le tue funzioni.

Codice sorgente - presumibilmente C++

//aggiungere #include <string.h>
// IDE: VS2017 Community
int main(){
 
/*******************************************************************/
    int vett[10];
    char *stringa = calloc( 10, sizeof( char ) );
/*******************************************************************/
    int **vettore = crea_vettore(10,sizeof(**vettore));
    char **string = crea_vettore(10,sizeof(**string));
/*******************************************************************/
 
 
    *vettore[0] = 0;
    *vettore[1] = 10;
    *vettore[2] = 200;
    *vettore[3] = -300;
    *vettore[4] = 400;
 
 
    strcpy( stringa, "provauno" );
 
    *string[0] = 'p';
    *string[1] = 'r';
    *string[2] = 'o';
    *string[3] = 'v';
    *string[4] = 'a';
    *string[5] = ' ';
    *string[6] = 'f';
    *string[7] = 'u';
    *string[8] = 'n';
    *string[9] = '\0';
 
 
    printf( "\n\nLa stringa=%s --- DIM = %d\n", (*string), strlen( *string ) );
    printf( "La *string=%s --- DIM = %d\n", (stringa), strlen( stringa ) );
 
    printf( "Dimensione complessiva di VETT[10] =%d\n", sizeof( vett ) );
    printf( "Dimensione complessiva di *vettore =%d\n\n\n\n", sizeof( *vettore ) );
 
 
    distruggi_vettore( string, 10 );
    distruggi_vettore( vettore, 10 );
    free( stringa );
 
    printf( "La stringa=%s --- DIM = %d\n", (stringa), strlen( stringa ) );
    printf( "La *string=%s --- DIM = %d\n\n", (*string), strlen( *string ) );
 
    printf( "Dimensione complessiva di VETT[10] =%d byte\n", sizeof( vett ) );
    printf( "Dimensione complessiva di *vettore =%d byte\n", sizeof( *vettore ) );
 
 
    return 0;
}

in poche parole:
come faccio ad utilizzarlo per le stringhe??
come posso avere la dimensione totale del vettore?
dopo aver distrutto i vettori..
string da errore se usato, vettore invece lo visualizza correttamente.

Ultima modifica effettuata da Mikelius il 30/07/2017 alle 17:20

nessuno (Normal User)
Guru^2

Messaggi: 6402
Iscritto: 03/01/2010

Postato alle 19:36
Domenica, 30/07/2017

Se hai scritto quello prima della peperonata, figuriamoci dopo ... :-)

Ricorda che nessuno è obbligato a risponderti e che nessuno è perfetto ...
---
Il grande studioso italiano Bruno de Finetti ( uno dei padri fondatori del moderno Calcolo delle probabilità ) chiamava il gioco del Lotto Tassa sulla stupidità.

nessuno (Normal User)
Guru^2

Messaggi: 6402
Iscritto: 03/01/2010

Postato alle 19:57
Domenica, 30/07/2017

Testo quotato

come faccio ad utilizzarlo per le stringhe??

Non puoi. Perché i vettori che sono allocati in questo modo dal nostro Paganini (con affetto ...) non hanno gli elementi in indirizzi successivi in memoria, essendo foglie di una lista di puntatori.

Per capirci, un vettore di char allocato in questo modo è fatto

p ->
--- p1 -> 'a'
--- p2 -> 'b'
--- p3 -> 'c'
--- p4 -> '\0'

in modo che gli indirizzi di 'a' 'b' 'c' '\0' non sono successivi (come DEVE essere per una stringa ASCIIZ del C) ed essi sono posizionati, potenzialmente, ovunque in memoria.

In questo modo, fra l'altro, per QUALSIASI vettore allocato in questo modo (anche per gli int o per i double ...) fallirà qualsiasi funzione del tipo strcpy, memcpy, memmove e simili.

Infine, la sizeof non può funzionare perché il tipo di dati su cui agisce è SEMPRE un puntatore (a prescindere dal dato a cui punta) quindi restituirà sempre 4 (per sistemi a 32 bit) oppure 8 (per sistemi a 64 bit).

Ultima modifica effettuata da nessuno il 30/07/2017 alle 19:59

Mikelius (Member)
Expert

Messaggi: 525
Iscritto: 14/04/2017

Postato alle 20:12
Domenica, 30/07/2017

Testo quotato

Postato originariamente da nessuno:

Non puoi.

leggendo di char** mi era parso che si potesse, o almeno lo volesse rendere possibile. in questo modo, se non si puo usarlo per stringhe, meglio specificarlo nel sorgente (pignoleria MODE OFF).

Per la sizeof(), si lo so che ritorna sempre 4 , 8 o 2568 a seconda la macchina perche ci sono puntatori.
Lo chiedevo proprio per questo. se uno volesse sarere il numero degli elementi dell'array?
con i vettori normali calcolo sizeof(array)/sizeof(array[0]) , con questo metodo, se il vettore venisse generato in una funzione ed usato in altre?
Usare una struttura:

Codice sorgente - presumibilmente C++

struct
{
   int NElementi;
   int DimTot;
   int **vettore;
   void ***Peperonata;
}

o si rinuncia a certe info e a certe funzioni, oppure si deve complicare il codice.
L'idea però mi piace.

Ultima modifica effettuata da Mikelius il 30/07/2017 alle 20:15

nessuno (Normal User)
Guru^2

Messaggi: 6402
Iscritto: 03/01/2010

Postato alle 20:59
Domenica, 30/07/2017

Testo quotato

Postato originariamente da Mikelius:

o 2568

2568 ?

Testo quotato

con i vettori normali calcolo sizeof(array)/sizeof(array[0])

Neanche con quelli "normali" se lo fai all'interno di una funzione a cui passi il vettore.

Fra l'altro l'inefficienza (dal punto di vista dell'allocazione e della frammentazione di memoria) di questo codice è enorme.

Ultima modifica effettuata da nessuno il 30/07/2017 alle 21:04

AldoBaldo (Member)
Guru

Messaggi: 700
Iscritto: 08/01/2015

Postato alle 21:58
Domenica, 30/07/2017

Nessuno ha colto perfettamente il punto e lo ha spiegato meglio di come avrei saputo fare io (e non mi stupisce).

L'idea di base è l'allocazione in memoria dinamica di ogni elemento del vettore/matrice, perché... non lo so!

(comunque la peperonata, che ho cucinato io stesso con le verdure che ho coltivato io stesso era eccelsa!)

Scherzi a parte (si fa per dire), di base volevo che con quelle funzioni si potessero creare vettori/matrici di tipo a piacere con una sola riga di codice, al limite allocando intere strutture a raffica, in un colpo solo, tipo...

Codice sorgente - presumibilmente C

#include <stdio.h>
#include <stdlib.h>
 
#include "allocazioni.h"
 
/*==============================================================================
Definisce un quid di stupidaggini che richiedono inutilmente un pacco di memoria.
==============================================================================*/
 
typedef struct RICCONE {
    char cognome[64];
    char nome[64];
    int id;
} RICCONE;
 
typedef struct TESORETTO {
    char luogo[64];
    double ammontare;
} TESORETTO;
 
typedef struct PACCO {
    RICCONE proprietario;
    TESORETTO soldoni[1024];
} PACCO;
 
/*==============================================================================
Genera una matrice 5*5 di strutture PACCO allocate in memoria dinamica con una
manciata risibile di esilaranti righe di codice.
==============================================================================*/
 
int main() {
    const int qr = 5, qc = 5; /* qr = quantita' righe; qc = quantita' colonne */
 
    PACCO ***matrice = crea_matrice( qr, qc, sizeof(***matrice) );
 
    if( matrice ) {
        /* fai quel che vuoi con la matrice appena allocata */
 
        /* libera la memoria allocata */
        if( !distruggi_matrice(matrice,qr,qc) )
            printf( "\nMatrice non distrutta." );
    }
    else {
        printf( "\nMatrice non creata.\n" );
    }
 
    printf( "\nPremi \"invio\" per lasciare il programma...\n\n" );
    while( getchar() != '\n' );
 
    return 0;
}

Ultima modifica effettuata da AldoBaldo il 30/07/2017 alle 22:20

AldoBaldo (Member)
Guru

Messaggi: 700
Iscritto: 08/01/2015

Postato alle 22:20
Domenica, 30/07/2017

Mikelius, volevo evitare di associare strutture "dedicate" a queste funzioni perché le volevo indipendenti da tutto e da tutti, nell'ottica grezza del "fai questa cosa e piantala lì", magari con un semplicissimo copia-e-incolla di codice o un'inclusione senza troppe complicazioni. Cioè, il contenuto delle funzioni è effettivamente un po' cervellotico, da psicopatia dispeptica post-prandiale, però quando si tratta di usarle basta davvero poco (anche se effettivamente non si tratta di vettori dei tipi usati, bensì di vettori di puntatori ai tipi usati). L'utilizzo che avevo in mente riguarda programmi di minime dimensioni, di quelli dove l'immediatezza nella stesura è un valore al quale sacrificare tante finezze.

Per generare il vettore/matrice in una funzione e usarlo in un'altra dovresti semplicemente passare alla seconda funzione anche il numero di elementi/righe-colonne. Per conoscerne le dimensioni dovresti conoscere anche le dimensioni del singolo elemento. Ad esempio, un'eventuale chiamata a mostra_matrice( matrice, qr, qc, sizeof(***matrice) ); nel main ...

Codice sorgente - presumibilmente C/C++

int mostra_pacco( PACCO *p ) {
    int ok = 0;
 
    if( p ) {
        int i;
 
        printf( "id: %04d", p->proprietario.id );
        printf( " %s", p->proprietario.cognome );
        printf( " %s\n", p->proprietario.nome );
 
        for( i=0; i<32; ++i ) {
            printf( "%.2lf euro", p->soldoni[i].ammontare );
            printf( " (%s)\n", p->soldoni[i].luogo );
        }
    }
 
    return ok;
}
 
int mostra_matrice( PACCO ***m, size_t qr, size_t qc, size_t dimEl ) {
    int ok = 0;
 
    if( m && qr && qc ) {
        size_t r, c;
 
        printf( "Dimensioni di un PACCO: %u byte\n", dimEl );
        printf( "Dimensioni della matrice: %u byte\n\n", dimEl*qr*qc );
 
        for( r=0; r<qr; ++r )
            for( c=0; c<qc; ++c )
                mostra_pacco( m[r][c] );
 
        ok = 1;
    }
 
    return ok;
}

Ultima modifica effettuata da AldoBaldo il 30/07/2017 alle 22:39

AldoBaldo (Member)
Guru

Messaggi: 700
Iscritto: 08/01/2015

Postato alle 22:44
Domenica, 30/07/2017

nessuno, effettivamente avrei potuto allocare un unico blocco per i dati e altri blocchi per i puntatori, oppure un unico blocco in tutto con un'organizzazione tipo header+dati, però non so se ne sarei stato capace. Tra l'altro: sarebbe effettivamente stato meglio? Varrebbe lo spaccacervello? Se mi dici di sì ci provo!

Pagine: [ 1 2 ]