Newsgroup: it.comp.lang.c++
Titolo: 'identifier' is not a member of 'struct'

>incasinare ulteriormente il tutto...
Non puoi fare un confronto tra classi diverse e presupporre di avere un qualche membro che ti dia il valore dell'oggetto.
Se anche ci fosse una classe StringaDati comunque non potresti fare un cofronto con InteriDati.
D'altrone il set raccoglie dati con lo stesso tipo. Se tu vuoi renderlo generale devi usare i template.
Qualcosa tipo (vado a braccio!):
template <type T> class Dati<T>
{
..
   int Confronta(const Dati<T> &d));
..
private:
   T mioValore;
}
La classe InteriDati non serve piu'.
Ciao
Antonio Donatiello

Ciao!
Sono abbastanza d'accordo con Antonio (se non altro perche' siamo fratelli), pero' avrei un'altra soluzione.
Qualcuno potra' storcere il naso, pero' in questo caso puoi forzare le regole con un "cast".
int Interi::Confronta(const Dati & Altro)
{
   Interi y = (const Interi&) Altro;   // naturalmente si "spera" che Altro sia davvero della classe "Interi"
   if (mioValore == y.mioValore)   // uso "y"... ovviamente
        return 1;
    else
        return 0;
}
A presto,
Angelo.

    Interi y = (const Interi&) Altro;   // naturalmente si "spera" che Altro sia davvero della classe "Interi"
Allora sarebbe meglio utilizzare il dynamic_cast così si può fare il
test sull'effettiva appartenenza di Altro alla classe di arrivo. O
almeno il const_cast.
EMG

le con un "cast".
[omissis]
Cerchiamo pero` di usare i cast new style:
static_cast
const_cast
ecc. ecc.
Paolo
-----------------------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------------------------

Non puoi fare un confronto tra classi diverse e presupporre di avere un
qualche membro che ti dia il >valore dell'oggetto.
Gia'... ringrazio tutti quelli che mi hanno risposto ma purtroppo nessuno
dei metodi ha funzionato...
Credo che devo proprio ripartire dall'inizio dando a tutto un'impostazione
diversa..
La mia "specifica" esatta e' questa:
"Si progetti in C++ un componente che realizza il tipo di dato astratto
generico SET (insieme matematico), che offra le operazioni di inserimento,
eliminazione, unione, intersezione, differenza. Di questo costruire anche la
specializzatione ORD_SET, che definisce un insieme ordinato. Si generino
anche esmpi concreti di insiemi (per esempio, un insieme numerico, un
insieme di date, un elenco telefonico) e si facciano esempi di polimorfismo
e binding dinamico.
Si cerchi di usare il piu` possibile delle caratteristiche del linguaggio
(ereditarieta`, polimorfismo e binding dinamico, eccezioni, ecc."
La mia idea iniziale era quella di fare una linked list come classe "Set" e
una classe madre virtuale "Dato" con "Interi", "Data" e "Telefonico" che la
estendevano.
Poi nel main creavo un puntatore a "Dato" che instanziavo, secondo le
risposte ad un semplice menu switch, agli oggetti veri e propri.
Il problema sta nel fatto che nella lista ho bisogno di accedere agli
elementi dei vari tipi di "Dato", per poter fare i confronti, ma anche solo
semplicemente per vedere se un elemento e' gia' presente (in un set un
elemento e' presente solo una volta).
Questo lo facevo con un metodo"Confronta" di "Set" che prendeva un puntatore
a "Dato" come paramentro e poi, nel corpo del metodo, richiamava un metodo
omonimo di "Dato" che veniva ridefinito in ognuna delle sottoclassi di
"Dato".
Questo ha portato al problema che vi ho gia' esposto l'altro giorno...
siccome la "Confronta" ha come paramentro un puntatore a "Dato" non vede le
variabile private che sono presenti nei suoi figli e che vengono utilizzate
dalle confronta di questi ultimi.
Ora ho pensato che potrei fare un'altra cosa... potrei dichiarare la classe
"Set" come un template T e poi assegnare a T nel main degli oggetti
"Intero", "Data" e "Telefonico" completamente slegati fra di loro, ognuna
con un metodo "Confronta" che verrebbe chiamato correttamente nel set
essendo T il parametro passato alla "Confronta" del "Set", cioe':
template <class T>
class Set:
{
public:
    Set ();
    ~Set();
    Set operator + (Set altro); // Unione di due Set
    Set operator + (T * elem); // Inserimentodell'elemento
    Set operator & (Set altro); // Intersezione di due Set
    Set operator - (T * altro); // Differenza di due Set
    int Confronta (T * elem); // Dice se l'elemento fa gia' parte del Set
    void Show(); // Stampa a video tutti gli elementi
private:
    T mioDato;
    // qui poi dipende se faccio un array o una lista dinamica.. ma non
importa ora
};
// i vari metodi di overloading degli operatori...
// e la classe "Confronta"
template <class T>
Set<T>::Confronta(T * elem)
{ ....
    // qui scorro l'array o la lista dinamica e per ogni elemento  chiamo
    mioDato.confronta(*elem);
    // restituendo 1 se lo trova o 0 se non lo trova
}
// I vari dati vengono implementati singolarmente (senza discendere da una
classe virtuale)
// Per esempio  la classe "Intero"
class Intero
{
    Intero(int val) {mioValore = val}
    ~Intero(){}
    int confronta(Intero * altro);
    void show();
private:
    int mioValore;
}
int Intero::confronta(Intero * altro)
{
    if(mioValore==altro->mioValore)
        return 1;
    return 0;
}
Nel main poi verranno instanziati puntatori ai diversi oggetti e diversi
"Set":
Intero * pIntero;
Data * pData;
Telefonico *pTelefonico;
Set<Intero> a, b, c;
Set<Data> d, e, f;
Set<Telefonico> g, h, i;
La specifica richiedeva di utilizzare anche l'ereditarieta', e quella la
posso usare per fare Ord_Set che discende da Set e ne ridefinisce
l'inserimento e l'unione.
Voi che dite? Cosi' dovrebbe funzionare? Ed inoltre... e' buona
programmazione o una schifezza? Mi sfugge qualcosa? Se potete aiutarmi
grazie mille, ci passo delle notti insonni sopra questo progettino :)
E scusatemi per la lunghezza del post... non son riuscito a spiegarmi in
poche righe.
--
Ciao!
Lazarus Long (Francesco)
-15 giorni a SW Episode I The Phantom Menace!!
l...@startrekmail.com
  -  ICQ 26989309