Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Array dinamico in C - son sulla strada giusta per una libreria generica?
Forum - C/C++ - Array dinamico in C - son sulla strada giusta per una libreria generica? - Pagina 3

Pagine: [ 1 2 3 4 ] Precedente | Prossimo
Avatar
AldoBaldo (Member)
Guru


Messaggi: 700
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 23:33
Venerdì, 30/06/2017
Nel frattempo, ho messo insieme un programmino di esempio per provare l'array così com'è. Devo dire che mi pare funzioni come si deve, anche se non ne ho minimamente provato le prestazioni in termini di velocità (non mi sono neppure posto il problema). Non provoca disastri e, a giudicare da qualche "passaggio" tramite debugger, direi che non genera neppure perdite di memoria o altri fenomeni del genere.

Ho diviso il tutto in cinque file, il "perno" dei quali sono array_dinamico.h e array_dinamico.c.
I file main.c, gestione_schede.h e gestione_schede.c sono invece i file nei quali provo ad applicare l'array dinamico per vedere se funziona oppure no.

Che dici, se non vengono fuori errori, una cosa del genere può essere utile tra i programmi di pierotofy.it? In che sezione? Esempi? Moduli e librerie?

Edit del 1/7/2017: ho trovato e corretto due errori in array_dinamico.c, uno dei quali grave.

file main.c

Codice sorgente - presumibilmente C++
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4.  
  5. #include "array_dinamico.h"
  6. #include "gestione_schede.h"
  7.  
  8. int esci( ARR_DIN*ad, const char *msg, int codice );
  9.  
  10. /*==============================================================================
  11. Predispone una struttura ARR_DIN che conterra' TOT_SCHEDE puntatori che puntano
  12. ad aree di memoria allocate dinamicamente con calloc() da AD_AggiungiInCoda().
  13. Ciascun'area di memoria puntata avra' le dimensioni specificate tramite
  14. sizeof(SP), passato ad AD_Inizializza().
  15. Nell'esempio, il "fattore di incremento" dell'array e' prefissato in blocchi di
  16. 5 elementi alla volta, il che fa si' che la prima chiamata a AD_AggiungiInCoda()
  17. provochi l'allocazione dello spazio necessario per i primi 5 puntatori
  18. (inizialmente tutti NULL). Successivamente, si rende necessario un
  19. ridimensionamento automatico dell'array, il che trattandosi di un programma di
  20. prova ed esempio va benissimo.
  21. Ogni chiamata da AD_AggiungiInCoda() provoca altresi' l'allocazione di uno
  22. spazio di memoria sufficiente a contenere una struttura di tipo SP, inizialmente
  23. occupata da soli zeri. Il puntatore a quell'area di memoria viene aggiunto in
  24. coda all'array dinamico di puntatori trattato tramite la struttura ad di tipo
  25. ARR_DIN.
  26. Subito dopo l'allocazione e l'immagazzinamento del puntatore, la funzione
  27. compila_scheda() si occupa di compilare ogni struttura con dati pseudocasuali
  28. esemplificativi.
  29. I dati immessi nell'array dinamico d'esempio ad vengono ordinati secondo tre
  30. diversi criteri (l'ordinamento avviene spostando i puntatori alle aree di
  31. memoria, non spostando i dati veri e propri). Dopo ogni ordinamento, i dati
  32. vengono visualizzati in console.
  33. ==============================================================================*/
  34.  
  35. int main() {
  36.     ARR_DIN ad; /* struttura per l'array dinamico */
  37.     size_t i;   /* un contatore */
  38.  
  39.     srand( time(NULL) );
  40.  
  41.     AD_Inizializza( &ad, sizeof(SP), 5 ); /* SEMPRE inizializzare ad */
  42.  
  43.     for( i=0; i<TOT_SCHEDE; ++i ) {
  44.         if( AD_ERR == AD_AggiungiInCoda(&ad) )
  45.             return esci( &ad, "Aggiunta elemento non riuscita.", 0 );
  46.         compila_scheda( AD_Leggi(&ad,i) );
  47.     }
  48.  
  49.     /* in lettura si possono usare tranquillamente i membri di ARR_DIN */
  50.     printf( "Elementi nell'array (%u)\n\n", ad.qEl );
  51.  
  52.     ordina( &ad, confronto_alfabetico ); /* usa AD_Scambia() */
  53.     mostra_schede( &ad, "IN ORDINE ALFABETICO" );
  54.  
  55.     ordina( &ad, confronto_cronologico ); /* usa AD_Scambia() */
  56.     mostra_schede( &ad, "IN ORDINE CRONOLOGICO" );
  57.  
  58.     ordina( &ad, confronto_identificativo ); /* usa AD_Scambia() */
  59.     mostra_schede( &ad, "SECONDO L'IDENTIFICATIVO" );
  60.  
  61.     return esci( &ad, NULL, 0 ); /* chiama anche AD_Distruggi() */
  62. }
  63.  
  64. /*==============================================================================
  65. Distrugge l'array dinamico ad (occorre SEMPRE farlo!!!).
  66. Se msg non e' NULL mostra il messaggio indicato.
  67. Mostra la dicitura "premi invio per uscire".
  68. Si pone in attesa che venga premuto "invio".
  69. Restituisce il valore ricevuto tramite il parametro codice.
  70. ==============================================================================*/
  71.  
  72. int esci( ARR_DIN *ad, const char *msg, int codice ) {
  73.     AD_Distruggi( ad ); /* da ricordare, se no memory leak a iosa! */
  74.     if( NULL != msg ) printf( msg );
  75.     printf( "\n\nPremi \"invio\" per uscire  " );
  76.     getchar(); /* attende l'invio */
  77.     return codice;
  78. }


file gestione_schede.h

Codice sorgente - presumibilmente C++
  1. /*==============================================================================
  2. Questo header e il file di implementazione correlato (gestione_schede.c) sono
  3. da intendere unicamente come elementi di un piccolo programma d'esempio
  4. finalizzato a illustrare alcune delle modalità di funzionamento dell'array
  5. dinamico implementato in array_dinamico.h e array_dinamico.c.
  6. ==============================================================================*/
  7.  
  8. #ifndef GESTIONE_SCHEDE_H_INCLUDED
  9. #define GESTIONE_SCHEDE_H_INCLUDED
  10.  
  11. #include "array_dinamico.h"
  12.  
  13. #define TOT_SCHEDE  10
  14. #define DIM_TAMP    24
  15.  
  16. typedef unsigned short us_t; /* esclusivamente per brevita' */
  17. typedef const char cc_t;     /* esclusivamente per brevita' */
  18.  
  19. /*==============================================================================
  20. Struttura usata come tipo dato d'esempio da immagazzinare nell'array dinamico.
  21. ==============================================================================*/
  22.  
  23. typedef struct {
  24.     char cognome[DIM_TAMP];
  25.     char nome[DIM_TAMP];
  26.     us_t anno_nascita;
  27.     us_t id;
  28. } SP; /* "SP" = scheda personale */
  29.  
  30. /*==============================================================================
  31. Prototipi di funzioni.
  32. ==============================================================================*/
  33.  
  34. void ordina( ARR_DIN *ad, int(*confr)(const SP*s1,const SP*s2) );
  35. int confronto_alfabetico( const SP *s1, const SP *s2 );
  36. int confronto_cronologico( const SP *s1, const SP *s2 );
  37. int confronto_identificativo( const SP *s1, const SP *s2 );
  38.  
  39. void mostra_schede( ARR_DIN *ad, const char *titolo );
  40. void compila_scheda( SP *s );
  41.  
  42. #endif /* GESTIONE_SCHEDE_H_INCLUDED */


file gestione_schede.c

Codice sorgente - presumibilmente C++
  1. /*==============================================================================
  2. Questo file di implementazione e l'header correlato (gestione_schede.h) sono da
  3. intendere unicamente come elementi di un piccolo programma d'esempio finalizzato
  4. a illustrare alcune delle modalità di funzionamento dell'array dinamico
  5. implementato in array_dinamico.h e array_dinamico.c.
  6. ==============================================================================*/
  7.  
  8. #include <stdlib.h>
  9. #include <stdio.h>
  10. #include <string.h>
  11.  
  12. #include "gestione_schede.h"
  13.  
  14. /*==============================================================================
  15. Una funzione per l'esemplificazione dell'uso di AD_Scambia() nell'ordinamento
  16. dell'array di esempio.
  17. ==============================================================================*/
  18.  
  19. void ordina( ARR_DIN *ad, int(*confr)(const SP*s1,const SP*s2) ) {
  20.     size_t qEl = ad->qEl;
  21.  
  22.     if( qEl > 1 ) {
  23.         size_t i, j, scambiato;
  24.  
  25.         for( scambiato=0, i=0; i<qEl-1; ++i, scambiato=0 ) {
  26.             for( j=0; j<qEl-1-i; ++j ) {
  27.                 if( confr(AD_Leggi(ad,j),AD_Leggi(ad,j+1)) > 0 ) {
  28.                     AD_Scambia( ad, j, j+1 );
  29.                     scambiato = 1;
  30.                 }
  31.             }
  32.  
  33.             if( !scambiato ) break;
  34.         }
  35.     }
  36. }
  37.  
  38. /*==============================================================================
  39. Tre funzioni di supporto alla funzione ordina().
  40. ==============================================================================*/
  41.  
  42. int confronto_alfabetico( const SP *s1, const SP *s2 ) {
  43.     int comp;
  44.  
  45.     if( !(comp=strcmp(s1->cognome,s2->cognome)) )
  46.         if( !(comp=comp?comp:strcmp(s1->nome,s2->nome)) )
  47.             if( !(comp=confronto_cronologico(s1,s2)) )
  48.                 comp = confronto_identificativo( s1, s2 );
  49.     return comp;
  50. }
  51.  
  52. int confronto_cronologico( const SP *s1, const SP *s2 ) {
  53.     us_t n1 = s1->anno_nascita, n2 = s2->anno_nascita;
  54.     int comp;
  55.  
  56.     if( !(comp=n1==n2?0:(n1>n2?1:-1)) )
  57.         if( !(comp=confronto_alfabetico(s1,s2)) )
  58.             comp = confronto_identificativo( s1, s2 );
  59.     return comp;
  60. }
  61.  
  62. int confronto_identificativo( const SP *s1, const SP *s2 ) {
  63.     us_t id1 = s1->id, id2 = s2->id;
  64.     return id1==id2 ? 0 : (id1>id2?1:-1);
  65. }
  66.  
  67. /*==============================================================================
  68. Due funzioni per la visualizzazione del contenuto delle schede inserite
  69. nell'array di esempio.
  70. ==============================================================================*/
  71.  
  72. void mostra_scheda( SP *s ) {
  73.     int nc = printf( "%s %s", s->cognome, s->nome );
  74.     while( 2*DIM_TAMP-(nc++) ) printf( " " );
  75.     printf( "(%4d)", s->anno_nascita );
  76.     for( nc=5; nc; --nc ) printf( " " );
  77.     printf( "ID: %05d\n", s->id );
  78. }
  79.  
  80. void mostra_schede( ARR_DIN *ad, const char *titolo ) {
  81.     int i;
  82.  
  83.     printf( "%s\n", titolo );
  84.  
  85.     for( i=0; i<ad->qEl; ++i )
  86.         mostra_scheda( AD_Leggi(ad,i) );
  87.  
  88.     printf( "\n" );
  89. }
  90.  
  91. /*==============================================================================
  92. Due funzioni per la compilazione semicasuale automatica delle schede da inserire
  93. nell'array di esempio.
  94. ==============================================================================*/
  95.  
  96. size_t estrai_unico( size_t *v, size_t *de ) {
  97.     size_t i, j = rand()%(*de);
  98.     size_t e = v[j];
  99.  
  100.     if( --(*de) ) {
  101.         for( i=j; i<(*de); ++i )
  102.             v[i] = v[i+1];
  103.     }
  104.     else {
  105.         *de = TOT_SCHEDE;
  106.         for( i=0; i<(*de); ++i )
  107.             v[i] = i;
  108.     }
  109.  
  110.     return e;
  111. }
  112.  
  113. void compila_scheda( SP *s ) {
  114.     static size_t v1[TOT_SCHEDE] = {0,1,2,3,4,5,6,7,8,9};
  115.     static size_t v2[TOT_SCHEDE] = {0,1,2,3,4,5,6,7,8,9};
  116.     static size_t da_estrarre1=TOT_SCHEDE;
  117.     static size_t da_estrarre2=TOT_SCHEDE;
  118.  
  119.     const char *kStrNomiEsempio[TOT_SCHEDE][2] = {
  120.         { "Abate",        "Agatino" },
  121.         { "Benante",      "Bruno" },
  122.         { "Caroselli",    "Carlo" },
  123.         { "De Filippi",   "Davide" },
  124.         { "Ersani",       "Ernesto" },
  125.         { "Fanoni",       "Fabio" },
  126.         { "Giuffredo",    "Giovanni" },
  127.         { "Iliante",      "Ilario" },
  128.         { "Lastricotti",  "Luigi" },
  129.         { "Marotta",      "Mario" }
  130.     };
  131.  
  132.     size_t e1 = estrai_unico( v1, &da_estrarre1 );
  133.     size_t e2 = estrai_unico( v2, &da_estrarre2 );
  134.  
  135.     strncpy( s->cognome, kStrNomiEsempio[e1][0], DIM_TAMP-1 );
  136.     s->cognome[DIM_TAMP-1] = '\0';
  137.     strncpy( s->nome, kStrNomiEsempio[e2][1], DIM_TAMP-1 );
  138.     s->nome[DIM_TAMP-1] = '\0';
  139.     s->anno_nascita = 1980 + rand()%25;
  140.     s->id = rand();
  141. }


file array_dinamico.h

Codice sorgente - presumibilmente C/C++
  1. /*==============================================================================
  2.                                  ARRAY_DINAMICO
  3.                      di Aldo Carpanelli - v1.0, giugno 2017
  4.                 coadiuva la gestione d'una serie  automaticamente
  5.                 estensibile di puntatori a dati di qualsiasi tipo
  6.  
  7. La libreria ARR_DIN gestisce strutture che si  comportano  come  "collettori" di
  8. puntatori ad aree di memoria  allocate  dinamicamente.  I puntatori trattati per
  9. mezzo di questa libreria vengono  immagazzinati in strutture di tipo ARR_DIN per
  10. poterli  rapidamente  gestire con funzioni dedicate.  Le funzioni si occupano di
  11. allocare e deallocare la memoria  puntata,  per cui chi usa questa  libreria non
  12. dovrebbe  allocare e/o deallocare  direttamente.  Non e' cosa saggia,  altresi',
  13. modificare  direttamente alcun  campo delle strutture di tipo ARR_DIN gia' usate
  14. con le funzioni della libreria.
  15. ==============================================================================*/
  16.  
  17. #ifndef ARR_DIN_H
  18. #define ARR_DIN_H
  19.  
  20. #define AD_OK   1
  21. #define AD_ERR  0
  22.  
  23. typedef struct {
  24.     char **pEl; /* puntatori correntemente contenuti nell'array          */
  25.     size_t dEl; /* la quantita' di memoria da allocare per ogni elemento */
  26.     size_t qEl; /* quantita' degli elementi correntemente nell'array     */
  27.     size_t cap; /* capacita' massima corrente dell'array                 */
  28.     size_t inc; /* quantita' di puntatori da aggiungere/sottrarre ad     */
  29.                 /* ogni incremento/decremento della capacita' massima    */
  30. } ARR_DIN;
  31.  
  32. /* N.B. : nel primo parametro d'ogni funzione, "ad" sta per "array dinamico" */
  33.  
  34. int AD_Inizializza( ARR_DIN *ad, size_t dimElemento, size_t dimIncremento );
  35. int AD_Distruggi( ARR_DIN *ad );
  36.  
  37. void *AD_Leggi( const ARR_DIN *ad, size_t posizione );
  38.  
  39. int AD_Inserisci( ARR_DIN *ad, size_t posizione );
  40. int AD_Elimina( ARR_DIN *ad, size_t posizione );
  41.  
  42. int AD_AggiungiInTesta( ARR_DIN *ad );
  43. int AD_EliminaInTesta( ARR_DIN *ad );
  44.  
  45. int AD_AggiungiInCoda( ARR_DIN *ad );
  46. int AD_EliminaInCoda( ARR_DIN *ad );
  47.  
  48. int AD_Scambia( ARR_DIN *ad, size_t posizione_1, size_t posizione_2 );
  49.  
  50. #endif /* ARR_DIN_H */


file array_dinamico.c

Codice sorgente - presumibilmente C/C++
  1. /*==============================================================================
  2.                                  ARRAY_DINAMICO
  3.                      di Aldo Carpanelli - v1.0, giugno 2017
  4.                 coadiuva la gestione d'una serie  automaticamente
  5.                 estensibile di puntatori a dati di qualsiasi tipo
  6.  
  7. La libreria ARR_DIN gestisce strutture che si  comportano  come  "collettori" di
  8. puntatori ad aree di memoria  allocate  dinamicamente.  I puntatori trattati per
  9. mezzo di questa libreria vengono  immagazzinati in strutture di tipo ARR_DIN per
  10. poterli  rapidamente  gestire con funzioni dedicate.  Le funzioni si occupano di
  11. allocare e deallocare la memoria  puntata,  per cui chi usa questa  libreria non
  12. dovrebbe  allocare e/o deallocare  direttamente.  Non e' cosa saggia,  altresi',
  13. modificare  direttamente alcun  campo delle strutture di tipo ARR_DIN gia' usate
  14. con le funzioni della libreria.
  15. ==============================================================================*/
  16.  
  17. #include <stdlib.h>
  18. #include <string.h>
  19.  
  20. #include "array_dinamico.h"
  21.  
  22. #define AD_DIMCHR sizeof(char)  /* dimensioni del tipo char */
  23. #define AD_DIMPTR sizeof(char*) /* dimensioni del puntatore */
  24.  
  25. /* prototipo d'una funzione utilizzabile solo in questo file */
  26. int AD_ModificaCapacita( ARR_DIN *ad, int dir_modf );
  27. int AD_Inizializza( ARR_DIN *ad, size_t dimEl, size_t dimInc ) {
  28.     if( NULL!=ad && 0!=dimEl && 0!=dimInc && 1 == AD_DIMCHR ) {
  29.         memset( ad, 0, sizeof(*ad) );
  30.         ad->dEl = dimEl;
  31.         ad->inc = dimInc;
  32.         return AD_OK;
  33.     } else return AD_ERR;
  34. }
  35.  
  36. int AD_Distruggi( ARR_DIN *ad ) {
  37.     if( NULL!=ad ) {
  38.         size_t i;
  39.  
  40.         for( i=0; i<ad->qEl; ++i )
  41.             { free( ad->pEl[i] ); ad->pEl[i] = NULL; }
  42.         free( ad->pEl );
  43.         memset( ad, 0, sizeof(*ad) );
  44.         return AD_OK;
  45.     } else return AD_ERR;
  46. }
  47.  
  48. void *AD_Leggi( const ARR_DIN *ad, size_t pos ) {
  49.     if( NULL!=ad && pos<ad->qEl ) return ad->pEl[pos]; else return NULL;
  50. }
  51.  
  52. int AD_Aggiungi( ARR_DIN *ad, size_t pos ) {
  53.     if( NULL!=ad && pos<=ad->qEl ) {
  54.         char *tmp = calloc( ad->dEl, 1 );
  55.  
  56.         if( NULL!=tmp ) {
  57.             if( ad->qEl+1 > ad->cap )
  58.                 if( !AD_ModificaCapacita(ad,1) )
  59.                     { free(tmp); return AD_ERR; }
  60.  
  61.             memmove( ad->pEl+pos+1, ad->pEl+pos, (ad->qEl-pos)*AD_DIMPTR );
  62.             ad->pEl[pos] = tmp;
  63.             ++ad->qEl;
  64.             return AD_OK;
  65.         } else return AD_ERR;
  66.     } else return AD_ERR;
  67. }
  68.  
  69. int AD_Elimina( ARR_DIN *ad, size_t pos ) {
  70.     if( NULL!=ad && pos<ad->qEl ) {
  71.         free( ad->pEl[pos] );
  72.         memmove( ad->pEl+pos, ad->pEl+pos+1, (ad->qEl-pos-1)*AD_DIMPTR );
  73.         ad->pEl[--ad->qEl] = NULL;
  74.         if( ad->cap-ad->inc >= ad->qEl )
  75.             AD_ModificaCapacita(ad,-1);
  76.         return AD_OK;
  77.     } else return AD_ERR;
  78. }
  79.  
  80. int AD_AggiungiInTesta( ARR_DIN *ad ) {
  81.     if( NULL!=ad ) return AD_Aggiungi( ad, 0 ); else return AD_ERR;
  82. }
  83.  
  84. int AD_EliminaInTesta( ARR_DIN *ad ) {
  85.     if( NULL!=ad ) return AD_Elimina( ad, 0 ); else return AD_ERR;
  86. }
  87.  
  88. int AD_AggiungiInCoda( ARR_DIN *ad ) {
  89.     if( NULL!=ad ) return AD_Aggiungi( ad, ad->qEl ); else return AD_ERR;
  90. }
  91.  
  92. int AD_EliminaInCoda( ARR_DIN *ad ) {
  93.     if( NULL!=ad ) return AD_Elimina( ad, ad->qEl-1 ); else return AD_ERR;
  94. }
  95.  
  96. int AD_Scambia( ARR_DIN *ad, size_t pos1, size_t pos2 ) {
  97.     if( NULL!=ad && pos1<ad->qEl && pos2<ad->qEl ) {
  98.         char *tmp = ad->pEl[pos1];
  99.         ad->pEl[pos1] = ad->pEl[pos2];
  100.         ad->pEl[pos2] = tmp;
  101.         return AD_OK;
  102.     } else return AD_ERR;
  103. }
  104.  
  105. /* a seguire, una funzione utilizzabile solo in questo file */
  106.  
  107. int AD_ModificaCapacita( ARR_DIN *ad, int dir_modf ) { /* dir_modf, 1 o -1 */
  108.     /* NULL!=ad e' gia' stato verificato in AD_Aggiungi() o AD_Elimina() */
  109.     int inc = dir_modf * ad->inc; /* determina se ampliare o ridurre */
  110.     size_t nuova_dim = (ad->cap+inc)*AD_DIMPTR;
  111.     char **tmp = realloc( ad->pEl, nuova_dim );
  112.  
  113.     if( NULL!=tmp || 0==nuova_dim ) {
  114.         /* memset() azzera i nuovi puntatori, se e' il caso */
  115.         if( inc>0 ) memset( tmp+ad->cap, 0, inc*AD_DIMPTR );
  116.         ad->pEl = tmp; /* "consolida" il nuovo array, accettandolo in pEl */
  117.         ad->cap += inc; /* aggiorna la capacita' dell'array */
  118.         return AD_OK;
  119.     } else return AD_ERR;
  120. }

Ultima modifica effettuata da AldoBaldo il 01/07/2017 alle 8:21

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.
PM Quote
Avatar
lumo (Member)
Expert


Messaggi: 449
Iscritto: 18/04/2010

Segnala al moderatore
Postato alle 15:18
Sabato, 01/07/2017
Moduli e librerie va bene, insegnamento e hobby pure.

PM Quote
Avatar
AldoBaldo (Member)
Guru


Messaggi: 700
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 20:42
Sabato, 01/07/2017
Grazie Lumo. Vada per "moduli e librerie". Attendo però qualche giorno, perché il fatto che ho individuato degli errori mi induce a pensare che è bene che usi ancora un po' "in proprio" 'sti array dinamici. Hai visto mai che ci siano ancora delle pecche!

Ah, ovviamente sarebbe bello se qualcuno desse a sua volta un'occhiata: quattro, sei, otto occhi vedono meglio di due (i miei).

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.
PM Quote
Avatar
lumo (Member)
Expert


Messaggi: 449
Iscritto: 18/04/2010

Segnala al moderatore
Postato alle 19:33
Domenica, 02/07/2017
Due consigli:
1) non usare un define per sizeof(char) e sizeof(char*), non è molto sensato e peggiora la leggibilità
2) Io eviterei l'else (soprattutto in riga, blrgh) in tutti quei casi dove il return precedente lo rende implicito.

PM Quote
Avatar
nessuno (Normal User)
Guru^2


Messaggi: 6403
Iscritto: 03/01/2010

Segnala al moderatore
Postato alle 19:54
Domenica, 02/07/2017
Cose di questo genere

if( NULL!=ad ) return AD_Aggiungi( ad, ad->qEl ); else return AD_ERR;

le scriverei

return (ad ? AD_Aggiungi(ad, ad->qEl) : AD_ERR);

E comunque, al posto di

} else return AD_ERR;

semplicemente

}

return AD_ERR;

Ultima modifica effettuata da nessuno il 02/07/2017 alle 19:56

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à.
PM Quote
Avatar
AldoBaldo (Member)
Guru


Messaggi: 700
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 21:50
Domenica, 02/07/2017
Sì, anche se sono più questioni di "stile" che di sostanza posso senz'altro adeguare il codice, se secondo voi che siete più esperti è meglio fare così. Magari migliora la leggibilità del codice, non so (ormai io mi sono abituato a vedere quel tipo di espressioni e non mi "turbano", ma non si può mai dire). Il funzionamento dovrevve comunque essere identico, no?

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.
PM Quote
Avatar
nessuno (Normal User)
Guru^2


Messaggi: 6403
Iscritto: 03/01/2010

Segnala al moderatore
Postato alle 22:04
Domenica, 02/07/2017
Quando diventano migliaia di righe la leggibilità diventa sostanza.

Righe come

if( NULL!=tmp ) {


devono diventare

if( tmp ) {

Ultima modifica effettuata da nessuno il 02/07/2017 alle 22:06

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à.
PM Quote
Avatar
AldoBaldo (Member)
Guru


Messaggi: 700
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 22:50
Domenica, 02/07/2017
Sarà fatto! :k:

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.
PM Quote
Pagine: [ 1 2 3 4 ] Precedente | Prossimo