Newsgroup: it.comp.lang.c++
Titolo: F.A.Q. UFFICIALI DI IT.COMP.LANG.C++

========================================================================
                  F.A.Q. UFFICIALI DI IT.COMP.LANG.C++
                      revisione 1.3  -  12/09/2000
           a cura di diversi partecipanti di it.comp.lang.c++
========================================================================
Indice delle domande:
0) Vorrei imparare il C++, e` necessario conoscere prima qualche altro
   linguaggio oppure posso imparare direttamente questo?
1) Che differenza esiste tra C++, Visual C++, Borland C++ Builder...?
2) Che differenza c'e` tra C e C++?
3) Dove posso trovare un compilatore C++ freeware?
4) Quale editor posso utilizzare per scrivere i miei programmi?
5) Dove posso trovare della documentazione sul C++ e lo standard?
6) Quali libri mi consigliate per imparare il C++ o perfezionare le
   mie conoscenze?
7) Che cosa e` la memoria dinamica? Come si usa?
8) Come posso allocare dinamicamente una matrice a piu` dimensioni e
   utilizzare la notazione M[i][j]?
9) Che cosa e` un header? Come si creano e come si usano?
10) Se separo le definizioni di un template dalla sua dichiarazione
    ponendole in file separati (.h e .cpp) non riesco ad istanziarlo.
    Come posso risolvere il problema?
11) Come si passa un array ad una funzione in C++?
12) Come posso generare numeri casuali?
13) Come mai ottengo sempre la stessa sequenza di numeri casuali?
14) La sequenza generata da rand() non e` molto buona, dove posso
    trovare generatori di numeri casuali piu` validi?
15) Che differenza c'e` tra STL e la libreria standard del C++?
16) Lavorando con i numeri in virgola mobile, non riesco ad ottenere
    risultati precisi, perche`?
========================================================================
0) Vorrei imparare il C++, e` necessario conoscere prima qualche altro
   linguaggio oppure posso imparare direttamente questo?
R) Il C++ e` un linguaggio estremamente ricco e complesso, e come
   tale puo` non essere il piu` adatto da imparare come primissimo
   linguaggio di programmazione; esso e` stato progettato (come il
   suo precursore "C") per l'uso da parte di programmatori esperti e
   "scafati". Molti altri linguaggi sono stati progettati
   specificamente per insegnare ai principianti a programmare: alcuni,
   come il Pascal, guidano molto il principiante obbligandolo ad
   imparare ed applicare una rigorosa disciplina; altri, come Rexx,
   Python, e Basic, sono invece (in diversa misura e con diverse
   filosofie) "tolleranti" e "di manica larga". L'uno, l'altro, o
   entrambi questi approcci potrebbero essere piu` produttivi per
   imparare a programmare che non tuffarsi alla "nuotare o affogare"
   nel pelago del C++.
   Per chi gia` sa programmare (in qualsiasi altro linguaggio, Pascal,
   Basic o altro) il C++ e` un ottimo "secondo passo" nel mondo della
   programmazione.  In particolare non e` certo il caso di vedere come
   propedeutici al C++ altri linguaggi simili ma diversi (come Java,
   Objective C, Eiffel, Smalltalk...), se l'obbiettivo e` il C++,
   meglio allora studiare il C++.
   C'e` un diffuso e stranissimo mito che il linguaggio C sia
   propedeutico al C++, poiche` storicamente ne fu la radice. Questo
   equivale a dire che, per chi voglia imparare l'Inglese, sarebbe
   furbo cominciare con il Sassone basso-medievale [1].
   In pratica i modi di programmare in C e in C++ sono talmente
   diversi
   che e` meglio passare direttamente al C++ e non acquisire idiomi
   tipici del C e del tutto superati e/o controproducenti nel C++.
   [1] Consulenza sul Sassone basso-medievale di Alex Martelli! :-)
1) Che differenza esiste tra C++, Visual C++, Borland C++ Builder...?
R) Il C++ e` il linguaggio definito dallo standard ANSI/ISO.
   Lo standard ne definisce la sintassi e la semantica dei costrutti,
   le regole che lo governano e la libreria standard. Di questo
   linguaggio esistono poi diverse implementazioni per le varie
   piattaforme (DOS, Linux, Windows, Mac...), alcune sono freeware
   (GNU gcc, CygwinB20...) altre commerciali (Visual C++, Borland C++
   Builder). Queste implementazioni sono tutte piu` o meno aderenti
   allo standard, alcune offrono oltre al compilatore anche strumenti
quali
   debugger e profiler, e/o delle estensioni non standard o
particolare
   supporto
   ad una certa piattaforma. Ad esempio il Borland C++ Builder e`
anche uno
   strumento R.A.D.
2) Che differenza c'e` tra C e C++?
R) Spesso si dice che il C++ e` una estensione del C, ovvero un
   "C + AltraRoba". Questa affermazione e` corretta ed errata allo
   stesso tempo. La correttezza sta nel fatto che effettivamente il
   C++ da un punto di vista sintattico e` un sovrainsieme del C,
   tuttavia queste sue estensioni modificano totalmente il modo in cui
   si programma in C++, al punto che l'approccio C e` totalmente
   diverso e superato.
3) Dove posso trovare un compilatore C++ freeware?
R) In rete e` possibile reperire diversi prodotti gratuiti, molti sono
   basati sul compilatore GNU gcc. Ecco un breve elenco di
   possibilita`:
   GNU gcc   -   
http://gcc.gnu.org
   L'ottimo compilatore GNU, uno dei piu` aderenti allo standard,
   fornito di serie sui sistemi Linux e di cui esistono porting molto
   validi per DOS e Windows. E` possibile trovare anche molti tool a
   supporto di questo compilatori, in particolare l'ottimo debugger
   GNU gdb ed il profiler GNU gprof.
   DJGPP   -   
http://www.delorie.com/djgpp
   E' il porting per MS-DOS del compilatore GNU gcc e viene aggiornato
   abbastanza frequentemente (almeno finora, ma la cosa potrebbe
   cambiare in futuro dato che l'MS-DOS tende sempre piu'
   all'obsolescenza).
   E' ottimo per imparare il C/C++ in quanto non mette troppa carne al
   fuoco (tipo programmazione Windows con finestre e bottoncini) ma
   offre compilatore e librerie con una buona aderenza allo standard.
   In piu' fornisce anche una nutrita serie di funzioni non standard,
   praticamente le stesse fornite con i compilatori Borland sempre
   per MS-DOS.
   CygWinB20   -   
http://sourceware.cygnus.com/cygwin/
   Basato su un porting dell'ottimo GNU gcc, fornisce un ambiente unix
   like su piattaforma windows. Sono compresi diversi tool utili, in
   particolare anche gdb il debugger GNU, ma manca di un editor di
   risorse.
   Altre utili informazione per questo compilatore si possono trovare
   su
 
http://www.remotepoint.com/~jordanh/personal/cygwin/cygwin.html
   Mingw   -   
http://www.xraylith.wisc.edu/~khan/software/gnu-win32/
 
ftp://ftp.xraylith.wisc.edu/pub/khan/gnu-win32/mingw32/
   Sempre gcc per windows, anch'esso dotato tra l'altro di un
   debugger (GNU gdb) ed un profiler (GNU gprof). A differenza del
   precedente non offre un ambiente unix like.
4) Quale editor posso utilizzare per scrivere i miei programmi?
R) Qualunque editor ASCII va bene, anche il semplice Edit del DOS o
   il Vi di Linux, tuttavia e` possibile trovare editor specializzati
   con syntax hilight (che usano cioe` colori diversi per i vari
   elementi del linguaggio). Eccone una nutrita lista:
   QEdit
   E' un vecchio editor per MS-DOS molto snello ma potente e
   totalmente configurabile. Contiene anche un ricco macro-linguaggio.
Ora e'
   sostituito dal successivo.
   The SemWare Editor   -   
http://www.semware.com
   E' il successore di QEdit con molte caratteristiche in piu', una
   delle quali e' di utilizzare la memoria estesa per permettere
l'editing di
   files molto grossi. Esiste anche in versione Windows ma sempre con
   interfaccia a caratteri.
   WinEdit   -   
http://www.winedit.com
   E' un editor per Win32 che offre buona configurabilita' ed ottime
   caratteristiche tra le quali il WIL (Windows Interactive Language),
   un linguaggio molto ricco e potente che permette di creare
   praticamente qualsiasi comando di cui si puo' aver bisogno allo
   interno dell'editor stesso.
   UltraEdit   -   
http://www.ultraedit.com
   E' un altro editor per Win32 molto simile al precedente che manca
   pero' del linguaggio WIL, ma offre in piu' la possibilita' di
editing
   esadecimale.
   MultiEdit   -   
http://www.multiedit.com
   Un altro editor ancora per Win32 (ma esiste anche la versione per
   Win16). Rispetto ai precedenti offre in piu' la possibilita' di
   configurare perfino i bitmap della toolbar per quanto riguarda i
   pulsanti definiti dall'utente. Per il resto sembra comunque
   inferiore
   ai due precedenti in quanto non offre editing esadecimale, il
   linguaggio macro sembra meno potente del WIL e, a differenza degli
   altri due, non presenta la classica struttura con tree delle
   cartelle sulla sinistra e finestra di editing sulla destra.
   EditPlus   -   
http://www.editplus.com
   E` un ottimo editor di testo, con sistemi di high-lighting
   personalizzabili e, sul sito, ci sono i plug-in per gestire quasi
   tutti i linguaggi (alcuni sono presenti con l'installazione di
   base).
   Solo per piattaforma Win32.
   Texturizer   -   
http://djst.cjb.net/
   Altro ottimo editor di testo per Windows, con sistemi di code
   highlighting, anch'essi personalizzabili, per moltissimi linguaggi.
   La cosa piu` interessante e` che ha un costo molto basso al
   confronto con altri strumenti simili per Windows.
   PFE   -   
http://www.lancs.ac.uk/people/cpaap/pfe/
   Freeware per win32, con una serie notevole di personalizzazioni
   possibili (macro, file salvati in formato *unix*, cattura
dell'output
   dei comandi batch, e cosi' via). Esiste anche una vecchia versione
a
   16 bit. Manca solo la sintassi colorata per raggiungere la
   perfezione.
   KDevelop   -   
http://www.kdevelop.org
   Non e` un semplice editor, ma un IDE (un ambiente di sviluppo
   integrato) freeware per Linux con class tree, gestione di progetti,
   tool di sviluppo RAD per KDE, integrazione con debugger, browser
   integrato per la documentazione.
   CForge   -   
http://www.codeforge.com
   Altro IDE per Linux ed altri SO molto completo. E` disponibile in
   una versione free (no opensource) per uso personale e piccoli
   progetti e varie versioni commerciali a prezzi contenuti.
   Infine e` utile ricordare Emacs uno dei piu` potenti editor, dotato
   di mille funzionalita` e disponibile per molte piattaforme (Unix,
   Linux, Windows...). Lo si trova facilmente con una piccola ricerca
   in rete.
5) Dove posso trovare della documentazione sul C++ e lo standard?
R) Per lo standard ci sono 2 possibilita`, puoi comprarne una copia
   sotto forma di file pdf (Acrobat reader) all'indirizzo
 
http://webstore.ansi.org/product.asp?sku=ISO%2FIEC+14882%2D1998
   per soli 18 US$, oppure puoi comprare la versione cartacea
   (molto piu` costosa) all'indirizzo 
http://www.ansi.org/
   Per altra documentazione sul C++ eccoti nutrito elenco di indirizzi
   utili, la maggior parte dei quali riferisce per ovvie ragioni a
   risorse in lingua inglese:
 
http://www.icce.rug.nl/docs/cplusplus/cplusplus.html
   C++ annotation, annotazioni per programmatori C che desiderano
   imparare il C++. In inglese.
 
http://www.cs.bham.ac.uk/~jdm/CPP/index.html
   Faq del NG comp.lang.c++. In inglese
 
http://www.eskimo.com/~scs/C-faq/top.html
   Faq del NG comp.lang.c. In inglese.
   In queste FAQ sono spiegati in dettaglio i sequence points, non
   discussi sulle FAQ di comp.lang.c++
 
http://www.programmazione.it
   E` un sito dedicato alla programmazione in generale, ma contiene
   molto materiale relativo al C++ compreso un tutorial in italiano
   che pero` richiede delle conoscenze di base in materia di
   programmazione.
 
http://www.bruceeckel.com
   A partire da questo indirizzo e` possibile scaricare liberamente la
   nuova edizione di "Thinking in C++", l'ottimo libro di Bruce Eckel.
   In inglese, molto valido.
 
http://www.programmingtutorials.com/
 
http://packetstorm.securify.com/programming-tutorials/
 
http://cs.nmhu.edu/personal/curtis/cs1htmlfiles/Cs1text.htm
 
http://www.cprogramming.com/
 
http://www.cyberdiem.com/vin/learn.html
   Su questi siti e` possibile trovare diversi tutorials ed altro
   sul C++ (ed anche sul C).
 
http://www.accu.org/
   Association of C and C++ users
 
http://www.utu.fi/~sisasa/oasis/oasis-cc++.html
 
http://www.la-online.com/cprog.htm
   link per C e C++ anche a documentazione varia
   Ecco dei link in cui si trova documentazione sulla
   libreria standard del C++ e su STL (vedere faq N. 15):
 
http://www.sgi.com/Technology/STL
 
http://www.dinkum.com/refstl.html
 
http://www.dinkum.com/htm_stl/index.html
 
http://www.cs.rpi.edu/~musser/stl.html
 
http://www.developer.com/reference/r_library.html
 
http://cgi.cs.rpi.edu/pub/stl/
   Alcuni Link sull'Object Oriented in generale:
 
http://www.cetus-links.org/
 
http://www.cpsc.ucalgary.ca/~gao/60903/paper.htm
6) Quali libri mi consigliate per imparare il C++ o perfezionare le
   mie conoscenze?
R) Tra le risposte alla precedente domanda trovi un link da cui
   scaricare l'ottimo libro di Bruce Eckel, adatto sia per i
   principianti che per quelli che gia` conoscono molti aspetti del
   C++.
   Al momento attuale (gennaio 2000) questo libro e` in fase di
   pubblicazione. Altri testi sono elencati di seguito, di alcuni di
   essi potrebbe essere disponibile la traduzione in italiano che
   pero` potrebbe non essere all'altezza dell'originale.
   Lippman e Lajoie, "C++ Primer" 3 ed. - Addison Wesley
   Ottimo libro per chi vuole imparare il C++. Esiste anche la
   traduzione in italiano, intitolata "C++ Corso di Programmazione".
   B. Stroustrup, "The C++ programming language" 3 ed. - Addison
   Wesley
   E` il libro del padre del C++, non e` molto valido per chi deve
   iniziare, ma e` sicuramente un buon reference ed un approfondimento
   per un programmatore C++ con una certa conoscenza del linguaggio.
   B. Stroustrup, "The design and evolution of C++" - Addison Wesley
   E` rivolto a chi vuole approfondire le conoscenze sul perche` delle
   scelte operate nella realizzazione del C++ e sul funzionamento di
   certi meccanismi. Non e` molto aggiornato rispetto allo standard,
   ma
   e` tuttora molto valido. Rivolto a conoscitori abbastanza esperti
   del linguaggio.
   S. Meyers, "Effective C++" 2 edizione e "More Effective C++"
   editi da Addison wesley
   Due libri disponibili anche in formato elettronico (CD) ad un
   prezzo conveniente (piu` aggiornati rispetto alle edizioni cartacee
   e con un plus di articoli dell'autore).
   Si tratta di una raccolta di consigli su cosa fare (e come) e cosa
   non fare in C++. Caldamente consigliati a chi vuole fare del C++ un
   utilizzo professionale.
   C. Pescio, "C++ manuale di stile" - Edizioni Infomedia
   L'argomento trattato e` l'importanza dell'uso di uno stile nella
   codifica in C++ e i problemi che possono sorgere quando non si
   usano dei principi precisi e razionali.
   Di facile lettura, molto valido e ad un prezzo abbordabile.
   Renato Conte (
co...@dsi.unive.it
)
   "Il Mondo degli Oggetti: Programmazione in C++"
   Edizioni Progetto - Padova
   Buon libro, adatto a chi ha conoscenza di programmazione in Basic,
   Pascal o altro e vorrebbe imparare da 0 il C++, semplice, con tanti
   esempi, chiaro e bene impaginato. Essendo lo scrittore italiano ed
   essendo disponibile l'indirizzo e-mail e' possibile contattarlo per
   chiarimenti, suggerimenti o altro.
   Nicolai Josuttis,
   "The C++ standard library, a tutorial and a reference"
   Addison-Wesley
   Un altro ottimo testo.
   J.Coplien,
   "Advanced C++ Programming Styles and Idioms"
   Addison Wesley?
   Il breve commento che lo descrive sul sito di Infomedia:
   "Per approfondire le caratteristiche del linguaggio. Tra cui:
   programmazione object oriented, ereditarieta' multipla, tipi di
   dati astratti ed altro".
   In realta' sono trattati argomenti anche un po' distanti dal C++
   (o meglio concetti che derivano da altri linguaggi, come per
   esempio la Programmazione Orientata agli Accessi, tecniche di
   Reflection, ecc.).
   Purtroppo e` molto datato ma puo` essere comunque una lettura
   assai interessante.
   J.Coplien,
   "Multi-Paradigm DESIGN for C++"
   E` piu` un libro sul design del software che sulla programmazione,
   d'altronde pero` il design e` importante almeno tanto quanto
   la programmazione.
   E. Gamma, R. Helm, R. Johnson, J. Vlissides
   "Design Patterns, Elements of reusable Object-Oriented Software"
   Addison Wesley
   Una raccolta di pattern molto importanti e di impiego generale, non
   tratta dunque la programmazione in C++, ma ha piu` a che vedere col
   design. Non deve mancare nella libreria (e nella testa) di un
   professionista del C++.
   J. Lakos
   "Large-Scale C++ Software Design"
   Addison Wesley
   Dedicato alla progettazione di applicazioni C++ (molto) grosse!
   E` possibile trovare delle recensioni su questi ed altri libri
   sul sito 
http://www.accu.org/bookreviews/public/index.htm
7) Che cosa e` la memoria dinamica? Come si usa?
R) In C++ e` possibile allocare la memoria solo quando serve, ad
   esempio quando non si sa a priori quanta memoria serve per
   memorizzare una lista di valori di un certo tipo.
   Questa memoria la si alloca e dealloca attraverso l'uso dei
   puntatori e degli operatori new (new[]) e delete (delete[]).
   Ad esempio se vogliamo allocare memoria per una variabile di tipo
   T possiamo scrivere:
   T* VarPtr = new T(/* parametri costruttore */);
   Per utilizzare questa variabile basta dereferenziare VarPtr:
   cout << *VarPtr << endl;   // supponendo l'esistenza di
                              // ostream& operator<<(ostream&, T&)
   *VarPtr = NewValue         // assegnamento...
   Per allocare un intero array bisogna utilizzare invece la forma
   T* MyArray = new T[Size];
   cout << MyArray[0] << endl;
   MyArray[5] = NewValue;
   E` necessario ricordarsi di deallocare la memoria dinamica
   quando non serve utilizzando sempre e solo l'apposito operatore:
   delete VarPtr;     // per singoli elementi
   delete[] MyArray;  // per gli array
   In C sono poi disponibili anche le funzioni malloc e free, ma il
   loro uso e` sconsigliato in C++.
   Infine e` spesso assai piu` proficuo utilizzare le classi
   fornite dalla libreria standard del C++ che sollevano il
   programmatore dalla necessita` di tenere traccia delle
   allocazioni e delle deallocazioni semplificandone il lavoro.
   Ad esempio std::auto_ptr<> e` una classe che incapsula un
   puntatore intelligente che quando distrutto libera automaticamente
   anche la memoria.
   Un altro approccio si basa sull'uso di classi come std::vector<>
   std::vector<T> vT;
   // un T alla volta...:
   vT.push_back(T());    // con il ctor di default
   // e/o, anche, molti T alla volta...:
   vT.resize(23);           // altri 22 ctor di default
   vT.push_back(T(args));    // con altri ctor
   Questo ha tra l'altro gli stessi vantaggi di std::auto_ptr<>,
   in quanto gli oggetti contenuti in vT vengono automaticamente
   cancellati dal distruttore di vT stesso.
   Esistono anche altri contenitori standard, come std::list<>,
   std::set<>, std::map<>, ..., per esigenze particolari, ma
   std::vector<> e` di gran lunga il piu` utile e comune per
   la semplice allocazione dinamica.  Per il caso particolare,
   molto comune, di stringhe di caratteri di lunghezza dinamicamente
   variabile, std::string (e std::wstring, per usare Unicode) sono
   anche molto, molto pratiche.
   Il C++, essendo un linguaggio adatto anche a "programmazione di
   sistema" (cioe` di bassissimo livello), offre anche delle forme
   alternative di allocazione dinamica, che sono quelle che,
   internamente, strutture come std::vector possono usare per offrire
   la loro comoda ed efficiente funzionalita` (queste funzionalita`
   vanno incapsulate in un oggetto di tipo "allocatore" perche`
   std::vector e soci possano poi usarle).
   In pratica, non si presenta mai una vera necessita` di
   accedere a queste funzionalita` di bassissimo livello
   (come new[]/delete[], malloc/free, e altre, meno portatili, come
sbrk
   su Unix, VirtualAllocEx su Win32, CoTaskMemAlloc nell'ambito di un
   utilizzo del COM o DCOM, eccetera eccetera), se non per
   compatibilita` con vecchio codice scritto con l'uso di esse, o
   interfacce di sistema di bassissimo livello; infatti, std::vector
   (e gli altri contenitori standard) fanno in pratica tutto quello
   che serve, al limite con l'aiuto di un oggetto allocatore non
   standard per esigenze peculiari.
8) Come posso allocare dinamicamente una matrice a piu` dimensioni e
   utilizzare la notazione M[i][j]?
R) Ecco alcune possibilita`, alcune richiedono un po' di impegno,
   studiatele bene prima di porre eventuali quesiti sul NG.
   Approccio tradizionale di basso livello:
   #include <iostream>
   #include <iomanip>
   using namespace std;
   int main() {
     int** Matrice = new int* [10];
     // alloca la prima dimensione
     for(int i=0; i<10; ++i)
       Matrice[i] = new int [10];
     // allocazione della seconda dimensione
     // e inizializzazione della matrice
     for(int i=0; i<10; ++i)
       for(int j=0; j<10; ++j)
         Matrice[i][j] = (i+1) * (j+1);
     // visualizza il valore dei vari elementi
     for(int i=0; i<10; ++i) {
       for(int j=0; j<10; ++j)
         cout << setw(3) << Matrice[i][j] << " ";
        cout << endl;
      }
     // Deallocazione della matrice.
     // Notare che la deallocazione avviene in ordine
     // inverso rispetto all'allocazione
     for(int i=0; i<10; ++i)
        delete[] Matrice[i];
     delete[] Matrice;
   }
   Un approccio basato su vector:
   #include <vector>
   template<class T>
   class matrix {
       typedef std::vector<T> riga;
       std::vector<riga> body;
     public:
       void setSize(int x, int y) {
         body.resize(0);    // getta tutto
         body.resize(x);    // riparte
         for(int i=0; i<x; ++i)
           body[i].resize(y);
       }
       void getSize(int &x, int &y) {
         x = body.size();
         if(x) y=body[0].size();
         else y=0;
       }
       matrix() {}
       matrix(int x, int y) { setSize(x,y); }
       // non occorre dtor esplicito, quello di
       // default e` OK
       std::vector<T>& operator[](int i) { return body[i]; }
       const std::vector<T>& operator[](int i) const { return body[i];
}
   };
   Un altro, piu` a basso livello e che presenta eguale
   interfaccia d'uso pur utilizzando in realta` un semplice
   vettore e non una matrice:
   template<class T>
   class matrix {
       T* body;
       int x; int y;
     public:
       void setSize(int x, int y) {
         if(body) delete[] body;    // getta tutto
         body = new T[x*y];         // riparte
         this->x = x;
         this->y = y;
       }
       void getSize(int &x, int &y) {
         x = this->x;
         y = this->y;
       }
       matrix(): body(0) {}
       matrix(int x, int y): body(0) { setSize(x,y); }
       ~matrix() { if(body) delete[] body; }
       T* operator[](int i) { return body+i*y; }
       const T* operator[](int i) const { return body+i*y; }
   };
9) Che cosa e` un header? Come si creano e come si usano?
R) Un header e' un file di testo (con estensione .h o .hpp o altro)
   contenente normalmente dichiarazioni di funzioni, tipi, classi...
   Lo scopo principale di un header file e' quello di raggruppare in
un
   unico punto del programma tutte le dichiarazioni relative ad un
   certo argomento (ad esempio, parlando di header files standard,
   tutte quelle riguardanti l'I/O su stream o quelle riguardanti il
tipo
   std::vector in vector.h) ed evitare cosi' possibili errori di
   battitura da parte del programmatore e rendere piu` gestibile un
   programma.
   In un file header e` comunque possibile (e in alcuni casi
necessario)
   inserire anche definizioni di funzioni, variabili, costanti...
   Una volta creato un header per utilizzarlo si utilizza la direttiva
   #include "file.h" all'interno dei file che ne fanno uso.
   Per maggiori dettagli si rimanda ad un qualsiasi libro (tutorial)
   su C/C++.
10) Se separo le definizioni di un template dalla sua dichiarazione
    ponendole in file separati (.h e .cpp) non riesco ad istanziarlo.
    Come posso risolvere il problema?
R)  Gli attuali compilatori hanno bisogno di avere completo accesso
    sia alla dichiarazione che alla definizione di un template quando
    questo viene istanziato. Come conseguenza di cio` non e`
    possibile separare le definizioni dalle dichiarazioni, tutto deve
    essere messo in un unico file header (.h).
11) Come si passa un array ad una funzione in C++?
R)  In C++ un array non puo` essere passato come parametro allo
    stesso modo di una struttura o un altro aggregato.
    Sebbene sia possibile dichiarare la funzione nel seguente modo:
    const size_t Size = 100;
    void MyFunc(T array[Size]);
    in C (e di conseguenza anche in C++) un parametro di tipo array
    di T decade a puntatore a T e Size perde di significato
    cosicche` e` possibile scrivere
    T MyArray[Size/2];
    MyFunc(MyArray);   // con tutte le conseguenze del caso
    Il modo classico in C/C++ di passare un array come parametro
    e` quello di passare un puntatore al primo elemento e la
dimensione
    dell'array:
    void MyFunc(T* Array, size_t ArraySize) {
      for(size_t i=0; i<ArraySize; ++i)
        cout << Array[i] << endl;
    }
    Questo metodo si applica sia ad array statici che array
    allocati dinamicamente:
    int main() {
      const size_t Size = 100;
      T MyArray[Size];
      T* MyDynArray = new T[Size];
      MyFunc(MyArray, Size);
      MyFunc(MyDynArray, Size);
      return 0;
    }
    Una soluzione alternativa ed elegante e` quella di utilizzare i
    template e la deduzione implicita dei parametri, ma richiede un
    compilatore standard (o almeno sufficientemente standard):
    template<typename T, size_t Size>
    void MyFunc(T (&Array)[Size])  {
      for(size_t i=0; i<Size; ++i)
        cout << Array[i] << endl;
    }
    int main() {
      int Array1[5];
      int Array2[100];
      MyFunc(Array1);
      MyFunc(Array2);
      return 0;
    }
    Infine una soluzione quasi sempre molto valida e` quella di
    utilizzare la classe std::vector<> al posto dei tradizionali
    array:
    typedef std::vector<int> ArrayOfInt;
    void MyFunc(ArrayOfInt& array);
    ArrayOfInt MyArray;
    MyFunc(MyArray);    // passaggio di un array
12) Come posso generare numeri casuali?
R)  La libreria standard del C (e quindi del C++) prevede le
    funzioni srand() e rand().
    La prima serve a inizializzare il generatore di numeri casuali,
    la seconda invece restituisce un numero casuale nell'intervallo
    0..RAND_MAX. Se vuoi ottenere valori inferiori a RAND_MAX
    e` importante non utilizzare l'operatore di modulo:
    int random_fra_0_e_99() {
      return rand() % 100;
    }
    poiche` in questo modo otterresti una sequenza di qualita`
    assai scarsa... molto meglio utilizzare
    int un_po_meglio_fra_0_e_99() {
      static const double divisore = (1.0 + RAND_MAX)*100.0;
      return static_cast<int>(rand()/divisore);
    }
    RAND_MAX, srand() e rand() sono dichiarate in stdlib.h
13) Come mai ottengo sempre la stessa sequenza di numeri casuali?
R)  Ti sei ricordato di effettuare l'inizializzazione del generatore
    di numeri casuali? Hai evitato di inizializzarlo sempre con
    lo stesso seme? Un buon modo di fare tutto cio` e`:
    #include <stdlib.h>
    #include <time.h>
    /* ... */
    srand(static_cast<unsigned>(time(0)));
14) La sequenza generata da rand() non e` molto buona, dove posso
    trovare generatori di numeri casuali piu` validi?
R)  Il generatore fornito dalla libreria standard non e` solitamente
    di alta qualita`, anche se ha il pregio di essere veloce... Se hai
    esigenze piu` spinte, questo piccolo elenco comprende sia testi
    di teoria, sia software gia` fatto, sia informazioni sui
generatori
    hardware (non pseudo, ma VERI numeri casuali) accessibili via
rete.
 
http://csep1.phy.ornl.gov/rn/rn.html
 
http://random.mat.sbg.ac.at/
 
http://www.math.keio.ac.jp/~matumoto/emt.html
 
http://nhse.npac.syr.edu/random/
 
http://www.taygeta.com/random.xml
 
http://lavarand.sgi.com/
 
http://www.fourmilab.ch/hotbits/
 
http://www.ncsa.uiuc.edu/Apps/CMP/RNG/mascagni/www-rng.html
 
http://random.mat.sbg.ac.at/ftp/pub/data/winrand.zip
 
http://webnz.com/robert/nzc_nr02.html
 
http://www.math.keio.ac.jp/~matumoto/emt.html
 
http://www.ulib.org/webRoot/Books/Numerical_Recipes/bookcpdf.html
15) Che differenza c'e` tra STL e la libreria standard del C++?
R)  La libreria standard del C++ trae spunto da STL, il lavoro
    sviluppato da Alexander Stepanov. Molte delle funzionalita`
    offerte da STL sono state inserite nella libreria del C++,
    tuttavia la libreria del C++ non e` STL.
    STL rimane un progetto a se stante e in continua evoluzione,
    mentre il contenuto della libreria standard del C++ e` deciso
    unicamente dal comitato ANSI/ISO.
16) Lavorando con i numeri in virgola mobile, non riesco ad ottenere
    risultati precisi, perche`?
R)  E` normale, la rappresentazione dei numeri reali in base (base 10,
    base 2,...) e con un numero finito di cifre comporta inerentemente
    un errore di approssimazione. Ad esempio 1/3 in base 10 non puo`
    essere rappresentato con un numero finito di cifre, 1/10 che in
    base 10 equivale a 0.1, in base 2 e` periodico (proprio come 1/3
in base
    10).
    Infine ci sono anche i numeri irrazionali (es. sqrt(3)) che per
loro
    natura non sono mai rappresentabili con precisione in alcuna base.
    Cio` significa che lavorando con i numeri reali devi sempre
    aspettarti risultati affetti da errori di approssimazione. Tali
errori
    possono essere anche molto significativi poiche` le operazioni
aritmetiche
    tendono ad amplificarli.
    Per maggiori riferimenti, puoi leggere
    "Introduzione alla matematica computazionale"
    di R. Bevilacqua, D. Bini, M. Capovani, O. Menchi
    edito da Zanichelli
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg

     }
Mmmm, probabilmente sarebbe meglio fare:
static const double divisore = ( 1.0 + RAND_MAX ) / 100.0;

 static const double divisore = ( 1.0 + RAND_MAX ) / 100.0;
Giusto. Sistemato.


========================================================================
                  F.A.Q. UFFICIALI DI IT.COMP.LANG.C++
                      revisione 1.4  -  15/12/2004
           a cura di diversi partecipanti di it.comp.lang.c++
========================================================================
Indice delle domande:
-1) Perche` dovrei leggere questo documento ?
0) Vorrei imparare il C++, e` necessario conoscere prima qualche altro
   linguaggio oppure posso imparare direttamente questo?
1) Che differenza esiste tra C++, Visual C++, Borland C++ Builder...?
2) Che differenza c'e` tra C e C++?
3) Dove posso trovare un compilatore C++ freeware?
4) Quale editor posso utilizzare per scrivere i miei programmi?
5) Dove posso trovare della documentazione sul C++ e lo standard?
6) Quali libri mi consigliate per imparare il C++ o perfezionare le
   mie conoscenze?
7) Che cosa e` la memoria dinamica? Come si usa?
8) Come posso allocare dinamicamente una matrice a piu` dimensioni e
   utilizzare la notazione M[i][j]?
9) Che cosa e` un header? Come si creano e come si usano?
10) Se separo le definizioni di un template dalla sua dichiarazione
    ponendole in file separati (.h e .cpp) non riesco ad istanziarlo.
    Come posso risolvere il problema?
11) Come si passa un array ad una funzione in C++?
12) Come posso generare numeri casuali?
13) Come mai ottengo sempre la stessa sequenza di numeri casuali?
14) La sequenza generata da rand() non e` molto buona, dove posso
    trovare generatori di numeri casuali piu` validi?
15) Che differenza c'e` tra STL e la libreria standard del C++?
16) Lavorando con i numeri in virgola mobile, non riesco ad ottenere
    risultati precisi, perche`?
17) a -void main() funziona perché non dovrei usarlo?
    b -Posso omettere di scrivere uno statement return in main?
    c -Posso scrivere una main ricorsiva?
18) Posso ereditare pubblicamente da una classe che non ha distruttore
    virtuale?
========================================================================
-1) Perche` dovrei leggere questo documento ?
R)  Potresti trovare qui le risposte alle tue domande rapidamente senza
    dover aspettare che qualcuno ti scriva. Magari se trovi risposte che
    ti fanno sorgere altre domande, cercale sempre in questo documento.
    Quando poi veramente non riesci a venirne fuori, cerca nel gruppo
    it.comp.lang.c++ con parole chiave del tuo problema su google:
 
http://groups.google.it/groups?hl=it&lr=&group=it.comp.lang.c%2B%2B
    (copia anche %2B%2B o la tua ricerca andra` su it.comp.lang.c)
    Magari esistono gia` risposte date da altri.
    Se non riesci a capire le risposte degli altri, controlla i termini
    usati su un tuo libro o in qualche sito web citato in questa faq.
    Questo potrebbe aiutarti anche nel porre poi la domanda ai
    partecipanti del gruppo.
    Se non hai tempo di fare tutto questo, ti verra` forse chiesto
    comunque di farlo, in modi piu' o meno cortesi. Se non hai tempo,
    evita quindi perdite di tempo e cerca di essere preciso nel
    formulare le domande.
 
    Ricordati anche di leggere il manifesto del gruppo:
 
http://www.news.nic.it/manif/it.comp.lang.c%2B%2B.html













   DJGPP   -   
http://www.delorie.com/djgpp

   CygWinB20   -   
http://sourceware.cygnus.com/cygwin/



   Ora ci sono anche quelli Microsoft e Intel, ottenibili e usabili
   entro certi limiti:
 
http://msdn.microsoft.com/visualc/vctoolkit2003/
 
http://www.intel.com/software/products/noncom/


   QEdit



   WinEdit   -   
http://www.winedit.com

   UltraEdit   -   
http://www.ultraedit.com

   MultiEdit   -   
http://www.multiedit.com

   EditPlus   -   
http://www.editplus.com

   Texturizer   -   
http://djst.cjb.net/

   PFE   -   
http://www.lancs.ac.uk/people/cpaap/pfe/

   KDevelop   -   
http://www.kdevelop.org

   CForge   -   
http://www.codeforge.com

   VIM   -   
http://www.vim.org
   Estensione dello storico 'vi' per Unix disponibile anche per Windows.
   Dotato anche di interfaccia grafica con menu` per principianti.
   Diventa uno strumento velocissimo dopo un opportuno addestramento
   all'uso solo-tastiera. Impareggiabile dopo l'accostamento a GNU
   Screen. Consiglio di comprare il libro con il quale l'autore
   finanzia un progetto a scopo umanitario, oppure di scaricarlo,
   stamparlo e leggerselo lontano dal computer.




 
http://www.icce.rug.nl/docs/cplusplus/cplusplus.html

 
http://www.cs.bham.ac.uk/~jdm/CPP/index.html

 
http://www.eskimo.com/~scs/C-faq/top.html

 
http://www.programmazione.it

 
http://www.bruceeckel.com

   Una traduzione in italiano del primo volume si trova su
 
http://pensareincpp.altervista.org
   In inglese, molto valido.


 
http://www.accu.org/

 
http://www.utu.fi/~sisasa/oasis/oasis-cc++.html
 
http://www.la-online.com/cprog.htm




 
http://www.cetus-links.org/
 
http://www.cpsc.ucalgary.ca/~gao/60903/paper.htm















   Un altro ottimo testo.












   std::cout << *VarPtr << std::endl; // supponendo l'esistenza di
                              // ostream& operator<<(ostream&, T&)
   *VarPtr = NewValue         // assegnamento...
   Per allocare un intero array bisogna utilizzare invece la forma
   T* MyArray = new T[Size];
   std::cout << MyArray[0] << std::endl;
   MyArray[5] = NewValue;
















         std::cout << setw(3) << Matrice[i][j] << " ";
        std::cout << std::endl;
      }

     delete[] Matrice;
   }

   #include <vector>





   tipo std::vector) ed evitare cosi' possibili errori di battitura da
   parte del programmatore e rendere piu` gestibile un programma.
   In un file header e` comunque possibile (e in alcuni casi
   necessario) inserire anche definizioni di funzioni, variabili,
   costanti...
   Una volta creato un header per utilizzarlo si utilizza la direttiva
   #include "file.h" all'interno dei file che ne fanno uso.
   Notare che che gli header standard non ereditati dal C sono privi
   di estensione '.h'.







    T MyArray[Size/2];



        std::cout << Array[i] << std::endl;
    }
    Questo metodo si applica sia ad array statici che array
    allocati dinamicamente:
    int main() {
      const size_t Size = 100;
      T MyArray[Size];
      T* MyDynArray = new T[Size];
      MyFunc(MyArray, Size);
      MyFunc(MyDynArray, Size);
      return 0;
    }
    Gli array (come tutti gli altri tipi di dati) possono anche essere
    passati per reference:
    void MyFunc(T (&Array)[], size_t ArraySize) {
      for(size_t i=0; i<ArraySize; ++i)
        std::cout << Array[i] << std::endl;
    }
    Una soluzione alternativa ed elegante e` quella di utilizzare i
    template e la deduzione implicita dei parametri, ma richiede un
    compilatore standard (o almeno sufficientemente standard):
    template<typename T, size_t Size>
    void MyFunc(T (&Array)[Size])  {
      for(size_t i=0; i<Size; ++i)
        std::cout << Array[i] << std::endl;
    }
    int main() {
      int Array1[5];
      int Array2[100];
      MyFunc(Array1);
      MyFunc(Array2);
      return 0;
    }
    Infine una soluzione quasi sempre molto valida e` quella di
    utilizzare la classe std::vector<> al posto dei tradizionali
    array:
    typedef std::vector<int> ArrayOfInt;
    void MyFunc(ArrayOfInt& array);
    ArrayOfInt MyArray;
    MyFunc(MyArray);    // passaggio di un array
12) Come posso generare numeri casuali?
R)  La libreria standard del C (e quindi del C++) prevede le
    funzioni srand() e rand().
    La prima serve a inizializzare il generatore di numeri casuali,
    la seconda invece restituisce un numero casuale nell'intervallo
    0..RAND_MAX. Se vuoi ottenere valori inferiori a RAND_MAX
    e` importante non utilizzare l'operatore di modulo:
    int random_fra_0_e_99() {
      return rand() % 100;
    }
    poiche` in questo modo otterresti una sequenza di qualita`
    assai scarsa... molto meglio utilizzare
    int un_po_meglio_fra_0_e_99() {
      static const double divisore = (1.0 + RAND_MAX)/100.0;
      return static_cast<int>(rand()/divisore);
    }



    #include <stdlib.h>
    #include <time.h>
    /* ... */
    srand(static_cast<unsigned>(time(0)));









17) a -void main() funziona perché non dovrei usarlo?
    b -Posso omettere di scrivere uno statement return in main?
    c -Posso scrivere una main ricorsiva?
R)  a - le due definizioni garantite valide di main secondo lo standard
        sono:
        int main(void)
        int main(int argc, char* argv[])
        la prima è naturalmente riscrivibile in
        int main()
        Il vostro compilatore può permettervi altre forme di
        dichiarazione di main. Non usatele, non avete alcun buon motivo
        per farlo.
    b - si, è espressamente garantito che se il controllo raggiunge la
        fine di main senza incontrare un return l'effetto sarà quello di
        eseguire return 0;
    c - no, è esplicitamente vietato [3.6.1 dello standard].
18) Posso ereditare pubblicamente da una classe che non ha distruttore
    virtuale?
    Risposta breve: No.
    Regola d'oro  : si eredita pubblicamente soltanto da classi con
                    distruttore public virtuale o protected non-virtual
    Perché:
    struct base{ };
    struct derivata: public base{ };
    int main(){ base* unaBase = new derivata; delete unaBase; }
    Deletare polimorficamente una classe senza ditruttore virtuale porta
    ad un comportamento indefinito [5.3.5.3 dello standard].
    Se state pensando che non userete mai una delete in modo polimorfico
    e ritenete quindi di essere nella legalità, avete ragione: è legale
    ma immorale: state violando il principio di sostituzione di Liskov.



Non so se è corretto chiedere a qualcun'altro di rivedere le FAQ senza
proporre un testo sostitutivo o integrativo... forse dovrei farlo da me
stesso ma preferisco di no, anche perchè ho paura di non essere troppo bravo
a sintetizzare e chiarire un concetto nel modo in cui le FAQ sono scritte e
per i fini a cui le FAQ sono destinate.
Comunque volevo chiedere se qualcuno vuole modificare il punto '10' della
suddetta alla luce di quanto da me stesso postato sul thread del 15/12/04
che ha per oggetto "i template mi fanno impazzire", dove si descrive il modo
di risolvere il problema della separazione su files .h e .cpp di
dichiarazione e definizione di classe template. Sullo stesso post è anche
mostrato come risolvere lo stesso problema con le funzioni friend template
che sono necessarie ad esempio per la ridefinizione degli operatori di
immissione ed estrazione dagli streams.
Ovviamente sono disponibile a fornire assistenza, nei limiti di ciò che
conosco, nel caso in cui il mio post dovesse risultare di difficile
comprensione a causa della solita confusione che pervade tutti i miei
scritti...
Ringrazio anticipatamente chiunque voglia occuparsi di questo compito.
Saluti,
fabiomdf
 
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 immissione ed estrazione dagli streams.
E allora, se l'hai già scritto, suvvia! Si tratta solo di ripulirlo un
po', no? Coraggio! :-)



 


 tra le FAQ.
Ulp! Ci proverň ma spero ardentemente che lo faccia qualcuno piů
esperto. Anzi, l'ultima versione che ho postato andrebbe controllata,
specialmente nelle nuove domande che ho inserito. O vogliamo che la
nostra FAQ sia una schifezza? :-)
EMG



Ok, siamo qui per il discorso sui templates ed ecco la mia proposta di
aggiornamento.
La sezione delle FAQ da aggiornare, previo controllo da parte di qualcuno
più esperto di me sull'argomento e correzione da parte di qualcuno più bravo
a sintetizzare concetti e scrivere, è la '10'.
***************** inizio testo ******************
10.1 - Se separo la dichiarazione di un template di classe dalla sua
definizione in due files separati (.h e .cpp) ottengo errori da parte del
linker. Come risolvere?
Il problema si risolve dicendo al compilatore per quali tipi la 'template
class' sarà instanziata.
Ad esempio:
// file handle.h
template<typename T>
class handle
{
public:
    void fun( const T& ) const;
}
// file handle.cpp
#include <iostream>
#include "handle.h"
template<typename T>
void handle<T>::fun( const T& obj ) const
{
    std::cout << obj << '\n';
}
// qui seguono le dichiarazioni di tutti i tipi per cui la classe sarà
istanziata
template class handle<const int>;
template class handle<const char*>;
// file main.cpp
#include "handle.h"
int main()
{
    const int x = 999;
    const char* s = "abc";
    handle<const int> h1;
    handle<const char*> h2;
    h1.fun( x );
    h2.fun( s );
}
************* fine testo ********************
Per quanto riguarda gli errori del linker all'utilizzo di 'friend template
functions', sempre quando la dichiarazione e la definizione sta su files
differenti come nel caso di cui sopra, ho intenzione di scrivere una nota.
Immagino che la domanda dovrebbe essere:
************** inizio testo *****************
10.2 - Quando voglio dichiarare e definire su files separati funzioni
'friend template' la semplice soluzione della sezione precedente non è più
sufficente per il linker che continua a dare errori. Come posso risolvere?
*************** fine testo *****************
Purtroppo oggi non ho più tempo, per cui entro lunedi sera ti faccio avere
anche la risposta a quest'ultima domanda.
Spero sia tutto chiaro, comunque sono sempre qui...
Saluti,
fabiomdf


 anche la risposta a quest'ultima domanda.
Ok, grazie.


 [cut]
Ciao.
Beh, allora che ne pensi/pensate? Va bene cosě? C'č qualcuno che voglia
commentare quanto ho scritto o proporre delle modifiche? Please, scrivete
almeno due righe per dire se credete che questo testo possa venire integrato
nelle FAQ ufficiali e anche se pensate o meno che la seconda domanda sia
anche di interesse per essere svolta nel documento.
Nell'attesa di commenti, vi ringrazio in anticipo.


 anche di interesse per essere svolta nel documento.
Secondo me va bene e una piccola aggiunta, con esempio altrettanto
sintetico e chiaro, sul secondo problema la completerebbe ottimamente.


Io propongo di aggiungere alle FAQ la seguente:
D) Come si sviluppano programmi interattivi, e in particolare con 
interfaccia utente a pieno schermo a carattere, o con interfaccia utente 
a pieno schermo grafica, o con interfaccia utente per ambienti grafici a 
finestre?
R) Il linguaggio C++ standard non supporta lo sviluppo di programmi 
interattivi. D'altra parte, il linguaggio C++ supporta l'accesso a 
librerie in grado di supportare la programmazione interattiva. Di tali 
librerie, alcune sono fornite con il sistema operativo, altre con 
particolari ambienti di sviluppo, altre sono sviluppate separatamente 
dagli ambienti di sviluppo ma supportano un solo ambiente di sviluppo, 
altre sono multipiattaforma. Tuttavia, sono tutte librerie non standard.

 ha
scritto:

Non so, anche se ho capito di cosa parli non direi che "Il linguaggio C++
standard non supporta lo sviluppo di programmi interattivi".
La definizione di "interattivo" presuppone solo che il programma gestisca un
input/output di parametri/risultati della elaborazione e il C++ consente
l'input/output in questo senso.
Saluti,



Aggiunta. Oh, chiaramente se in qualunque momento qualcuno si oppone a
ragion veduta o si accorge di errori, tutto si può rivedere, eh?


 l'input/output in questo senso.
Vuoi proporre un emendamento alla domanda 19? :-)


 EMG
Forse saro' pignolo ma secondo me questa faq e' sbagliata,
io posso sviluppare un programma interattivo a carattere con c++ standard no
?
"interfaccia utente" mi sembra troppo generico ...
Io scriverei qualcosa del tipo poi lo arrangiate voi , io non sono bravo  io
a fare queste cose :P
Il c++ è un linguaggio che permette di creare programmi o librerie  le
libreria che possono essere grafiche ma non solo (es: ci sono librerie
sonore ,di algoritmi ecc.)
si creano tramite il c++ (o altri linguaggi) e servono per creare le
interfacce
utente interattive.
Il mio è solo un consiglio :-)
ciao

 Il mio è solo un consiglio :-)
Mi sembra un po' incompleta...


 ragion veduta o si accorge di errori, tutto si può rivedere, eh?
Anch'io considero questa aggiunta decisamente fuorviante e la
modificherei come segue:
D) Come si sviluppano programmi con interfaccia utente grafica?
R) Il linguaggio C++ standard non supporta lo sviluppo di programmi
dotati di GUI, perche' non esiste una libreria GUI standard e perche' il
linguaggio e' pensato per poter essere implementato anche su sistemi non
dotati di terminale interattivo. Esistono pero' librerie in grado di
supportare la programmazione di interfacce grafiche. Di tali
librerie, alcune sono fornite con il sistema operativo, altre con
particolari ambienti di sviluppo, altre sono sviluppate separatamente
dagli ambienti di sviluppo ma supportano un solo ambiente di sviluppo,
altre sono multipiattaforma. Tuttavia, sono tutte librerie non standard.
D) E programmi con interfaccia a caratteri, ma a schermo pieno invece
che linea per linea?
R) Vale lo stesso discorso delle GUI; esistono solo librerie
proprietarie, o comunque limitate a specifiche piattaforme.
Ciao,
Nicola
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 modificherei come segue:
Modificata, grazie!



Bene siamo qui anche per la seconda domanda (cambia il numero di sezione per
come reputi meglio):
**************** inizio testo *******************
10.2 - Quando voglio dichiarare e definire su files separati funzioni
 'friend template' la semplice soluzione della sezione precedente non č piů
 sufficente per il linker che continua a dare errori. Come posso risolvere?
La soluzione in questo caso č un po' piů complessa della precedente, tanto
che qualcuno preferisce lasciare la definizione delle funzioni friend
template nel corpo della template class stessa.
Per i casi in cui č richiesto di separare dichiarazione e definizione su
files separati esite comunque una soluzione come da esempio seguente. Ponete
attenzione alle righe commentate:
// file templates.h
#ifndef _TMPLT_
#define _TMPLT_
#include <iostream>
// bisogna pre-dichiarare la classe stessa
template <typename T> class my_class;
// quindi la friend template
template <typename T>
std::ostream& operator<<( std::ostream& out, const my_class<T>& obj );
template <typename T>
class my_class
{
public:
    my_class( const T& v );
private:
// ...e, per ultimo, inserire il simbolo <> prima della parentesi
    friend std::ostream& operator<< <> ( std::ostream& out, const my_class<T>&
obj );
    const T val;
};
#endif
// file templates.cpp
#include "templates.h"
// le seguenti sono le dichiarazioni di instanza esplicita (vedi domanda
precedente)
template class my_class<int>;
template class my_class<char*>;
// e questa č specifica per la funzione che ci interessa...
// ricordo che le funzioni membro non hanno bisogno di essere instanziate
per ogni tipo
template std::ostream& operator<<( std::ostream& out, const my_class<int>
&obj );
template std::ostream& operator<<( std::ostream& out, const my_class<char*>
&obj );
template <typename T>
my_class<T>::my_class( const T& v = T() )
    : val( v )
{ }
template <typename T>
inline std::ostream& operator<<( std::ostream &out, const my_class<T>
&obj )
{
    return out << obj.val << '\n';
}
// file main.cpp
#include "templates.h"
int main()
{
    my_class<int> h1(999);
    std::cout << h1;
    my_class<char*> h2("abc");
    std::cout << h2;
    return 0;
}
L'esempio č completo e puň essere compilato cosi come si trova. Ripeto il
concetto che per tutte le funzioni membro sono sufficenti solo le istanze
esplicite di classe per ogni tipo, quindi non č necessario scrivere le
instanze di funzione come fatto sopra per le funzioni friend templates (vedi
domanda precedente sulle classi template).
****************** fine testo ******************
Spero sia tutto chiaro... In ogni caso sono sempre qui. Fatemi sapere,
please.
Buon lavoro,


 come reputi meglio):
Inserito. Anche in questo caso ho ritenuto opportuno mantenere tutto
nell'unica risposta. Ho poi riformattato e corretto un piccolo errore di
italiano. :-)
Nel prossimo messaggio riporto la nuova release cosě la controllate.


========================================================================
                  F.A.Q. UFFICIALI DI IT.COMP.LANG.C++
                      revisione 1.5  -  21/12/2004
           a cura di diversi partecipanti di it.comp.lang.c++
========================================================================
Indice delle domande:
-1) Perche` dovrei leggere questo documento ?
0) Vorrei imparare il C++, e` necessario conoscere prima qualche altro
   linguaggio oppure posso imparare direttamente questo?
1) Che differenza esiste tra C++, Visual C++, Borland C++ Builder...?
2) Che differenza c'e` tra C e C++?
3) Dove posso trovare un compilatore C++ freeware?
4) Quale editor posso utilizzare per scrivere i miei programmi?
5) Dove posso trovare della documentazione sul C++ e lo standard?
6) Quali libri mi consigliate per imparare il C++ o perfezionare le
   mie conoscenze?
7) Che cosa e` la memoria dinamica? Come si usa?
8) Come posso allocare dinamicamente una matrice a piu` dimensioni e
   utilizzare la notazione M[i][j]?
9) Che cosa e` un header? Come si creano e come si usano?
10) Se separo le definizioni di un template dalla sua dichiarazione
    ponendole in file separati (.h e .cpp) non riesco ad istanziarlo.
    Come posso risolvere il problema?
11) Come si passa un array ad una funzione in C++?
12) Come posso generare numeri casuali?
13) Come mai ottengo sempre la stessa sequenza di numeri casuali?
14) La sequenza generata da rand() non e` molto buona, dove posso
    trovare generatori di numeri casuali piu` validi?
15) Che differenza c'e` tra STL e la libreria standard del C++?
16) Lavorando con i numeri in virgola mobile, non riesco ad ottenere
    risultati precisi, perche`?
17) a - void main() funziona perché non dovrei usarlo?
    b - Posso omettere di scrivere uno statement return in main?
    c - Posso scrivere una main ricorsiva?
18) Posso ereditare pubblicamente da una classe che non ha distruttore
    virtuale?
19) a - Come si sviluppano programmi con interfaccia utente grafica?
    b - E programmi con interfaccia a caratteri, ma a schermo pieno
        invece che linea per linea?
========================================================================





 
http://www.news.nic.it/manif/it.comp.lang.c%2B%2B.html













   DJGPP   -   
http://www.delorie.com/djgpp

   CygWinB20   -   
http://sourceware.cygnus.com/cygwin/




 
http://msdn.microsoft.com/visualc/vctoolkit2003/
 
http://www.intel.com/software/products/noncom/


   QEdit



   WinEdit   -   
http://www.winedit.com

   UltraEdit   -   
http://www.ultraedit.com

   MultiEdit   -   
http://www.multiedit.com

   EditPlus   -   
http://www.editplus.com

   Texturizer   -   
http://djst.cjb.net/

   PFE   -   
http://www.lancs.ac.uk/people/cpaap/pfe/

   KDevelop   -   
http://www.kdevelop.org

   CForge   -   
http://www.codeforge.com

   VIM   -   
http://www.vim.org





 
http://www.icce.rug.nl/docs/cplusplus/cplusplus.html

 
http://www.cs.bham.ac.uk/~jdm/CPP/index.html

 
http://www.eskimo.com/~scs/C-faq/top.html

 
http://www.programmazione.it

 
http://www.bruceeckel.com

 
http://pensareincpp.altervista.org
   In inglese, molto valido.


 
http://www.accu.org/

 
http://www.utu.fi/~sisasa/oasis/oasis-cc++.html
 
http://www.la-online.com/cprog.htm


 
http://www.sgi.com/Technology/STL
 
http://www.dinkumware.com/refxcpp.html
 
http://www.cppreference.com/cpp_stl.html
   Alcuni Link sull'Object Oriented in generale:
 
http://www.cetus-links.org/
6) Quali libri mi consigliate per imparare il C++ o perfezionare le
   mie conoscenze?














   Un altro ottimo testo.

































     delete[] Matrice;
   }

   #include <vector>





10) Se separo le definizioni di un template dalla sua dichiarazione
    ponendole in file separati (.h e .cpp) non riesco ad istanziarlo.
    Come posso risolvere il problema?
R)  Gli attuali compilatori hanno bisogno di avere completo accesso
    sia alla dichiarazione che alla definizione di un template quando
    questo viene istanziato. Come conseguenza di cio` non e`
    possibile separare le definizioni dalle dichiarazioni, tutto deve
    essere messo in un unico file header (.h).
    Un modo per risolvere il problema è dire al compilatore per quali
    tipi la 'template class' sarà instanziata.
    Ad esempio:
    // file handle.h
    template<typename T>
    class handle
    {
    public:
        void fun( const T& ) const;
    };
    // file handle.cpp
    #include <iostream>
    #include "handle.h"
    template<typename T>
    void handle<T>::fun( const T& obj ) const
    {
        std::cout << obj << '\n';
    }
    // qui seguono le dichiarazioni di tutti i tipi per cui la classe
    // sarà istanziata
    template class handle<const int>;
    template class handle<const char*>;
    // file main.cpp
    #include "handle.h"
    int main()
    {
        const int x = 999;
        const char* s = "abc";
        handle<const int> h1;
        handle<const char*> h2;
        h1.fun( x );
        h2.fun( s );
    }
    Se però volessi dichiarare e definire su files separati funzioni
    'friend template' la semplice trovata di cui sopra non è più
    sufficiente per il linker che continua a dare errori.
    La soluzione in questo caso è un po' più complessa della precedente,
    tanto che qualcuno preferisce lasciare la definizione delle funzioni
    friend template nel corpo della template class stessa.
    Per i casi in cui è richiesto di separare dichiarazione e
    definizione su files separati esite comunque una soluzione come da
    esempio seguente. Ponete attenzione alle righe commentate:
    // file templates.h
    #ifndef _TMPLT_
    #define _TMPLT_
    #include <iostream>
    // bisogna pre-dichiarare la classe stessa
    template <typename T> class my_class;
    // quindi la friend template
    template <typename T>
    std::ostream& operator<<( std::ostream& out,
                              const my_class<T>& obj );
    template <typename T>
    class my_class
    {
    public:
        my_class( const T& v );
    private:
    // ...e, per ultimo, inserire il simbolo <> prima della parentesi
        friend std::ostream& operator<< <> ( std::ostream& out,
                                             const my_class<T>& obj );
        const T val;
    };
    #endif
    // file templates.cpp
    #include "templates.h"
    // le seguenti sono le dichiarazioni di istanza esplicita (vedi
    // soluzione precedente)
    template class my_class<int>;
    template class my_class<char*>;
    // e questa è specifica per la funzione che ci interessa
    // ricordo che le funzioni membro non hanno bisogno di essere
    // instanziate per ogni tipo
    template std::ostream& operator<<( std::ostream& out,
                                       const my_class<int> &obj );
    template std::ostream& operator<<( std::ostream& out,
                                       const my_class<char*> &obj );
    template <typename T>
    my_class<T>::my_class( const T& v = T() )
        : val( v )
    { }
    template <typename T>
    inline std::ostream& operator<<( std::ostream &out,
                                     const my_class<T> &obj )
    {
        return out << obj.val << '\n';
    }
    // file main.cpp
    #include "templates.h"
    int main()
    {
        my_class<int> h1(999);
        std::cout << h1;
        my_class<char*> h2("abc");
        std::cout << h2;
        return 0;
    }
    L'esempio è completo e può essere compilato cosi come si trova.
    Ripeto il concetto che per tutte le funzioni membro sono sufficenti
    solo le istanze esplicite di classe per ogni tipo, quindi non è
    necessario scrivere le instanze di funzione come fatto sopra per le
    funzioni friend templates (vedi soluzione precedente).




    T MyArray[Size/2];












    void MyFunc(ArrayOfInt& array);
    ArrayOfInt MyArray;









    #include <stdlib.h>
    #include <time.h>
    /* ... */
    srand(static_cast<unsigned>(time(0)));









17) a - void main() funziona perché non dovrei usarlo?
    b - Posso omettere di scrivere uno statement return in main?
    c - Posso scrivere una main ricorsiva?



        int main()





    Perché:



19) a - Come si sviluppano programmi con interfaccia utente grafica?
    b - E programmi con interfaccia a caratteri, ma a schermo pieno
        invece che linea per linea?
R)  a - Il linguaggio C++ standard non supporta lo sviluppo di programmi
        dotati di GUI, perche' non esiste una libreria GUI standard e
        perche' il linguaggio e' pensato per poter essere implementato
        anche su sistemi non dotati di terminale interattivo. Esistono
        pero' librerie in grado di supportare la programmazione di
        interfacce grafiche. Di tali librerie, alcune sono fornite con
        il sistema operativo, altre con particolari ambienti di
        sviluppo, altre sono sviluppate separatamente dagli ambienti di
        sviluppo ma supportano un solo ambiente di sviluppo, altre sono
        multipiattaforma. Tuttavia, sono tutte librerie non standard.
    b - Vale lo stesso discorso delle GUI; esistono solo librerie
        proprietarie, o comunque limitate a specifiche piattaforme.
EMG



Ciao,
mancano le risposte alle domande dalla 12 in su e la 11 è incompleta.
Per favore, puoi inviare nuovamente il testo completo?
Grazie,



Ciao,


    filosofie) "tolleranti" e "di manica larga"
Qui io non sono tanto d'accordo.
Python e` tutto fuorche` un linguaggio tollerante e di manica larga.
Capisco che non e` IT affrontare un discorso sul Python qui, tuttavia
ritengo di dover fare notare questa imprecisione.
-- 
RiK0

 Per favore, puoi inviare nuovamente il testo completo?
Ho clickato sul Reference per vedere il messaggio precedente e ho visto
che è completo. Come mai a te mancano quelle parti? C'è qualcun'altro a
cui mancano parti della FAQ?


 ritengo di dover fare notare questa imprecisione.
Hai fatto bene. Purtroppo non so niente di Python (non l'ho scritta io
quella risposta). Se ti va di riportare l'intera risposta corretta, la
modifico.



Allora c'è qualcosa che mi sfugge... Boh, io accedo ai messaggi del Gruppo
tramite browser via portale di Libero. L' ultima revisione della FAQ che hai
pubblicato è a questo indirizzo:
http://arianna.libero.it/usenet/cgi-bin/ViewArticle.epl?MESSAGE_ID=%3C41C86226%2EED33AF3C%40emagsoftware%2Eit%3E&GRUPPO=it%2Ecomp%2Elang%2Ec%2B%2B&CATEG_PARAM=Gerarchia%20it&t=1103775852
Ogni volta che accedo vedo solo parte della FAQ (fin dove ti avevo già
scritto) anche se la pagina è visualizzata senza errori (almeno per ciò che
mi è dato di capire).
Hai idea di cosa possa provocare questo problema?
... Mentre rispondevo ho provato ad accedere al Gruppo tramite Google e li
vedo che la FAQ è pubblicata per intero. Tra l'altro leggo anche che il
thread è composto da 28 articoli mentre qui sembra composto solo da 6
articoli mentre altri 22 si trovano su un altro thread con stesso oggetto.
Trovate sia necessario imparare ad usare un qualche newsreader tipo knode
(ci mancava pure questo...), o c'è qualcuno che accede come me tramite
browser senza avere problemi?
Ciao,


 browser senza avere problemi?
Io ho sempre utilizzato un newsreader. E' molto più comodo.


 wrote in message
news:pc2sdfu4hf66$.
d...@rikodespammed.com

Considerato che, come si puo' evincere dalla nota poco piu' sotto,
questa risposta ha avuto la benedizione di Alex Martelli [1], ci
penserei un po' prima di cambiarla :-)
Ciao,
Nicola
[1] Chi non conoscesse Alex puo':
a) dare un'occhiata a it.comp.lang.python 
b) cercare il suo nome negli archivi di it.comp.lang.c++


 [1] Chi non conoscesse Alex puo':
Ci conosciamo di persona ;)
-- 
RiK0

         int main()
Questa è imprecisa perché lo standard parla di:
int main() e non di int main(void), quindi andrebbe corretta in:
R)  a - le due definizioni garantite valide di main secondo lo standard
int main()
int main(int argc, char* argv[])
la prima è naturalmente riscrivibile in
int main(void)
ma questo è uno stile C che è preferibile non usare in C++.
Ciao.
-- 
BSD is for UNIX lovers -- linux is for Windows haters.

 ma questo è uno stile C che è preferibile non usare in C++.
Fatto.


 distribuirne il sorgente.
Il punto di forza dei template č proprio il poter scrivere codice
parametrizzato su tipi che sono sconosciuti all'atto della scrittura del
codice; il metodo in questione rende quindi di fatto la libreria 
inutilizzabile. Se potessi usare solo std::vector di tipi predefiniti
sarebbero ancora utili? 


 dover per forza separare le definizioni dalle dichiarazioni? 
i tempi di compilazione.
Anche se sono perfettamente d'accordo che questo si restringa nello 0.1% 
dei casi, e che la soluzione soluzione proposta non è una soluzione: 
quello che ottieni non ha i vantaggi di un template
imho andrebbe rimossa dalle faq
-- 
sbi

 i tempi di compilazione.
A scapito però delle dimensioni dell'eseguibile, perché nel caso di 
istanziazione esplicita viene istanziato tutto il codice della classe,
mentre nell'uso "normale" il compilatore istanzia solo le funzioni
membro della classe che sono realmente usate (cose che tra l'altro 
può essere usata per scrivere codice ancore "più generico").


 può essere usata per scrivere codice ancore "più generico").
sisi ma anche peggio...
la butto lì... inlineare da un .obj non è semplice quanto inlineare da 
un sorgente per esempio
anche se sono drawback minimi rispetto al perdere genericità e 
riusabilità di un template istanziandolo solo per _alcuni_ tipi IMHO
-- 
sbi e buon natale a tutti che va a farsi una settimana dai suoi

 inutilizzabile.
No. Si vuole nascondere il sorgente *senza* impedire all'utente di poter
istanziare template parametrizzati su qualunque tipo gli sia necessario.
E mi sembra che il metodo proposto lo garantisca al solo prezzo di dover
scrivere a mano
template class NomeClasse < NomeTipo >;
per ogni tipo richiesto.


 imho andrebbe rimossa dalle faq
Allora non ho capito io quello che fa la soluzione di cui parliamo. A me
sembrava non toccare i normali vantaggi di un template
(parametrizzazione) a prezzo solo di una dichiarazione manuale delle
varie specializzazioni. Sbaglio?


 può essere usata per scrivere codice ancore "più generico").
Non ti seguo...


 varie specializzazioni. Sbaglio?
caso:
hai come legacy code una libreria che ha un bellissimo
legacy::shared_ptr<>
il tipo che ha scritto la lib mi ha istanziato gentilmente il template 
per legacy::shared_ptr<TIPO_UTILIZZATO_NEL_CODICE_LEGACY>
e legacy::shared_ptr<ALTRO_TIPO_UTILIZZATO_NEL_CODICE_LEGACY>
e ti ha regalato un bello legacy_shared_ptr.h e una lib da linkare
trovi utilissimo quello shared_ptr e vorresti utilizzarlo per
legacy::shared_ptr<TIPO_NON_LEGACY_SPUNTATO_DA_NUOVI_REQUIREMENTS>
cosa fai?
1) chiami il tipo che ha scritto la lib lo minacci di morte finché non
    ti istanzia anche per il tuo tipo
2) chiami il tipo che ha scritto la lib lo minacci di morte finché non
    rimette tutto nel .h
3) essendo il tipo che ha scritto la lib morto ed il suo hd andato
    disperso riscrivi non_legacy::shared_ptr<> e coupli codice a manetta
4)    chiami la neuro e la mandi a casa di sbi
4bis) fai gli auguri di natale a sbi
è a risposta multipla!
pur essendo metaprogrammazione puzza di violazione dell'openclosedprinciple
-- 
sbi e gli auguri a tutti

 Non ti seguo...
a meno che una specializzazione di una classe template sia stata 
esplicitamente istanziata o specializzata, la specializzazione della 
classe template è implicitamente istanziata quando la specializzazione è 
referenziata in un contesto che richiede un tipo completamente definito.
L'istanziazione implicita di una specializzazione della classe template
causa una istanziazione implicita delle dichiarazioni ma non delle 
definizioni o degli argomenti di default delle funzioni membro della 
classe, dei membri statici e membri template [14.7.1.1 dello standard]
in sostanza puoi avere una classe template enorme se ne usi solo una 
funzione membro il resto non viene istanziato salvandoti "spazio". la 
cosa non è vera se istanzi esplicitamente una specializzazione della 
classe, come nel caso di cui parliamo.
ancora molto più in sostanza: stiamo parlando di metaprogrammazione, 
quindi stiamo generando codice; in questa ottica:
-se devi creare codice senza sapere come verrà usato, devi generare
il codice per tutti i casi in cui verrà usato ( tipo devi generare 
funzioni membro che magari non verranno mai usate )(questo è il caso 
della faq)
-se devi creare codice sapendo come verrà usato puoi(devi a dire il vero 
in questo caso visto che lo standard vuole così) risparmiarti di 
generare roba che non viene usata.(e questo è il caso in cui tu hai 
tutto nell'header e le specializzazioni della classe template sono 
create implicitamente)
-- 
sbi

 caso:
Altola! Ecco cosa mi era sfuggito: che la dichiarazione manuale deve
stare nel file di implementazione del template! Sulle prime mi era parso
che potesse stare nel main. A questo punto credo di essere d'accordo
anch'io a rimuovere tutta la trattazione.
Me lo confermate? Vorrei sentire anche l'autore...


4) Quale editor posso utilizzare per scrivere i miei programmi?
io eliminerei dalla faq tutta la sezione relativa a questa domanda. 
Innanzitutto perchè offtopic. Poi perchè di editor per programmatori
ce ne sono a bizzeffe, per non citare quelli embedded nell'ide dei
vari compilatori, ed è inutile cercare di star dietro agli editor non
più supportati, ecc.
Riporterei al limite solo un link alla pagina di google directory con
tutti gli editor:
http://directory.google.com/Top/Computers/Software/Editors/
friol

 
http://directory.google.com/Top/Computers/Software/Editors/
Sentiamo che ne pensano gli altri.


 io eliminerei dalla faq tutta la sezione relativa a questa domanda.
Io la sostituirei con una più generica.
 D. Quale editor/IDE/RAD/GUI-toolkit mi consigliate?
 R. GIYF
Max


Siccome è un bel malloppo di roba, non lo eliminerei con tanta
leggerezza. Vogliamo fare una votazione? Chi è a favore e chi contrario
alla cancellazione della domanda 4 della FAQ?


 alla cancellazione della domanda 4 della FAQ?
Io la lascerei. Anche perche` anche se OT, siccome la gente che fa domande
a riguardo comunque c'e`, almeno la si puo` rimandare alla FAQ.
-- 
RiK0

 Io la lascerei.
A favore: 0
Contrari: 1
Anch'io sono contrario a toglierla.
A favore: 0
Contrari: 2


 alla cancellazione della domanda 4 della FAQ?
Io sono favorevole ad eliminarla. Per inciso, un link di quella sezione non 
è funzionante: 
http://djst.cjb.net/
.
Già che c'ero, ho controllato con uno script tutti link del FAQ, ed i 
seguenti sono risultati non funzionanti:
 
http://www.news.nic.it/manif/it.comp.lang.c%2B%2B.html
http://sourceware.cygnus.com/cygwin/
http://www.remotepoint.com/~jordanh/personal/cygwin/cygwin.html
http://djst.cjb.net/
http://webstore.ansi.org/product.asp?sku=ISO%2FIEC+14882%2D1998
http://www.cs.bham.ac.uk/~jdm/CPP/index.html
http://packetstorm.securify.com/programming-tutorials/
http://cs.nmhu.edu/personal/curtis/cs1htmlfiles/Cs1text.htm
http://nhse.npac.syr.edu/random/
http://lavarand.sgi.com/
http://www.ncsa.uiuc.edu/Apps/CMP/RNG/mascagni/www-rng.html
http://www.ulib.org/webRoot/Books/Numerical_Recipes/bookcpdf.html
Inoltre, il link '
http://www.icce.rug.nl/docs/cplusplus/cplusplus.html
'
andrebbe sostituito con '
http://www.icce.rug.nl/documents/cplusplus/
'.
Max

 andrebbe sostituito con '
http://www.icce.rug.nl/documents/cplusplus/
'.
Aggiornato.
Un grosso grazie a nome di tutti!
E naturalmente tanti auguri di buon Natale a tutti!


 The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg
Ciao,




Io credo che bisogna far conoscere le tecniche senza preoccuparsi delle
politiche di utilizzo. Credo che sia sempre opportuno conoscere una tecnica
che consente di fare qualcosa di nuovo, qualcuno prima o poi se ne servirą
anche per motivi a noi oggi ignoti o per motivi da altri considerati
superflui.
Faccio anche notare che sulle FAQ di comp.lang.c++ (che a torto o ragione
rimane il modello di riferimento, sia considerando l'etą che la presenza di
veri e propri guru del C++) hanno ritenuto a suo tempo di dedicare spazio
all'argomento (sezioni 34.13-14-15) e di risolverlo allo stesso modo (anche
se ci sono alcune inesattezze che non permettono a tutti i compilatori di
funzionare con alcune delle soluzioni proposte).
Saluti,


 EMG
Guarda cosa ho scritto in altro reply sullo stesso thread a proposito del
fatto che le FAQ di comp.lang.c++ hanno una trattazione degli stessi
argomenti (divise in tre capitoli della sezione 34).
Che ne pensi a proposito del fatto che in certi contesti, su software creato
a fini specifici, sono ben chiari tutti i tipi per i quali saranno
istanziati i templates? E dove è possibile che la software house che mette a
disposizione una libreria abbia anche un servizio di assistenza che permette
di personalizzare l'implementazione? O ancora in altri casi che non
immaginiamo oggi?
Io dico (e molti altri prima di me): metti a disposizione una tecnica e non
una politica di utilizzo!
Ciao,


 fabiomdf
In conclusione non si può più rispondere che spezzare la dichiarazione di
una template class dalla sua implementazione non è assolutamente possibile
(come precedentemente sulle FAQ), ma si deve spiegare come fare al costo di
perdere una certa flessibilità che in molti casi REALI non è necessaria.
Commercialmente forse non conviene essere dei teorici puristi della
programmazione generica, bensì dei pragmatici: se non vuoi fare vedere a
chiunque la tua implementazione hai un modo.
Buon Natale a tutti,


 superflui.
Si. Complessivamente sono d'accordo. Anche se per una serie di motivi
filosofici sono a favore della versione 'classica' con l'implementazione
dei template negli header files.
D'altra parte per ora ho avuto la fortuna di cavarmela sempre con librerie
libere. 
-- 
[ RiK0                                ]
[ non credo negli schemi non vincenti ]
[ two is an odd prime number          ]

 scoccia parecchio, ma mi sa che dovò farlo prima o poi...
In realta` non e` molto piu` complesso di usare un software di posta
elettronica, anzi.
Il piu` e` conoscere le convenzioni... ma quelle sono a prescindere dal
metodo di accesso a usenet. :))


 superflui.
In linea di principio sarei d'accordo con te, però la soluzione
proposta è in effetti una non-soluzione ad un non-problema, ossia
risolve un problema che nel 99,9% dei casi non è reale, introducendo
limitazioni enormi.
Pertanto, se si vuole lasciare (anche se io rimango per la rimozione), 
sarebbe bene aggiungere una premessa che spieghi queste problematiche 
(cosa che tra l'altro è stata in parte fatta nelle faq di comp.lang.c++ 
nella sezione 34.12).
Rimango dell'idea della rimozione per un motivo ben preciso:
sono convinto che sia chi sta imparando il C++ a trarre il maggior
vantaggio dalla lettura di faq ben fatte; chi ha già una conoscenza
avanzata del linguaggio in genere ha anche meno problemi nel reperire le
informazioni che gli sono necessarie e soprattutto nel "filtrarle" in
modo critico.
Dato che chi sta imparando non ha il problema di separare definizione ed
implementazione di classi/funzione template ma vuole semplicemente
capire perché il linker gli stia creando problemi nonostante gli sembri
di non fare nulla di sbagliato, penso che l'indicargli la soluzione che
nel 99,9% dei casi è quella corretta, sia una forma di rispetto nei suoi
confronti.
Poi, per carità, questa è solo la mia opinione...
Ciao e Buon Natale a tutto il NG.


 una politica di utilizzo!
Potrei essere d'accordo, ma per come è scritta la faq si sta mettendo a
disposizione una politica di utilizzo e non una tecnica.
Ciao e Buon Natale a Tutti.


 scoccia parecchio, ma mi sa che dovò farlo prima o poi...
Ti capisco, ma ti assicuro che è facile e ne vale senz'altro la pena.


 superflui.
Vogliamo fare una votazione anche per questo? Se a voi va bene,
deciderei io. Se sono il curatore della FAQ è giusto che abbia anche
qualche potere in più. :-) Se nessuno si oppone, io lascerei il punto 10
così com'è.
Fatemi sapere.


 immaginiamo oggi?
Sono d'accordo. Per me deve restare.


 EMG
Mi permetto di aggiungere anche un'altra considerazione.
Immaginiamo di togliere tutta la trattazione dell'argomento. La prossima
volta (e ci saranno altre volte come in passato) che qualcuno chiede al
Gruppo un consiglio su come evitare gli errori del linker cosa diciamo?
Possiamo scegliere:
(1) Liquidiamo il discorso dicendo che deve mettere tutto su un unico file.
(2) Tentiamo una risposta che per essere esauriente forse necessita di una
trattazione ampia e con esempi.
Probabilmente al punto (2) parecchi di noi non avranno voglia di scrivere
codice di esempio e commenti così come si trovano ora nelle FAQ. Quindi si
sarà tentati a non rispondere, senza dare la possibilità all'OP di decidere
da solo se la soluzione (anche se discutibile) è applicabile al suo caso o
meno.
A suo tempo, le indicazioni che ho letto sulle FAQ di comp.lang.c++ mi hanno
risolto un problema che altrimenti mi avrebbe costretto a sostituire i
templates con altre soluzioni. Ora quindi penso che dobbiamo dare la libertà
a chi la vuole di decidere da sè cosa fare con il suo codice.
Saluti,


 limitazione nei tipi istanziabili sia un enorme problema pratico.
Beh.. insomma.
Io direi che in pratica manca lo scopo principale della programmazione
generica. In pratica e` un 'generatore' di codice che fa risparmiare solo
un po' di digitazione, un buon editor di testo potrebbe fare pressoche` lo
stesso.
Sul fatto che la FAQ si possa lasciare ok... (anche se IMHO non e` cosi`
frequently asked, ma vabbe`).
Pero` direi che invece e` un grosso problema pratico... in pratica la
libreria e` abbastanza castrata, dal mio punto di vista.
Il punto di forza dei template e` che possono essere usati perfettamente su
tipi di dati che non sono nemmeno stati pensati al momento della scrittura
della libreria.
Personalmente una libreria che mi ponesse una simile limitazione la
schiverei come la peste, se appena appena possibile.


 chiunque la tua implementazione hai un modo.
A costo di sembrare pedante ribadisco ancora una volta che sono convinto
che tu stia proponendo una situazione esattamente opposta a quella reale. 
La flessibilità che perdi è enorme (e non "una certa"), ed è necessaria
in quasi tutti i casi reali, mentre è proprio la necessità della
separazione tra dichiarazione e definizione a non essere quasi mai
necessaria (ed in ogni caso anche fosse necessaria la soluzione proposta
-per quanro al momento l'unica- crea più problemi di quelli che
risolve).
Qui non si tratta di teoria ma proprio di pratica. Direi che siamo in
totale disaccordo su tutto, perché a me la tua pare proprio una
soluzione teorica ma con bassissima (se non nulla) applicabilità
pratica. 
Ti invito a fare un uso di tutte le classi/funzioni template della
libreria standard solo per i tipi predefiniti ed a riflettere su quanto
esse diventino inutili...
Ciao.


 a chi la vuole di decidere da sè cosa fare con il suo codice.
Noto però con estremo dispiacere che non hai letto il mio intervento a
riguardo...


 stesso.
Non solo, i template sono anche di piů. Grazie al fatto che la loro
istanziazione avviene all'atto della compilazione č possibile sfruttare
questo fatto per avere controlli di vario tipo durante la compilazione e
non solo in esecuzione (come possibile con codice "normale").
Ciao.


 limitazione nei tipi istanziabili sia un enorme problema pratico.
Rispondo qui anche agli altri tuoi post. Sulla faq in questione ho 
solo espresso la mia opinione, ovviamente la decisione non spetta a me e
mi sta benissimo qualunque decisione prendiate.
Sul fatto però che la limitazione della libreria sia solo teorica e non
pratica non sono per nulla d'accordo. Anzi, è proprio l'opposto... 
Se la libreria standard mettesse a disposizione solo template istanziati
con tipi predefiniti pensi avrebbe la stessa validità? Che contenitore
useresti per un array di classi da te definite non potendo usare quelli
standard? Alla fine la libreria standard risulterebbe perfettamente
inutile.
Ciao.


 inutile.
Sono d'accordo. Ma i templates della libreria standard sono, per forza
di cose, pensati per la massima genericità. Mentre i templates
eventualmente offerti da una libreria commerciale (di questo si sta
parlando) possono benissimo offrire solo ciò che è stato pagato (e
potrebbe addirittura non avere senso istanziarli sul tipo generico).


 EMG
Ad esempio il discorso vale per software che manipola oggetti grafici come
pulsanti, campi di input, finestre eccetera. Si tratta di oggetti in numero
finito. Oppure software che manipola in qualche modo oggetti contabili come
clienti, fornitori, dipendenti. Sono tutti casi in cui si ha a che fare con
un numero di elementi che è finito e che comunque è controllato dal
produttore del software stesso che al momento in cui disegnerà un nuovo
oggetto gestibile dalle sue funzioni generiche ne includerà l'istanza
nell'implementazione delle stesse.


 potrebbe addirittura non avere senso istanziarli sul tipo generico).
È su questo che non mi trovi affatto d'accordo.
Sono pienamente convinto che una tale libreria (salvo pochi e
particolari casi) avrebbe una vita decisamente breve.


 nell'implementazione delle stesse.
Il discorso non mi pare che regga... Se stiamo parlando di applicazioni
è verissimo quello che dici, ma non vedo la necessità di nascondere
l'implementazione delle funzioni/classi template, visto che basta non
fornire il codice.
Se stiamo parlando di librerie il discorso cade perché di fatto
impedisco all'utilizzatore della libreria di usarla...


 Ciao.
Per finire (almeno da parte mia) non credo stia a noi ipotizzare come e
perchè usare quella tecnica. Il fatto che si possa comunque risolvere (anche
se in modo discutibile) un problema è quanto si voleva spiegare. Se anche in
un Gruppo così importante e numeroso come comp.lang.c++ hanno ritenuto di
trattare l'argomento e proporre le stesse soluzioni è evidente che la a
qualcuno serve. A suo tempo, con questo stesso problema da risolvere, sono
stato spedito a leggere le FAQ.
In alternativa si può cancellare tutto e rispondere che non c'è soluzione.
Saluti,


 non solo in esecuzione (come possibile con codice "normale").
Mi sono spiegato male. Se costringi ad usare i templates solo per i tipi
predefiniti da chi ha fatto la libreria, in pratica essi diventano
effettivamente poco piu` di un modo per scrivere meno codice (o usare un
buon editor).
Si trovano immensamente limitati rispetto ai templates semplici. La mia
frase era poco chiara, ma pensavo si capisse poi dal resto del post :))


 In alternativa si può cancellare tutto e rispondere che non c'è soluzione.
E lasciare la risposta con un avvertenza *molto* esplicita sugli svantaggi
che  questa struttura comporta? Chi ne ha bisogno la usera`. Chi e`
indeciso ci pensera` su...


 frase era poco chiara, ma pensavo si capisse poi dal resto del post :))
Sě, hai perfettamente ragione.
In effetti avevo avevo frainteso.


 In alternativa si può cancellare tutto e rispondere che non c'è soluzione.
Ti faccio però notare che il punto 34.12 delle faq che tu citi (che è
giusto *prima* della soluzione proposta) è ben chiaro:
<quote>
Why can't I separate the definition of my templates class from it's
declaration and put it inside a .cpp file?
If all you want to know is how to fix this situation, read the next FAQ.
But in order to understand why things are the way they are, first accept
these facts:
1 A template is not a class or a function. A template is a "pattern"
that the compiler uses to generate a family of classes or functions.
2 In order for the compiler to generate the code, it must see both the
template definition (not just declaration) and the specific
types/whatever used to "fill in" the template. For example, if you're
trying to use a Foo<int>, the compiler must see both the Foo template
and the fact that you're trying to make a specific Foo<int>.
...
</quote>



Non ho capito lo scopo di questo "quote". Conosco il documento e mi sembra
che serve a spiegare le ragioni degli errori lasciando alle sezioni
seguenti. Traduzione approssimativa dell'inizio della risposta: "Se tutto
ciò che vuoi è come risolvere il problema leggi la prossima FAQ. Per
comprendere da cosa il problema è originato prima conosci questi fatti...".
Da qui segue la spiegazione sullla necessità da parte del compilatore di
vedere sia la definizione del templete che gli specifici tipi usati to "fill
in" lo stesso template. Mi sono perso qualcosa?
Forse vuoi suggerire che è preferibile includere nelle nostre FAQ una
introduzione come questa che permetta di capire perchè poi si propone
"l'istanza esplicita della classe" come soluzione? Ho preferito non
appesantire troppo la trattazione e credo che la natura del problema si
desuma dal testo. Ho anche evitato di parlare dei singoli templates di
funzioni non-membro, immaginando che la soluzione venga fuori dalla
trattazione delle classi.
Ciao e buone Feste,


 che serve a spiegare le ragioni degli errori lasciando alle sezioni
seguenti.
[CORRIGE] Non ho capito lo scopo di questo "quote". Conosco il documento e
mi sembra che serva a spiegare le ragioni degli errori riamndando le
soluzioni alle sezioni seguenti.
Tra l'altro mi capita spesso che parte delle citazioni con "> >" finisce
sulla riga successiva rendendo il testo non leggibile. Cercherò di capire
perchè e rimediare.


 "l'istanza esplicita della classe" come soluzione? 
Non proprio. Secondo me sarebbe necessaria (ripeto ancora una volta a 
scanso di equivoci: questa è solo la mia opinione) un'introduzione che 
faccia capire che la soluzione proposta va usata solo in caso di reale
necessità e non solo per uniformità con le classi non template, perché
ha delle conseguenze che, e questa non la ritengo una mia opinione, 
non vengono messe in risalto nella faq. Conseguenze che possono 
inficiare l'uso stesso dei template. 
