Newsgroup: it.comp.lang.c++
Titolo: BUG grave in VC6.00

Qualche settimana fa ho incontrato il  runtime error :
Runtime error R6025
- pure virtual function call
durante il test di un grosso progetto in VC6.00. Dopo qualche fatica ho
scoperto che il sorgente seguente produce lo stesso errore. Notare che una
versione recente di CYGWIN ( EGCS per windows 95 / 98 / NT -
http://www.cygnus.com
 ) lo compila e lo esegue correttamente.
Il succo del discorso sembra essere che VC6.00 non riesce a riferire le
chiamate virtuali di abstract_class anche se non c'č nessun motivo per cui non
dovrebbe.
Ecco il codice
#include <fstream.h>
#include <vector>
struct abstract_string {
    virtual const char *
    begin() const = 0;
    virtual int
    size() const = 0;
    virtual const char *
    end() const {
        return begin() + size();
    }
};
using std::vector;
struct concrete_string: public vector<char> {
    concrete_string( const abstract_string & s ): vs(*this) {
        cout << "built a concrete string" << endl;
        const char * p = s.begin();
        const char * q = s.begin() + s.size();
        for( ; p < q ; ++p  )
            push_back( *p );
    }
    concrete_string( const char * p ) : vs(*this) {
        cout << "built a concrete string" << endl;
        if ( p != NULL ) insert( end(), p, p + strlen(p) );
    }
    ~concrete_string( )  {
        cout << "destroyed a concrete string" << endl;
    }
    operator abstract_string & () {
        return vs;
    }
    operator const char * () {
        push_back( '\0' );
        resize( size() - 1, '\0' );
        return reinterpret_cast<const char *>(begin());
    }
protected:
    struct i_string : public abstract_string {
        virtual  int
        size() const {
            return s.size();
        }
        virtual const char *
        begin() const{
            return s.begin();
        }
        i_string( concrete_string & s_ ) : s(s_) {}
    protected:
        concrete_string &
        s;
    };
    i_string
    vs;
};
void
a_function_taking_abstract_string( const abstract_string & s ){
    cout << ( const char * ) concrete_string( s ) << endl;
}
int
main(){
    a_function_taking_abstract_string( concrete_string("pippo") );
}
Qualcuno di voi mi sa dare una spiegazione di quello che succede qui e di come
evitarlo accidentalmente in futuro?
Grazie
Davide
-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/
       Search, Read, Discuss, or Start Your Own    

 evitarlo accidentalmente in futuro?
Purtroppo (o per fortuna) il tuo esempio compilato con il DJGPP non dą
alcun run-time error e pare funzionare correttamente.
EMG

evitarlo accidentalmente in futuro?
A parte che una classe contenuta abbia un'istanza della classe
contenitore mi sembra un abominio (lievemente ricorsiva la cosa?), il
problema e' che la dichiarazione della funzione della classe annidata
viene dopo la dichiarazione dell'istanza della stessa. 
Il bugs c'e', ma non e' cosi grave. Basta cambiare l'ordine di
comparsa dell'implementazione delle funzioni. Insomma di usare il
classico modo di procedere, ovvero header per le dichiarazioni, e dopo
l'implementazione (inline che sia). Ovvero non come la standard
library e' implementata (stile molto Java).
-------------------------------------------------------
Togli il Papero il vero indirizzo d'email.