Discussione: [C++] Lista di struct
Visualizza messaggio singolo
Vecchio 06-09-2009, 12.10.55   #7
LoryOne
Gold Member
WT Expert
 
Registrato: 09-01-2002
Loc.: None of your business
Messaggi: 5.505
LoryOne è un gioiello raroLoryOne è un gioiello raroLoryOne è un gioiello raro
Abbiamo visto che l'operatore new viene utilizzato per allocare ed eventualmente popolare un array di qualsiasi tipo attraverso l'utilizzo di un puntatore alla memoria dinamica (heap).
La classe generica list, utilizzabile attraverso l'inclusione dell'header <list.h> (#include <list>), fa ampio uso di template e di strutture che puntano a loro stesse, in modo tale da creare un array espandibile (dinamico) di oggetti.
Il link da me proposto, mostra come utilizzare la classe list in modo da creare un array di interi, ma non è molto chiaro su come gestire un array di strutture.
Una struttura è anch'essa un tipo di dato, così come lo sono int e char (persino una classe), ma può essere costituita da differenti tipi di dato, nonchè funzioni inline.

Facciamo un esempio semplice e chiaro:

1 - Creiamo la struttura MiaStruct1
struct MiaStruct1{
char x;
int y;
};

2 - Creiamo ora una classe list di tipo MiaStruct1
list<MiaStruct1> L1;

3 - Identifichiamo un puntatore alla struttura MiaStruct1
MiaStruct1 *p;

4 - Utilizziamo la classe L1 per allocare un array dinamico di 3 elementi di tipo MiaStruct1
p=L1.get_allocator().allocate(3);
p ora punta ad una lista concatenata di tre elementi di struttura MiaStruct1

5 - Popoliamo ogni elemento dell'array.
p[0].x='A' ; p[0].y=1 ;
p[1].x='B' ; p[1].y=2 ;
p[2].x='C' ; p[2].y=3 ;

6 - Visualizziamo ogni elemento dell'array
for(int i=0; i<3; i++) cout << p[i].x << p[i].y << endl;

7 - Infine deallochiamo la memoria dinamica allocata in precedenza.
L1.get_allocator().deallocate(p,3);

Vediamo ora un ulteriore esempio di utilizzo della classe facendo riferimento ai membri pubblici esplicitamente predisposti, al fine di ottenere un approccio più C++ alla classe list.

Facciamo un esempio semplice e chiaro:
1 - Creiamo la struttura MiaStruct2
struct MiaStruct2{
char x_;
int y_;
MiaStruct2(char x, int y) : x_(x), y_(y) { };
};
In questo caso, MiaStruct2 diventa una sorta di costruttore inline di se stessa che contiene al suo interno il prototipo.
si potrà popolare MiaStruct2 chiamandola direttamente ed assegnando ad x_ il valore di x ed ad y_ il valore di y.

2 - Creiamo ora una classe list di tipo MiaStruct2
list<MiaStruct2> L2;

4 - Utilizziamo la classe L2 per allocare un array dinamico di 3 elementi di tipo MiaStruct2
L2.push_back(MiaStruct2('a',1));
L2.push_back(MiaStruct2('b',2));
L2.push_back(MiaStruct2('c',3));

5 - Ora è necessario implementare un puntatore ad ogni elemento dell'array, in modo da poter iterare su ogni elemento di cui si compone l'insieme.
list<MiaStruct2>::iterator it2;

6 - Visualizziamo ogni elemento dell'array
for(it2=L2.begin(); it2!=L2.end(); it2++) cout << (*it2).x_ << (*it2).y_ << endl;

In ultimo, il programma completo:

Codice:
struct MiaStruct1{
    char x;
    int y;
};

struct MiaStruct2{
    char x_;
    int y_;
    MiaStruct2(char x, int y) : x_(x), y_(y) { };
};

main(void){

    list<MiaStruct1> L1;
    MiaStruct1 *p;
   
    p=L1.get_allocator().allocate(3);
    p[0].x='A' ; p[0].y=1 ;
    p[1].x='B' ; p[1].y=2 ;
    p[2].x='C' ; p[2].y=3 ;
    
    for(int i=0; i<3; i++)
    cout << p[i].x << p[i].y << endl;
    L1.get_allocator().deallocate(p,3);
    
    list<MiaStruct2> L2;
    
    L2.push_back(MiaStruct2('a',1));
    L2.push_back(MiaStruct2('b',2));
    L2.push_back(MiaStruct2('c',3));
    
    list<MiaStruct2>::iterator it2;
    for(it2=L2.begin(); it2!=L2.end(); it2++)
    cout << (*it2).x_ << (*it2).y_ << endl;
    
}
Ps: ringrazio il web per aver postato un ottimo esempio di implementazione di una classe generica che faccia uso di liste concatenate per ottenere un vettore dinamico di oggetti.
LoryOne non è collegato   Rispondi citando