Home ] Su ] Novità ] Hardware ] Software ] Windows ] Sicurezza ] Linguaggi ] Cerca ] Contatta ] Guestbook ] Mappa ] Info su... ]

Le FAQ sul linguaggio C++


La versione originale di questa FAQ è sempre disponibile all'indirizzo http://www.programmazione.it.
Nel suddetto indirizzo potete trovare materiale più aggiornato rispetto al contenuto della FAQ sul linguaggio C++ di questo sito.
Prima di continuare a leggere le seguenti sezioni della FAQ sul linguaggio C++, vi invitiamo a prendere visione del disclaimer, dei copyright e delle note di revisione, situate in questa pagina.



F.A.Q. UFFICIALI DI IT.COMP.LANG.C++

revisione 1.2 - 26/5/2000
a cura di diversi partecipanti di it.comp.lang.c++

 

Indice delle domande

  1. Vorrei imparare il C++, e` necessario conoscere prima qualche altro linguaggio oppure posso imparare direttamente questo?
  2. Che differenza esiste tra C++, Visual C++, Borland C++ Builder...?
  3. Che differenza c'e` tra C e C++?
  4. Dove posso trovare un compilatore C++ freeware?
  5. Quale editor posso utilizzare per scrivere i miei programmi?
  6. Dove posso trovare della documentazione sul C++ e lo standard?
  7. Quali libri mi consigliate per imparare il C++ o perfezionare le mie conoscenze?
  8. Che cosa e` la memoria dinamica? Come si usa?
  9. Come posso allocare dinamicamente una matrice a piu` dimensioni e utilizzare la notazione M[i][j]?
  10. Che cosa e` un header? Come si creano e come si usano?
  11. 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?
  12. Come si passa un array ad una funzione in C++?
  13. Come posso generare numeri casuali?
  14. Come mai ottengo sempre la stessa sequenza di numeri casuali?
  15. La sequenza generata da rand() non e` molto buona, dove posso trovare generatori di numeri casuali piu` validi?
  16. Che differenza c'e` tra STL e la libreria standard del C++?

 

0) Vorrei imparare il C++, e` necessario conoscere prima qualche altro linguaggio oppure posso imparare direttamente questo?

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! :-)

Torna all'indice

1) Che differenza esiste tra C++, Visual C++, Borland C++ Builder...?

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.

Torna all'indice

2) Che differenza c'e` tra C e C++?

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.

Torna all'indice

3) Dove posso trovare un compilatore C++ freeware?

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 più 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 più 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.
Torna all'indice

4) Quale editor posso utilizzare per scrivere i miei programmi?

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 è sostituito dal successivo.
  • The SemWare Editor - http://www.semware.com
    E' il successore di QEdit con molte caratteristiche in più, una delle quali è 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 configurabilità 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 può aver bisogno allo interno dell'editor stesso.
  • UltraEdit - http://www.ultraedit.com
    E' un altro editor per Win32 molto simile al precedente che manca però del linguaggio WIL, ma offre in più la possibilità 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 più la possibilità 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.
  • 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.

Torna all'indice

5) Dove posso trovare della documentazione sul C++ e lo standard?

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:
Ecco dei link in cui si trova documentazione sulla libreria standard del C++ e su STL (vedere faq N. 15):
Alcuni Link sull'Object Oriented in generale:
Torna all'indice

6) Quali libri mi consigliate per imparare il C++ o perfezionare le mie conoscenze?

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 (conte@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 è 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
Torna all'indice

7) Che cosa e` la memoria dinamica? Come si usa?

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 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. Torna all'indice

8) Come posso allocare dinamicamente una matrice a piu` dimensioni e utilizzare la notazione M[i][j]?

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 riga;
       std::vector 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& operator[](int i) { return body[i]; }
       const std::vector& 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; }
   };
Torna all'indice

9) Che cosa e` un header? Come si creano e come si usano?

Un header è 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 è 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 così 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++.

Torna all'indice

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?

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).

Torna all'indice

11) Come si passa un array ad una funzione in C++?

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
    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
Torna all'indice

12) Come posso generare numeri casuali?

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 Torna all'indice

13) Come mai ottengo sempre la stessa sequenza di numeri casuali?

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(reinterpret_cast<unsigned>(time(0)));
Torna all'indice

14) La sequenza generata da rand() non e` molto buona, dove posso trovare generatori di numeri casuali piu` validi?

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.

Torna all'indice

15) Che differenza c'e` tra STL e la libreria standard del C++?

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.

Torna all'indice


--------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   http://www.cli.di.unipi.it/~marotta
--------------------------------------------------

 



Disclaimer

SourceNet non riconosce nessun tipo di garanzia per il contenuto di tutta la sezione dedicata alle FAQ sul linguaggio C++ pubblicata su questo sito (SourceNet Italia).
Tutto il contenuto della FAQ sul linguaggio C++ è fornito "così come è", senza alcuna garanzia di qualsiasi tipo, sia espressa che implicita, ivi incluse, senza limitazioni, le garanzie implicite di commerciabilità o idoneità per uno scopo particolare ovvero quelle che escludano la violazione di diritti altrui. L'intero rischio derivante dall'uso o dalle prestazioni del contenuto di tutta la sezione della FAQ sul linguaggio C++ rimane a carico dell'utente.


Copyright

Il contenuto della sezione delle FAQ sul linguaggio C++ situata in questo sito è la copia della FAQ sul linguaggio C++, pubblicata all'indirizzo http://www.programmazione.it.
Il contenuto dell'intera FAQ sul linguaggio C++ è di proprietà di Paolo Marotta.
Viene concessa la possibilità di poter copiare il contenuto dell'intera FAQ sul linguaggio C++ di questo sito solo previa autorizzazione di Paolo Marotta (http://www.cli.di.unipi.it/~marotta).


Note sulla revisione

La versione di questa FAQ è aggiornata alla versione 1.2 (26/05/2000).


Pagine FAQ sulla programmazione

 

Torna ad inizio pagina

Le FAQ sul linguaggio C ] [ Le FAQ sul linguaggio C++ ] Le FAQ sul linguaggio HTML ] Le FAQ sui Modem ] Le FAQ sul linguaggio Java ] Le FAQ su Outlook Express e sul prefisso R: ] Le FAQ su Outlook Express 5 ] Le FAQ sul linguaggio Perl ] Le FAQ sui dischi rigidi ] Le FAQ sui modem Conexant ] Le FAQ sul linguaggio C++ ] Le FAQ su GeForce ] La FAQ su Hamster ]

Ultimo aggiornamento : 17/01/2009.   
Home ] Su ] Novità ] Hardware ] Software ] Windows ] Sicurezza ] Linguaggi ] Cerca ] Contatta ] Guestbook ] Mappa ] Info su... ]

Copyright © 1997-2070, Joseph Parrello. Tutti i diritti sono riservati.

Siete il visitatore n. Contatore Sito
Bpath Contatore
dal 17 gennaio 2009.