[C++] Liste di oggetti - LIST

[xVinz]

Salve a tutti, ho un problema. Ho svolto diversi problemi utilizzando list della libreria #include <list>, ma ora ho un problema.

Dovrei creare una struttura (lista) che contenga più oggetti! Fino a quando dovevo creare una lista per oggetto, non era un problema, creavo tre diverse liste con tre diversi iteratori associati.
Ora il problema è proprio che non capisco come creare una lista piu' oggetti diversi.


Per esempio avendo tre classe diverse, voglio creare una lista che le contenga tutte.

class p1{

}

class p2{

}

class p3{

}


int main(){
list<piuoggetti> nomelista;

}


list ammette un solo tipo - oggetto, generalmente. Come posso, dunque creare un unica lista con tutti gli oggetti che voglio?

Preferirei non usare "boost::"

Potreste postare anche qualche esempio, se non è troppo disturbo?

Grazie in anticipo.

[71106]

struct Class1 {
...
};

struct Class2 {
...
};

struct Class3 {
...
};

struct Node {
Class1 m_Object1;
Class2 m_Object2;
Class3 m_Object3;
};

list<Node> List;


Preferirei non usare "boost::"

A parte che Boost non c'entra niente, ma... perchè? :D

[xVinz]

Intanto ti ringrazio per la risposta! :)
Non posso utilizzare boost, poiché ho visto che è una libreria che si dovrebbe "importare manualmente" dato che non è ufficiale di c++. Essendo che dovrò presto sostenere l'esame di "Programmazione 1", non posso chiedere al professore di scaricarla ahah!

Comunque, ho provato a fare una cosa del genere, ma non riesco:
#include <iostream>
#include <list>
using namespace std;

class Prima{
private:
int x,y;

public:
void setX(){
cout<<"Inserisci X: ";
cin>>x;
}


};

class Secondo{
private:
string nome;
public:
void setNome(){
cout<<"Inserisci nome:";
cin>>nome;
}
};

struct nodo{
Prima strPrimo;
Secondo strSecondo;

};
int main(){
list<nodo> listanodo;
list<nodo>::iterator ptr;

listanodo.push_back(/*come accedo al metodo setNome di classe Secondo?*/);
return 0;
}

[71106]

Non capisco perchè hai messo il commento con la domanda dentro la lista di argomenti per la push_back, cosa vorresti fare lì dentro?

Comunque, a titolo esemplificativo:


struct First {
int m_x;
int m_y;
First(int const a_x, int const a_y) :
m_x(a_x),
m_y(a_y) {}
};

struct Second {
string m_strName;
Second(string const &a_rstrName) :
m_strName(a_rstrName) {}
};

struct Node {
First m_First;
Second m_Second;
Node(int const a_x, int const a_y, string const &a_rstrName) :
m_First(a_x, a_y),
m_Second(a_rstrName) {}
};

list<Node> List1;
List1.push_back(Node(0, 1, "pippo"));
List1.push_back(Node(2, 3, "paperino"));

list<Node> List2{
Node(4, 5, "pluto"),
Node(6, 7, "topolino")
};

for (auto it = List1.cbegin(); it != List1.cend(); ++it) {
cout << it->m_First.m_x << it->m_First.m_y << it->m_Second.m_strName << endl;
}


Cerca di evitare di implementare oggetti che possono avere tanti stati. La tua versione di "Prima" e "Secondo" possono trovarsi in uno stato interpretabile come "inizializzato" e in uno interpretabile come "non inizializzato". E' meglio se puoi assumere che siano sempre entrambe inizializzate, e per fare ciò puoi passare i valori iniziali ai rispettivi costruttori come ho fatto io nelle mie "First" e "Second".

Altra cosa: io sono per i PODO ("plain old data objects"), quindi evito sempre di mascherare i campi e renderli accessibili solo tramite getters e setters. Motivo percui non uso quasi mai la visibilità privata e, conseguentemente, uso sempre "struct" anzichè "class". Ma su questo possono esserci questioni di gusti.

[xVinz]

Finalmente sto riuscendo a capirci qualcosa! Grazie :)
Un'altra domanda inerente al codice che mi hai postato!
Potresti spiegarmi cosa fai qui?
First(int const a_x, int const a_y) :
m_x(a_x),
m_y(a_y) {}
Cioè, quei ":"e quelle "{}" alla fine, per cosa stanno!?

Grazie ancora

[71106]

E' la sintassi per inizializzare i membri di un aggregato. Il costruttore di un aggregato deve inizializzare tutti i membri dell'aggregato, implicitamente o esplicitamente. Le pseudo-invocazioni che vedi tra i due punti e le graffe sono le invocazioni esplicite dei costruttori dei vari membri. Nota che non sono solo gli aggregati ad avere costruttori invocabili: i tipi primitivi hanno degli pseudo-costruttori con prototipi predefiniti.

Nell'esempio che citi:


First(int const a_x, int const a_y) :
m_x(a_x),
m_y(a_y) {}


accade che il costruttore di "First" invoca gli pseudo-costruttori di copia dei membri "m_x" ed "m_y", che sono interi. Essendo pseudo-costruttori di copia, accade che i valori di "a_x" e "a_y" vengono ricopiati in "m_x" ed "m_y", rispettivamente.

Anche nel costruttore di "Second" invoco un costruttore di copia, ma stavolta non si tratta di un tipo nativo bensì di std::string.