Corrispondenza spazio dei nomi

Question

Sto cercando di mettere in discussione la correttezza del mio codice sul seguente esempio minimalista in cui un file di intestazione solleva un identificatore nello spazio dei nomi corrente.

#include <string> 

namespace mine { 

    using std::string; // std::string lifted into mine 

    struct agent 
    { 
     string name; 
    }; 
} 

Questo è un suggerimento che ho fatto di recente come un'altra alternativa all'utilizzo di un typedef:

#include <string> 

struct agent 
{ 
    private: 
     typedef std::string string; 
    public: 
     string name; 
}; 

ho considerato la prima opzione più corretta dal momento che fa uso del mio proprio spazio dei nomi e questo è un pratica a cui ci si dovrebbe abituare (quella della creazione e gestione dello spazio dei nomi). Nel frattempo, dato che l'identificatore viene sollevato all'interno di uno spazio dei nomi che controllo, rende questo un approccio sicuro.

Tuttavia, ho dei ripensamenti. Per uno, l'uso incauto del namespace mine, con una direttiva using, ad esempio, porterà anche std :: string in vista. Un altro problema è che sto esponendo troppo std :: string. Forse anche per le aree del namespace mine dove non è necessario o desiderabile.

Mi sembra più corretto lavorare sempre con lo scopo più basso possibile e lavorare da lì. Esporre solo l'assolutamente necessario. Il fatto che io abbia reso privato typedef nel secondo esempio era esattamente per questo. Ma poi non seguo il mio consiglio con il secondo esempio.

Ma d'altra parte, le mie preoccupazioni risultato dal fatto che qualcuno possa abusare del namespace miniera di:

using namespace mine; 

A prima vista, sappiamo che questo non è un modello di utilizzo corretto per uno spazio dei nomi. Ma non si può negare che ci siano casi in cui potrebbe essere desiderabile. Quanto ritieni valido il primo approccio?

Answer 1

avrei pensato che la soluzione più ovvia è:

namespace mine { 
    struct agent 
    { 
     std::string name; 
    }; 
} 

Io personalmente non usano utilizzando le direttive nei file header a tutti. Nei file di implementazione, certamente.

Answer 2

faccio di solito questo:

// In header file: 

#include <string> 

namespace mine { 

    struct agent 
    { 
     std::string name; 
    }; 
} 

// In source file: 

using std::string; 

namespace mine { 
    // Code 
}  

In questo modo non c'è bisogno di scrivere std :: più e più volte nella realizzazione, ma si evita il problema delle persone che usano le intestazioni inavvertitamente importazione std :: simboli.

Answer 3

solito faccio questo:

// In header file 
#include <string> 
namespace mine 
{ 
    namespace detail 
    { 
     using std::string; 

     struct agent 
     { 
      string name; 
     } 
    } 

    using detail::agent; 
} 

In questo modo non devo tenere a digitare std:: nell'intestazione sia, ma qualcuno può ancora fare using namespace mine; e non importare i nomi da std.