Newsgroup: it.comp.lang.c++
Titolo: come dereferenziare un elemento di un vector?

ho un
vector<MiaClasse> *vec = qualcosa;
per accedere alle proprietà del vector basta che faccio
vec->size()
ecc.
ma per accedere agli elementi? cioè quello che con un vector senza *
farei con vec[i].proprietà_della_classe_MiaClasse ???
-- 
]\/[ad]\/[age
"Un Maestro insegue semplicemente la sua visione di Eccellenza in
qualunque cosa sta facendo e lascia agli altri decidere se sta 
lavorando o giocando. A lui sembra sempre di fare entrambe." - Anonimo

farei con vec[i].proprietà_della_classe_MiaClasse ???
mi rispondo da solo... ma l'avevo già fatto nel topic!! :-DDDD
bisogna, appunto, dereferenziare il vector, quindi
(*vec)[i].proprietà
grazie :-DDDDDDDDD


altro problema: ho due classi ClasseA e ClasseB che derivano da
ClassePadre...
ho un vector<ClassePadre> vec, che in realtà può essere un
vector<ClasseA> o un vector<ClasseB>... non è bene lavorarci così,
sarebbe sicuramente meglio avere un vector<ClassePadre*> vec in modo
da poter accedere in maniera giusta ai membri di ClasseA e ClasseB
(anche se accedo solo a quelli che sono derivati da ClassePadre)
dico bene?


vabbé, vi dico il problema completo, altrimenti non mi capite
ho una classe
class Personaggio {
public:
	vector<ClasseA> vecA;
	vector<ClasseB> vecB;
}
in cui ClasseA e ClasseB sono due classi che ereditano da ClassePadre;
ora, dovrei fare due funzioni che fanno cose simili su vecA e vecB,
quindi avevo pensato di farne una sola e di avere un vecX che fosse
una volta vecA e una volta vecB, ad esempio
void func(int What)
{
	vector<ClassePadre> vecX;
	switch (What) {
	case 0:
		vecX = vecA;
		break;
	case 1:
		vecX = vecB;
		break;
	}
	eccetera eccetera, in cui uso vecX.size 
	oppure vecX[i].membrodiClassePadre
}
solo che mi sembra bruttino, per via della copia del vector, allora
pensavo ad un puntatore, ma come lo uso?


 pensavo ad un puntatore, ma come lo uso?
Non solo è bruttino, ma probabilmente è la strada sbagliata. Innazitutto
non puoi assegnare un vector<ClasseA> a un vector<ClassePadre>.
Volendo puoi copiarne il contenuto con assign() o insert():
   vecX.insert( vecX.begin(), vecA.begin(), vecA.end() );
Questo funziona perchè la insert() è templatizzata e ClasseA può essere
usato come argomento per il copy-ctor di ClassePadre. Quello che accade è
che gli oggetti ClasseA vengono usati per inizializzare oggetti di tipo
ClassePadre.
Se il tuo obbiettivo è avere un vettore di oggetti con comportamento
polimorfico, questa non è la strada giusta. Se poi ClassePadre è una
classe astratta, il tuo codice nemmeno compila (ma questo credo tu lo
sappia).
Max

quindi non c'è altro modo che modificare tutto il codice e fare
vettori di puntatori invece che puntatori di oggetti?


ho cambiato le cose, ho fatto
class Personaggio {
public:
	vector<ClasseA*> vecA;
	vector<ClasseB*> vecB;
}
ma nel ciclo
void func(int What)
{
	vector<ClassePadre*> vecX;
	switch (What) {
	case 0:
		vecX = vecA;
		break;
	case 1:
		vecX = vecB;
		break;
	}
	eccetera eccetera, in cui uso vecX.size 
	oppure vecX[i].membrodiClassePadre
}
non mi permette di farlo, perché non può castare da vector<ClasseA*> a
vector<ClassePadre*>... come faccio a risolvere questo problema?!?



Se vuoi a tutti i costi popolare un vector<ClassePadre*> con i puntatori
di un vector<ClasseA*> puoi usare assign() o insert().
Mi pare, però, (se ben intuisco quel che vuoi ottenere) che potresti
templatizzare parte dell'implementazione di func() e usare una
specializzazione o un'altra a seconda del valore di what:
 
  template< class T >
  void func_impl_tmpl( std::vector<T*>& vecX )
  { /* eccetera eccetera, in cui uso vecX.size */
    /* oppure vecX[i]->membrodiClassePadre */
  }
...e in func():
 
 void 
 Personaggio::func(int What) // ho aggiunto Personaggio::
 {
       switch (What) {
       case 0:
               func_impl_tmpl(vecA); // usa func_impl_tmpl<ClasseA>(...)
               break;
       case 1:
               func_impl_tmpl(vecB); // usa func_impl_tmpl<ClasseB>(...)
               break;
         }           
  }
In questo caso, peraltro, non c'è nemmeno bisogno che ClasseA e ClasseB
siano imparentate. Inoltre, a questo punto, puoi evitare l'uso di
puntatori.
Però se spiegassi con maggiore chiarezza quello che vuoi ottenere si
potrebbero individuare soluzioni più appropriate.
Max

potrebbero individuare soluzioni più appropriate.
ho una classe finestra che contiene una istanza della classe MiaClasse
(quella che dentro ha i due vettori)... all'interno della finestra c'è
un pagecontrol con varie tabsheet... in 3 o 4 di queste tabsheet devo
visualizzare il contenuto di uno dei vettori all'interno della
MiaClasse, a seconda, appunto, della tabsheet che è attiva in quel
momento (il What di cui sopra)...
poiché le cose da fare in una delle tabsheet sono molte (e piccole,
anche), del tipo aggiungere un elemento al vector, visualizzarlo,
eliminare un elemento, modificarlo e tante altre cosette, riscrivere
tutto il codice usando i template non mi sembra una buona soluzione
(anche perché dovrei fare tanti switch per ogni funzione func, mentre
invece preferisco settare una variabile globale vec al vettore giusto
e poi usare vec nelle varie funzioni... anche perché non è solo il
vettore che devo scegliere, ma anche i vari controlli della tabsheet
corrispondente...
in pratica ho una funzione SetGenVars(int What) che setta tutte queste
variabili (per dire il vettore, i puntatori ai textbox, alle
stringgrid per visualizzare i contenuti, ecc.) e poi nelle varie
funzioni io chiamo prima SetGenVars e poi utilizzo queste variabili
globali...
non so se questa era la maniera migliore, spero di sì! fammi sapere,
grazie ancora (comunque penso che userò assign())...
