Libreria standard C ++: come scrivere wrapper per cout, cerr, cin ed endl?

Non mi piace using namespace std , ma sono anche stanco di dover digitare std:: davanti a ogni cout , cin , cerr e cerr . Quindi, ho pensato di dare loro nomi nuovi più corti come questo:

 // STLWrapper.h #include  #include  extern std::ostream& Cout; extern std::ostream& Cerr; extern std::istream& Cin; extern std::string& Endl; // STLWrapper.cpp #include "STLWrapper.h" std::ostream& Cout = std::cout; std::ostream& Cerr = std::cerr; std::istream& Cerr = std::cin; std::string _EndlStr("\n"); std::string& Endl = _EndlStr; 

Questo funziona. Ma, ci sono problemi in quanto sopra che mi manca? C’è un modo migliore per ottenere lo stesso?

Perchè no

 using std::cin; using std::cout; 

e così via? Quindi nel tuo codice puoi usare cin , cout e così via, senza iniettare accidentalmente tutto il resto dello spazio dei nomi std nel tuo codice.

Alex ti ha dato una risposta su come risolvere sintatticamente quel problema. Tuttavia, voglio sottolineare altri due argomenti riguardanti questo problema:

  1. Indipendentemente dal fatto che si stia utilizzando una direttiva using ( using namespace std ) o la sua sorella ctriggers minore, una dichiarazione using std::cout ( using std::cout ), l’overloading potrebbe portare a brutte sorprese. Non è molto complicato digitare std:: rispetto a passare una notte di debug per trovare il tuo codice chiamato std::distance() invece della tua funzione distance() , solo perché hai fatto un piccolo errore e std::distance() accidentalmente è una corrispondenza migliore.

  2. Una riga di codice viene scritta una volta , ma – a seconda della sua durata – viene letta decine, centinaia e persino migliaia di volte . Quindi il tempo necessario per scrivere una riga di codice semplicemente non ha importanza , importante è solo il tempo necessario per leggere e interpretare una riga di codice . Anche se impiega tre volte il tempo per scrivere una riga con tutto lo std:: corretto std:: se lo fa leggere solo il 10% più velocemente, ne vale comunque la pena.
    Quindi la domanda importante è: è più facile leggere e interpretare una riga di codice con tutti gli std:: in posizione o è più difficile ? Da un’altra risposta :

    Ecco un altro punto dati: molti, molti anni fa, ho anche trovato fastidioso dover prefissare tutto dalla libreria standard con std:: . Poi ho lavorato a un progetto in cui è stato deciso all’inizio che sia l’ using direttive e delle dichiarazioni sia vietato, tranne per gli ambiti delle funzioni. Indovina un po? La maggior parte di noi impiegava poche settimane per abituarsi a scrivere il prefisso e dopo alcune settimane la maggior parte di noi ha persino accettato di rendere il codice più leggibile . (C’è una ragione per questo: se ti piace la prosa più corta o più lunga è soggettiva, ma i prefissi oggettivamente aggiungono chiarezza al codice. Non solo il compilatore, ma anche tu trovi più facile vedere a quale identificatore si fa riferimento.)

    In un decennio, quel progetto è cresciuto fino ad avere diverse milioni di linee di codice. Dal momento che queste discussioni si ripetono, una volta ero curioso di sapere quanto spesso il (ammesso) using dell’ambito della funzione fosse effettivamente utilizzato nel progetto. Ho capito le fonti e ho trovato solo una o due decine di posti dove è stato usato. Per me questo indica che, una volta provato, gli sviluppatori non hanno trovato std:: abbastanza doloroso da impiegare le direttive anche una volta ogni 100kLoC, anche dove è stato permesso di essere utilizzato .

    Penso che sia triste che ogni libro e tutorial trovi skip std:: , perché questo rende le persone abituate a leggere il codice in questo modo. Quando ho insegnato C ++ per diversi anni (dopo la suddetta esperienza), ho detto ai miei studenti che non voglio vedere alcun using direttive o dichiarazioni nel loro codice. (L’unica eccezione a questa regola è l’ using std::swap , BTW, che ti servirà per fare in modo che swap(a,b) prelevi sovraccarichi al di fuori dello spazio dei nomi std .) Una volta che ci si abituarono, non lo fecero t mente e, quando gli è stato chiesto, hanno detto di trovare il codice senza il prefisso std:: confuso. Alcuni addirittura hanno aggiunto il prefisso std:: al codice che hanno digitato da un libro o un tutorial che non ce l’ha .

In conclusione: cosa c’è di così difficile nel digitare std:: che tutti si eccitano? Ormai lo faccio da più di 15 anni e non mi manca affatto di using .