Newsgroup: it.comp.lang.c++
Titolo: Linee Guida (da Iniziare con il C++)

Ringrazio innanzitutto, tutti coloro che hanno risposto al thread "Iniziare
con il C++".
Ho notato che quelle poche cose di C che sapevo erano in realtà ernao
proprio di C e non di C++ che scopro ogni giorno essere molto differente:
pensavo banalmente che fosse C con aggiunta di oggetti e invece c'è un sacco
di cose.... namespace, template....
La cosa che più mi ha stupito è scopire che printf() non è standard C++ e
allora chiedo tutta la <stdio> è da buttare?
Davvero devo usare quel bizzarro modo di scrivere cout << "dxkdkdk" per
avere dell'output? (forse è bizzarro per me che sono abituato in java, e li
non si possono ridefinire gli operatori.... (vi prego ditemi che cout <<
"dxkdkdk" è possibile in quanto è stato ridefinito l'operatore <<
altrimenti mi dovete spiegare cosa sono cin e cout)
Insomma se qualcuno avesse voglia di scrivere quale linea seguire per
scrivere in C++ puro (senza sporcarsi col C)
farebbe una bella cosa..... e io lo apprezzarei tanto ;-)
Ciao e grazie ancora a tutti

 farebbe una bella cosa..... e io lo apprezzarei tanto ;-)
Beh, innanzittutto gli include di sistema vanno scritti senza ".h" finale... 
:)
Ciao!
-- 
---
*************** | Have you ever retired a human by mystake?
*** Azathot *** |
*************** | To contact me, ask me gently. Thanks.

 offrono
mah! prova ad internazionalizzare una stringa formattata con gli stream 
senza mettere mano al codice per ogni lingua
-- 
  < 
http://www.reactos.com/
 >  Open source clone of Windows NT. Current
      Don't stand, REACT!      version 0.1.2. C, C++ and ASM developers
                               and beta testers are welcome!

 senza mettere mano al codice per ogni lingua
spiega scusa ... ???
ciao

senza mettere mano al codice per ogni lingua
Condivido l'impressione :)
Gli stream hanno secondo me fatto un passo *indietro* rispetto
alla gia' rigida formattazione printf.
Nel C++ si e' tornati al basic !
Avvicinandomi al C++ io mi sarei aspettato qualcosa di piu'
evoluto (ad esempio una sostituzione non sequenziale nei
template di output) e non di piu' arretrato.
Ovviamente in C++ uno puo' costruire di tutto... ma la base
offerta dalla libreria standard e' in questo campo meno
interessante di quella C.
Andrea

 Nel C++ si e' tornati al basic !
Non sono d'accordo. Nell'ambito in cui gli stream sono utili, trovo molto 
comodo il fatto di non dover controllare per ispezione la correttezza delle 
stringhe di formattazione. Qualcosa del genere:
        printf( "%s: +%ld.%ld%%\n", x, y, z );
necessita di ispezionare la tipologia delle variabili x, y e z, senza 
considerare il fatto che è necessario verificare che la stringa di 
formattazione non contenga errori e/o parametri "nascosti" (tipo l'uso 
della percentuale come segno di percentuale vero e proprio)! Brrr...
Meglio
        cout << x << ": +" << y << "." << z << "%" << endl;
che non necessita altro che la verifica che l'output di questo comando sia 
la stringa attesa.
Senza contare un altro scenario interessante: quello in cui vuoi verificare 
che una tua routine/metodo/funzione dia l'output atteso fornendogli uno 
stream. In questo caso, il vantaggio di poter sostituire "al volo" uno 
string stream ad uno stream permette la verifica automatica della 
correttezza dell'elaborazione.


 [...]
Loro si riferivano a problemi di internazionalizzazione. In lingua diverse
la struttura della frase (intesa proprio come ordine delle parole al suo
interno) puņ essere diversa. Come puoi tenere conto della cosa usando gli
stream standard?
-- 
Marco Barisione
http://spazioinwind.libero.it/marcobari/

 stream standard?
Non credo che gli stream se ne debbano occupare, così come "printf" non si 
occupa dell'uso che viene fatto della stringa di formattazione. 
In ogni caso, la cosa più semplice che mi viene in mente è quella di usare 
delle regole di riscrittura, tali per cui l'output viene ridotto ad un solo 
invio su stream. Sulla falsariga del "get_text()".


 invio su stream. Sulla falsariga del "get_text()".
Ed era proprio quello che Griffini ha detto che si sarebbe aspettato dallo
standard ma che lo standard non ha dato.


 standard ma che lo standard non ha dato.
Griffini aveva detto che era quello che si aspettava DAGLI STREAM (non dallo 
standard), e che gli stream non gli hanno dato. Per me, hanno fatto bene a 
non darglieli! :)


stream standard?
Nota che questo non e' possibile nemmeno con la versione standard di
printf. La versione Unix invece permette di specificare parametri
posizionali.
Ciao,
Nicola

correttezza dell'elaborazione.
Questa fra tutte e' forse la parte da cui mi aspettavo di
piu' da un approccio OO... purtroppo adducendo motivazioni
prestazionali il dispatching verso la maggior parte dei
metodi di ostream e' non-virtuale (ovvero errato), con il
risultato che mentre e' possibile alterare la *destinazione*
non e' possibile alterare la *formattazione* dei tipi nativi.
Detto in altri termini puoi decidere dove finiscono i
caratteri, ma non puoi ad esempio fare in modo di racchiudere
le stringhe fra apici doppi e con escaping dei caratteri
speciali contenuti.
Anche una cosa come la costruzione virtuale degli stream in
base al nome del "file" sarebbe stata secondo me interessante.
Anche questa callback purtroppo e misteriosamente manca.
Andrea

 base al nome del "file" sarebbe stata secondo me interessante.
Cioč?


Cioč?
Come sai in C++ e' possibile ridefinire un allocatore globale
in modo che tutte le richieste di memoria vengano fatte a
questo allocatore.
Una cosa interessante sarebbe stata che gli stream standard
avessero utilizzato un sistema di creazione virtuale che
offrisse qualcosa di simile a quella redirezione.
Immagina di avere:
  //
  // Interfaccia stream
  //
  class StreamImpl
  {
    public:
      StreamImpl();
      virtual ~StreamImpl();
      virtual void seek(long pos,int from)           = 0;
      virtual int read(unsigned char *buf,int size)  = 0;
      virtual int write(unsigned char *buf,int size) = 0;
  };
  //
  // Interfaccia protocollo
  //
  class StreamBuilder
  {
    public:
      StreamBuilder();
      virtual ~StreamBuilder();
      StreamImpl *build(const std::string& specs) = 0;
  };
(nota, questo esempio serve solo a rendere l'idea, e mancano
ovviamente una montagna di dettagli)
In pratica gli oggetti "file" standard non sarebbero che
dei proxy che puntano a degli StreamImpl. La chiamata di
open non fa che chiamare tutti gli StreamBuilder in vita
al momento (vengono registrati dal costruttore e de-registrati
dal distruttore) passando le specifiche di creazione e il primo
che risponde con un oggetto StreamImpl si aggiudica lo stream.
Alcune possibili idee per uno stream sono ad esempio
"tcpstream:..." oppure addirittura "http:..." che potrebbe
usare delle chiamate http per comunicare le richieste di
lettura/scrittura ad un server web dall'altra parte del mondo.
Oppure qualcosa come
   "gzip:..."
che permette di avere degli stream compressi (che si appoggiano
ad altri stream es "gzip:http:..."). Altre possibilita' sono
stream in memoria ("mem:" ?), stream criptati, stream che si
appoggiano a tabelle o query di database, cose analoghe al "tee"
unix che permette di prendere una "derivazione", uno stream
che lancia un processo e comunica con il suo stdin/stdout,
stream che supportano rollback...
... e chi piu' ne ha piu' ne ha ...
(come diceva un mio ex collega :o)
Se la libreria fornisce una callback allora automaticamente
ottengo che tutto il codice che apre uno stream puo' usare
anche i miei stream "custom" semplicemente grazie al nome
che usa. Esattamente come grazie all'allocatore custom tutto
il codice chiede la memoria a me e puo' struttare caratteristiche
speciali del mio allocatore.
E invece no. Il codice che chiama open chiama open e basta.
Secondo me un sistema di callback sugli stream sarebbe stata
una aggiunta interessante.
Chiaramente io posso implementare questo meccanismo di
stream con costruzione virtuale per i miei usi... ma il
codice scritto da altri (es una libreria) non lo potra'
mai utilizzare se la open viene fatta nella libreria.
Andrea

 offrisse qualcosa di simile a quella redirezione.
Scusa Andrea, perché non proponi questa cosa in "comp.lang.c++.moderated"? 
Magari chissà che non venga proposto e portato avanti in sede di standard?


 non e' possibile alterare la *formattazione* dei tipi nativi.
La formattazione e` compito dei locale, non degli stream.
Gli stream si limitano a mettere assieme un locale e uno streambuf,
delegando la formattazione ai locale e gestoine della destinazione
agli streambuf.  Per fare questo non hanno bisogno di funzioni
virtuali, quindi i metodi degli stream sono giustamente non-virtuali.
        Mauro