Gunakan `menggunakan` dalam C ++ atau menghindarinya?

Diskon semantik yang berbeda karena ADL, bagaimana seharusnya saya gunakan secara umum using, dan mengapa? Apakah ini tergantung situasi (mis. Tajuk yang akan menjadi #included vs file sumber yang tidak akan)?

Juga, haruskah saya lebih suka ::std::atau std::?

1. Namespace-level using namespace:

   using namespace std;
   
   pair<string::const_iterator, string::const_iterator>
   f(const string &s) {
       return make_pair(s.begin(), s.end());
   }

2. Menjadi sepenuhnya eksplisit:

   std::pair<std::string::const_iterator, std::string::const_iterator>
   f(const std::string &s) {
       return std::make_pair(s.begin(), s.end());
   }

3. Namespace-level using-declarations:

   using std::pair;
   using std::string;
   
   pair<string::const_iterator, string::const_iterator>
   f(const string &s) {
       return make_pair(s.begin(), s.end());
   }

4. Function-local using-declarations:

   std::pair<std::string::const_iterator, std::string::const_iterator>
   f(const std::string &s) {
       using std::make_pair;
       return make_pair(s.begin(), s.end());
   }

5. Fungsi-lokal using namespace:

   std::pair<std::string::const_iterator, std::string::const_iterator>
   f(const std::string &s) {
       using namespace std;
       return make_pair(s.begin(), s.end());
   }

6. Sesuatu yang lain

_{Ini mengasumsikan pra-C ++ 14, dan dengan demikian tidak ada tipe pengembalian yang digunakan auto.}

Hindari penggunaan usingdi header, karena itu merusak tujuan ruang nama.

Tidak apa-apa untuk menggunakannya dalam file sumber, tapi saya masih akan menghindarinya dalam beberapa kasus (misalnya using std).

Namun jika Anda mendapatkan ruang nama bersarang, tidak apa-apa:

namespace A {
namespace B {
namespace C {
class s;
} // C
} // B
namespace D{
using B::C::s;
} // D
} // A

Saat meletakkan pernyataan menggunakan dalam file sumber, TOLONG, cukup tarik hal-hal yang Anda butuhkan. Contohnya:

using std::string;
using std::ostringstream;

Masalahnya di sini adalah jika Anda melakukannya

using namespace std;

Anda menarik SETIAP HAL SINGLE dari std ke namespace global. Yang mengarah ke pesan kesalahan yang sangat menarik ketika Anda secara tidak sengaja menggunakan nama dalam kode Anda yang cocok dengan yang Anda sama sekali tidak sadari di std. Jika Anda hanya menarik hal-hal yang Anda inginkan, maka Anda tidak akan memiliki masalah itu (atau, lebih tepatnya, programmer berikutnya untuk mengerjakan kode Anda tidak akan memiliki masalah itu).

Seperti yang ditunjukkan VJovic, jangan gunakan using dalam file header. usingdalam file header mempengaruhi unit kompilasi saat ini (file .cpp) dengan cara yang mungkin tidak diharapkan oleh file sumber.

using namespacejuga harus dihindari dalam file sumber. Ini membawa setiap simbol ke dalam cakupan yang sama dengan file sumber. Lebih jelas bagi pembaca Anda apa yang Anda lakukan jika Anda menggunakan simbol spesifik dari namespace.

Menulis usingdi Header adalah cara terbaik untuk membuat semua jenis bug yang tidak menyenangkan dan tidak mungkin untuk debug . Jangan tidak melakukan hal ini.

Menulis using namespace XYZdi file sumber sedikit lebih baik, tetapi masih bisa menyebabkan Anda sakit kepala yang tak terhitung jumlahnya. Cara yang aman adalah menentukan apa yang Anda gunakan misalnya using Foo::Bar.

Katakanlah Anda memiliki Bar.cpp dengan yang berikut:

//Bar.cpp
using namespace Foo;
namespace
{
    double increment(double v) { return (v + 1); }
}

void Bar::someFunction()
{
    //...
    int currentIndex = 0;
    int nextIndex = increment(currentIndex);
    //...
}

Fungsi ini berfungsi dengan baik, sampai suatu hari - tampaknya tanpa perubahan kode di kelas yang relevan - perilakunya berubah: Tiba-tiba currentIndexsepertinya selalu dimatikan satu per satu . Menggali perubahan terbaru Anda tidak menemukan perubahan bahkan terkait dengan kode jarak jauh.

Akhirnya Anda menemukan penyebabnya:
Anda (secara tidak langsung) memasukkan Foo.hsuatu tempat. Dalam file untuk namespace Foo fungsi baru ditambahkan:

//Foo.h
namespace Foo
{
    //...
    int& increment(int& v) { v += 1; return v; };
    //...
}

Yang merupakan kecocokan yang lebih baik increment(int)daripada fungsi Anda increment(double)- jadi sekarang Foo::increment()fungsi dipanggil oleh Bar::someFunction(). Aduh.

(Dan jika Anda adalah untuk menulis usingdi Header yang using namespace Foomungkin sangat baik menjadi di mana saja di pohon termasuk Anda ...)

Jadi ... Jangan menulis apa pun usingdi Header, dan berhati-hatilah dalam menulis using namespacefile sumber.