ใช้ `use` ใน C ++ หรือหลีกเลี่ยง

การลดความหมายที่แตกต่างกันอย่างละเอียดเนื่องจาก ADL ฉันควรใช้โดยทั่วไปusingอย่างไรและเพราะเหตุใด มันขึ้นอยู่กับสถานการณ์ (เช่นส่วนหัวซึ่งจะเป็น#included กับไฟล์ต้นฉบับที่จะไม่)?

นอกจากนี้ฉันควรจะชอบ::std::หรือstd::?

1. ระดับเนมสเปซusing namespace:

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

2. ชัดเจนอย่างสมบูรณ์:

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

3. ระดับเนมสเปซโดยใช้การประกาศ:

   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. ฟังก์ชั่นท้องถิ่นประกาศใช้:

   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. ฟังก์ชั่นท้องถิ่น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. อื่น ๆ อีก?

_{นี่คือการสมมติว่า pre-C ++ 14 และดังนั้นจึงไม่มีการใช้ชนิดการautoคืนสินค้า}

หลีกเลี่ยงการใช้usingในส่วนหัวเพราะนั่นทำลายวัตถุประสงค์ของเนมสเปซ

มันก็โอเคที่จะใช้มันในไฟล์ต้นฉบับ แต่ฉันจะยังคงหลีกเลี่ยงมันในบางกรณี (ตัวอย่างusing std)

อย่างไรก็ตามหากคุณมีเนมสเปซซ้อนกันอยู่ก็ใช้ได้:

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

เมื่อวางคำสั่ง using ในไฟล์ต้นฉบับโปรดดึงสิ่งที่คุณต้องการ ตัวอย่างเช่น

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

ปัญหาที่นี่คือถ้าคุณทำ

using namespace std;

คุณดึงทุกสิ่งจาก std ลงในเนมสเปซส่วนกลาง ซึ่งนำไปสู่ข้อความแสดงข้อผิดพลาดที่น่าสนใจมากเมื่อคุณใช้ชื่อในรหัสที่ตรงกับที่คุณไม่รู้ใน std โดยไม่ตั้งใจ หากคุณเพียงดึงสิ่งที่คุณต้องการคุณจะไม่มีปัญหานั้น (หรือแม่นยำยิ่งขึ้นโปรแกรมเมอร์คนต่อไปที่ทำงานกับโค้ดของคุณจะไม่มีปัญหานั้น)

ตามที่ VJovic บ่งชี้ห้ามใช้usingในไฟล์ส่วนหัว usingในไฟล์ส่วนหัวมีผลต่อหน่วยการคอมไพล์ปัจจุบัน (ไฟล์. cpp) ในรูปแบบที่ไฟล์ต้นฉบับอาจไม่ได้คาดหวัง

using namespaceจะต้องหลีกเลี่ยงในไฟล์ต้นฉบับ สิ่งนี้ทำให้ทุกสัญลักษณ์อยู่ในขอบเขตเดียวกับไฟล์ต้นฉบับ ชัดเจนยิ่งขึ้นกับผู้อ่านของคุณว่าคุณกำลังทำอะไรถ้าคุณใช้สัญลักษณ์เฉพาะจากเนมสเปซ

การเขียนusingส่วนหัวเป็นวิธีที่ดีที่สุดในการสร้างข้อบกพร่องที่น่ารังเกียจและเป็นไปไม่ได้ทุกประเภท อย่าได้ทำเช่นนี้

การเขียนusing namespace XYZในไฟล์ต้นฉบับนั้นดีขึ้นเล็กน้อย แต่ก็ยังทำให้คุณปวดหัวได้นับไม่ถ้วน วิธีที่ปลอดภัยคือการ explicitely using Foo::Barระบุสิ่งที่คุณกำลังใช้เช่น

สมมติว่าคุณมี Bar.cpp ดังต่อไปนี้:

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

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

ฟังก์ชั่นทำงานได้ดีจนกระทั่งวันหนึ่งดูเหมือนว่าจะไม่มีการเปลี่ยนแปลงรหัสในคลาสที่เกี่ยวข้องพฤติกรรมของมันเปลี่ยนไป: ทันใดนั้นcurrentIndexดูเหมือนจะถูกปิดโดยคนๆหนึ่ง การขุดผ่านการเปลี่ยนแปลงล่าสุดคุณไม่พบการเปลี่ยนแปลงใด ๆ แม้แต่เกี่ยวกับรหัสจากระยะไกล

ในที่สุดคุณค้นพบสาเหตุ:
คุณ (ทางอ้อม) รวมFoo.hบางแห่ง ในไฟล์สำหรับเนมสเปซ Foo มีการเพิ่มฟังก์ชั่นใหม่:

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

ซึ่งเป็นการจับคู่ที่ดีincrement(int)กว่าฟังก์ชั่นของคุณincrement(double)- ดังนั้นตอนนี้Foo::increment()ฟังก์ชั่นจะถูกเรียกใช้Bar::someFunction()แทน อ๊ะ

(และถ้าคุณต้องเขียนusingในส่วนหัวที่using namespace Fooอาจจะดีที่ใดก็ได้ในต้นไม้รวมของคุณ ... )

ดังนั้น ... อย่าเขียนusingส่วนหัวและระวังการเขียนลงusing namespaceในไฟล์ต้นฉบับ