[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;

Originariamente inviato da xVinz

Preferirei non usare "boost::"

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

[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.