Newsgroup: it.comp.lang.c++
Titolo: Header iniziale

Salve a tutti. In quanti modi si puo' iniziare un sorgente ?
#include <iostream.h> ?
#include <iostream.c> ?
#include <iostream>
using namespace std; ?
io conosco solo questi tre se qualcuno vuole aggiungerne degli altri mi
fareste cosa gradita.
Saluti

 fareste cosa gradita.
ce n'è solo uno, in realtà.
-- 
MSN: sirpsycho_78 -at- hotmail dot com
"Miss, simme juti a fernì int' 'o cess, e mo' ca rimango 'i sulo, te 
mann 'a fanculo."
"Chì la zent la pasa a far banzeina e quel l'an an'va'! Non si può 
andare avanti così!"

 using namespace std; ?
Pessima abitudine, come ho spiegato recentemente in una mia risposta a un
tuo messaggio.
Max

 fareste cosa gradita.
Dei tuoi tre solo uno e' valido. Guarda poi che queste non sono formule
magiche di buon auspicio, ma header da includere per inserire le
dichiarazioni di alcuni elementi della libreria standard nel tuo
programma.
Ciao,
Nicola Musatti

Salve grazie Nico, volevo chiederti una info.
Scrivere il sorgente in questo modo:
#include <iostream>
std::cout << " bla bla bla";
std::cin >> alpha;
per me è un po' macchinoso e lungo da scrivere,
invece:
#include <iostream>
using namespace std;
cout << "bla bla bla";
cin >> alpha;
è piu' semplice non ti pare ?

E' piu' semplice, e forse per cin e cout e' anche equivalente, ma in 
generale migliora la leggibilita' del codice in progetti dove ci sono 
piu' moduli sviluppati da piu' gruppi di persone.
Esempio:
Un gruppo crea una classe vector, intendendo la struttura dati, ed usa 
DT come namespace.
Un altro gruppo crea una classe vector intendendo i vettori di R^3, ed 
usa ML come namespace.
Per forza di cose dovra' essere usato ML::vector e DT::vector.
Ciao
robric ha scritto:


 è piu' semplice non ti pare ?
#include <iostream>
using std::cout;
using std::cin;
cout << "bla bla bla";
cin >> alpha;
e' cosi' brutto?
-- 
Torno subito

Ciao ZeD;
non dico che è brutto ma è piu' complicato e macchinoso in questo
modo scrivere il codice non ti pare
se utilizzo
#include <iostream>
using namespace std;
credo che sia piu' facile per me che scriverlo in un altra maniera....
Saluti

 modo scrivere il codice non ti pare
beh, se consideri come prioritario esclusivamente il risparmio 
di caratteri digitati, cosa sempre legittima (ma adatta giusto a 
micro programmi "hello world"), allora hai ragione tu.
Rendendo invece di default non tutti i nomi del namespace ma 
solo quelli strettamente necessari (cin e cout), eviti effetti 
collaterali in un programma più corposo che, potenzialmente, può 
collidere col namespace standard ridefinendo molti nomi in comune.
Tieni anche conto che poi alla fin fine questi "conflitti" li 
scopri se e solo se : 1) non c'è matching degli argomenti o dei 
tipi, e te lo dice il compilatore, oppure 2) la roba compila in 
modo silenzioso ma tu, saggiamente, poi fai il debug passo passo 
e ti accorgi che, invece di chiamare la TUA funzione definita da 
te e che tu intendevi implicitamente, ha codificato la chiamata 
di quella del namespace std (che ha MOLTI nomi, più di quelli 
che uno considera su due piedi), dato che con using gli hai 
detto di usarla di default per tutto.
Quindi occhio a quel che può succedere a lungo raggio
ciao
Soviet


Fred Mammola e il Tempio di Sdenk Settemani Urrins wrote:
 > robric wrote:
 >> Salve a tutti. In quanti modi si puo' iniziare un sorgente ?
 >> #include <iostream.h> ?
 > no
In generale. Visto il nivello della domanda, mi domando se non
sarebbe megliore dire ch'a volta communque, si può avere motivi
(vecchio compilatore, etc.) di farlo così, perche invecci...
 >> #include <iostream.c> ?
 > figuriamoci
qui, non c'è mai motivi che lo giustificano.
 >> #include <iostream>
 > ok
Credo che non mi è mai arrivato neanche. Che un sorgente
incommincia con #include <iostream>, voglio dire.
(Ma depende dall contesto. Quasi il solo motivo che scrivo
piccoli programmi di un solo sorgente è per provare qualcosa con
diversi compilatori. Allora, incommencio:
     #ifndef OLD
     #include <iostream>
     #include <ostream>
     #else
     #include <iostream.h>
     #define std
     #endif
Ma quello non è una considerazione di principiante:-).)
 >> using namespace std; ?
 > io non lo metterei...
Neanche io.
 >> io conosco solo questi tre se qualcuno vuole aggiungerne
 >> degli altri mi fareste cosa gradita.
 > ce n'è solo uno, in realtà.
Mi sembra che il solo modo giuso d'iniziare un sorgente sarebbe
quel'cosa come:
     //  File   : xxx.cc
     //  Autore : ...
     //      Copyright ...
seguito di commentari sul contenuto. Ma ci son moltissimi
varianti. (Per non sò più qual motivo, uso io degli commentari
stilo C per l'intesta: il nome di file, l'autore e il
copyright.)
Dopo, si trova sempre l'include che contienne le classe che
realizzo; in XXX.cc allora:
     #include "XXX.hh"
Solo dopo arrivano gli include di sisteme. E anche qui,
<iostream> è piùtosto raro. Molto più frequenti son <string>,
<vector>, o anche <ostream> o <istream>. In certe applicazioni,
credo che anche <boost/shared_ptr.hpp> sarebbe più frequente di
<iostream>. (Uso il collectore di Boehm, allora non avvienne
molto da me, mà senza il collectore, sarebbe quasi dappertutto.)
Solo per dire che la domanda era già mal formulato.
-- 
James Kanze                                 mailto: 
james...@free.fr
Conseils en informatique orientée objet/
                        Beratung in objektorientierter Datenverarbeitung
9 pl. Pierre Sémard, 78210 St.-Cyr-l'École, France 
+33 (0)1 30 23 00 34

robric wrote:
 > Salve grazie Nico, volevo chiederti una info.
 > Scrivere il sorgente in questo modo:
 > #include <iostream>
 > std::cout << " bla bla bla";
 > std::cin >> alpha;
 > per me è un po' macchinoso e lungo da scrivere,
Se il nome degli oggetti son std::cout e std::cin? Se no, perche
non incommiciare:
     #define o std::cout
     #define i std::cin
     #define v std::vector
     #define s std::string
? È certo che dopo, è meno lungo da scrivere.
Più serioso, direi che per i piccoli programmi di prova, non
importe, ma nelle applicazioni reali, std::cout e std::cin si
usano cosi poco che non fa fastidio scrivere sempre i suoi nomi
completi.
 > invece:
 > #include <iostream>
 > using namespace std;
 > cout << "bla bla bla";
 > cin >> alpha;
 > è piu' semplice non ti pare ?
A scrivere. Non forse a leggere. (Per cin o cout, credo che c'è
poco problemi. Ma per string? O per lower_bound?)
