Newsgroup: it.comp.lang.c++
Titolo: Visual C++ o C++ che cambia?

Ciao ragazzi vorrei sapere che cambia tra VC++ e C++
grazie ciao
five...@tin.it

Ciao,
qualche paragone:
1) C++ è un <linguaggio di programmazione>,
    VC++ è l'ambiente di sviluppo della M$ (quindi un IDE),
    che <include> un <compilatore> per il
    <linguaggio di programmazione> C++
quindi, a voler essere precisi e formali,
è già una bella differenza !
2) programmare con C++ significa farlo in modo
    "puro", quindi con le specifiche ANSI del linguaggio e
    le librerie standard (STL),
    programmare con VC++ potrebbe voler dire MFC,
    quindi mandare a gambe all'aria la portabilità fino
   dalle prime classi sviluppate,...
so che ci sono delle "pulci" nella implementazione del C++
della M$ che lo rendono non completamente C++ ANSI, ma
non le conosco (mi sembra di aver visto qualche cosa nel
manuale di VC++...) ma i due punti presentati sono a mio avviso
le differenze più sostanziali.
Ciao.
Davide.

manuale di VC++...) ma i due punti presentati sono a mio avviso
Non conosco ancora alcun compilatore che sostenga di
essere perfettamente compliant con il C++ Standard ISO
(non esiste un C++ ANSI: l'American National Standard
Institute adotta e sancisce invece lo standard in merito
approvato dall'International Standards Organization, ISO,
di cui l'ANSI e` d'altronde membro).
Fra i principali punti sui quali VC++6 non soddisfa ancora
completamente lo standard C++ ISO:
-- gli manca la covarianza dei tipi di ritorno in funzioni
    virtuali (antipatico, ma non mortale);
-- l'implementazione dei member-template non e` completa
    (e` sufficiente per molti usi, ma non per tutti);
-- "new" non causa, come dovrebbe, una exception se
    fallisce (fortunatamente non e` arduo istallare un
    new_handler che ripristini sostanzialmente lo standard);
-- (la peggiore, secondo me...): la specializzazione
    parziale di classi template, e il "partial ordering" di
    funzioni template, non sono implementate.
Quest'ultimo punto, per il quale non conosco workaround
e che inibisce decisamente certi usi avanzati del generic
programming (impedendo, ad esempio, di usare Blitz++
con VC++), e`, fra queste limitazioni, l'unica che dovrei
classificare come decisamente SERIA.  E` irritante, pero`,
che non siano state rimosse limitazioni, sia pur modeste,
che dovrebbe essere banale togliere, come le prime 3
(e` vero che le feature di VC++6 erano gia` "congelate"
quando lo Standard e` stato approvato, ma erano mesi
che si sapeva quasi perfettamente come sarebbe stato).
Speriamo in meglio per il futuro... la Microsoft, dopotutto,
e` maestra della strategia "abbraccia ed estendi" (dare
la piena implementazione di uno standard, poi _tentare_
gli utenti a legarsi all'implementazione proprietaria offrendo
feature _supplementari_ -- come sarebbe, ad es, per il
C++, la feature del Borland C++ Builder 3 che permette
di "incapsulare" un oggetto piu` un ptr-to-member in un
singolo "robo" che agisce "come se" fosse un ptr-to-function).
Al che, "basta" che l'utente sia furbo e scafato abbastanza
per evitare la tentazione, e il problema e` superato.
Nel C++, pero`, non hanno ancora completamente finito
la parte "abbraccio" della strategia:-).
Alex

     funzioni template, non sono implementate.
Non so se è legato a questo problema, ma secondo te perché non riesco a
compilare questo codice di Carlo Pescio con il DJGPP?
// -- codice riusabile di pre-calcolo
template < int i, int j, class F, class V > struct T;
template < int i, class F, class V > struct T < i, 0, F, V >
{
    T() {}
    V val[ i ];
    V operator [] ( int n ) const { return val[ n ]; }
};
template < int i, int j, class F, class V > struct T: public T < i, j -
1, F, V >
{
    T() { val[ j - 1 ] = F::f( j - 1 ); }
};
template < int d, class F, class V = int > struct Table: public T < d,
d, F, V >
{
    Table() {}
};
// -- Due semplici casi di utilizzo:
// Una funzione che eleva al quadrato
struct Square
{
    static int f( int i ) { return i * i; }
};
// Una funzione che eleva al cubo
struct Cube
{
    static int f( int i ) { return i * i * i; }
};
int main()
{
    // Una tabella con i primi 4 quadrati
    // (come interi)
    const Table < 4, Square > t;
    // Una tabella con i primi 3 cubi,
    // come double
    const Table < 3, Cube, double > t1;
    // si usano come normali array
    int n = t1[ 2 ];
    int m = t[ 1 ] + n;
    return 0;
}
Questa è la prima segnalazione che mi dà (seguita da una marea di
altre):
metaprog.cc:18: template instantiation depth exceeds maximum of 17
metaprog.cc:18:  (use -ftemplate-depth-NN to increase the maximum)
Naturalmente anche aumentando -ftemplate-depth-NN non risolvo ma
aumentano solo i messaggi di errore. Secondo me il compilatore non
riesce a risolvere la specializzazione con 0 al secondo parametro della
classe template che dovrebbe interrompere la recursione di calcolo della
tabella precalcolata.
EMG

 compilare questo codice di Carlo Pescio con il DJGPP?
Penso sia legato, infatti l'esempio che porti usa appunto
una specializzazione parziale di classe template, e nel
C++ classico questa non c'era (DJGPP, basato su gcc 2.8,
complessivamente differisce dal C++ standard su piu`
aspetti di quanti non ne manchino a VC++; solo egcs 1.1,
e non ancora relativamente alla libreria, presenta una
implementazione sostanzialmente equivalente o migliore,
come vicinanza allo standard, di quella di VC++).
Alex

     };
Capito. Il DJGPP lo accetta regolarmente.
Grazie.
EMG