Newsgroup: it.comp.lang.c++
Titolo: overloading di un operatore

come posso inserire un istanza di una classe in un file? con l'overloadin
dell'operatore di inserimento? e come?
GRAZIE   A TUTTI!!!

 l'overloadin dell'operatore di inserimento? e come?
Intendi la serializzazione di un oggetto? Non credo che ti basti
overloadare l'operatore <<
-- 
Rhymes
rhy...@myself.com
" ride or die "

 GRAZIE   A TUTTI!!!
class MyClass {
private:
    int    m_Intero;
    float m_Float;
public:
    void Save(std::ostream&) const;
    void Load(std::istream&);
};
void MyClass::Save(std::ostream& os) const
{
    os << m_Intero << m_Float;
}
void MyClass::Load(std::istream& is)
{
    is >> m_Intero >> m_Float;
}
std::ostream& operator << (std::ostream& os, const MyClass& mycls)
{
    mycls.Save(os);
    return os;
}
std::istream& operator >> (std::istream& is, MyClass& mycls)
{
    mycls.Load(is);
    return is;
}
Spero che sia abbastanza chiaro: scrivi due metodi (Save e Load, nel mio
esempio) che accettano come argomento uno stream della libreria standard.
A questo modo tu puoi scrivere la tua classe non solo su file ma anche su
altri tipi di stream (su schermo, per esempio).
Poi overloadi gli operatori << e >> in maniera che richiamino le tue due
funzioni (che sono pubbliche). A questo modo eviti problemi con gli accessi
(necessità di effettuare lo streaming su membri privati).
Nella tua funzione main potrai scrivere una cosa del genere:
int main()
{
    MyClass mycls;
    /* salvi la classe */
    std::ofstream ofs("Il_mio_file.txt");
    ofs << mycls;
    ofs.close();
    /* carichi la classe */
    std::istream ifs("Il_mio_file.txt");
    ifs >> mycls;
    ifs.close();
    /* scrivi a schermo la classe */
    cout << mycls;
}
Tutto qui. Stai solo un pò più attento quando inserisci nel tuo file delle
stringhe (sorgono complicazioni nella lettura).

 dell'operatore di inserimento? e come?
class A {
        private:
                int foo;
                int bar;
        public:
                friend ostream &operator<<(ostream &o, A const &a);
};
ostream &operator<<(ostream &o, A const &a) {
        o << "foo = " << foo << endl;
        o << "bar = " << bar << endl;
        return o;
}
Se vuoi utilizzare questo metodo  per salvare un'istanza e ripristinarla
in seguito  ricordati che per  i puntatori non  puoi fare come  ho fatto
nell'esempio. Se  il  tuo  puntatore  punta, ad  esempio,  ad  un  array
allocato dinamicamente,  non puoi salvare il  valore del puntatore! Devi
salvare i  singoli elementi, e,  in fase di caricamento,  riallocare una
nuova area di memoria e  copiarci gli elementi. Piu` in generale, quando
utilizzi dei puntatori,  devi salvare il contenuto  dell'area di memoria
puntata, non il puntatore stesso.
*NON* fare assolutamente una cosa del genere:
ofstream out("A.dump");
A *a = new A();
out.write(reinterpret_cast<char *>(&a), sizeof(A));
delete a;
....
ifstream in("A.dump");
a = reinterpret_cast<A *>(malloc(sizeof(A));
in.read(reinterpret_cast<char *>(&a), sizeof(A));
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
"L'abilita` politica e` l'abilita` di prevedere quello che
 accadra` domani, la prossima settimana, il prossimo mese e
 l'anno prossimo. E di essere cosi` abili, piu` tardi,
 da spiegare  perche' non e` accaduto."

 }
se non inserisci un carattere di spaziatura tra m_Intero e m_Float poi 
non riuscirai a leggerli successivamente...
ciao Anto
-- 
Antonio Cuni, 20 anni, studente
Brainbench C++ Master: 4.73, higher than 99% of all previous test takers.
C Language: 3.79, higher than 92% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

 non riuscirai a leggerli successivamente...
Confermo... distrazione! :-D

GRAZIE A TUTTI PER LE RISPOSTE!!!