อาจจะซ้ำกัน แต่ไม่ใช่เรื่องง่ายที่จะค้นหา ...

ให้ส่วนหัวเช่น:

namespace ns1
{
 class MyClass
 {
  void method();
 };
}

ฉันเห็นว่ามีการmethod()กำหนดไว้หลายวิธีในไฟล์. cpp:

เวอร์ชัน 1:

namespace ns1
{
 void MyClass::method()
 {
  ...
 }
}

เวอร์ชัน 2:

using namespace ns1;

void MyClass::method()
{
 ...
}

เวอร์ชัน 3:

void ns1::MyClass::method()
{
 ...
}

มีวิธีที่ 'ถูกต้อง' หรือไม่? สิ่งเหล่านี้ 'ผิด' หรือไม่ที่ไม่ได้หมายถึงสิ่งเดียวกันทั้งหมด?

เวอร์ชัน 2 ไม่ชัดเจนและเข้าใจได้ไม่ยากเพราะคุณไม่รู้ว่าMyClassเป็นของเนมสเปซใดและมันก็ไม่สมเหตุสมผล (ฟังก์ชันคลาสไม่ได้อยู่ในเนมสเปซเดียวกัน?)

เวอร์ชัน 1 ถูกต้องเพราะแสดงว่าในเนมสเปซคุณกำลังกำหนดฟังก์ชัน

3 รุ่นที่ถูกต้องยังเป็นเพราะคุณใช้::ประกอบการที่มีรายละเอียดขอบเขตในการอ้างถึงMyClass::method ()ในการ ns1namespace ฉันชอบเวอร์ชัน 3 มากกว่า

ดูNamespaces (C ++) นี่เป็นวิธีที่ดีที่สุดในการทำเช่นนี้

5 ปีต่อมาและฉันคิดว่าฉันจะพูดถึงเรื่องนี้ซึ่งทั้งสองก็ดูดีและไม่ได้ชั่วร้าย

using ns1::MyClass;

void MyClass::method()
{
  // ...
}

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

เวอร์ชัน 4: ใช้คุณสมบัติแบบเต็มโดยใช้ชื่อแทนเนมสเปซ:

#include "my-header.hpp"
namespace OI = outer::inner;
void OI::Obj::method() {
    ...
}

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

เวอร์ชัน 3 ทำให้การเชื่อมโยงระหว่างคลาสและเนมสเปซมีความชัดเจนมากโดยเสียค่าใช้จ่ายในการพิมพ์มากขึ้น เวอร์ชัน 1 หลีกเลี่ยงสิ่งนี้ แต่จับการเชื่อมโยงกับบล็อก เวอร์ชัน 2 มีแนวโน้มที่จะซ่อนสิ่งนี้ดังนั้นฉันจึงหลีกเลี่ยงสิ่งนั้น

Googles C ++ Style Guide จะกำหนดเวอร์ชัน 1 ของคุณโดยไม่ต้องเยื้อง

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

Num.1 สิ่งนี้อาจล้มเหลวด้วยขอบเขตอื่นที่ไม่ใช่คลาส - อะไรก็ตามที่สามารถเปิดใหม่ได้ ดังนั้นคุณอาจประกาศฟังก์ชันใหม่ในเนมสเปซโดยใช้วิธีนี้หรืออินไลน์ของคุณอาจถูกแทนที่ด้วย ODR คุณจะต้องใช้สิ่งนี้สำหรับคำจำกัดความบางอย่าง (โดยเฉพาะอย่างยิ่งความเชี่ยวชาญของเทมเพลต)

Num.2 สิ่งนี้เปราะบางมากโดยเฉพาะในโค้ดเบสขนาดใหญ่เนื่องจากส่วนหัวและการอ้างอิงเปลี่ยนไปโปรแกรมของคุณจะไม่สามารถคอมไพล์ได้

Num.3 นี้เหมาะ แต่มากพิมพ์ - สิ่งที่เจตนาของคุณคือการกำหนดสิ่งที่ สิ่งนี้ทำอย่างนั้นและคอมไพเลอร์เริ่มต้นเพื่อให้แน่ใจว่าคุณไม่ได้ทำผิดคำจำกัดความไม่ได้ซิงค์กับการประกาศ ฯลฯ

ปรากฎว่าไม่ใช่แค่ "รูปแบบการเข้ารหัส" เท่านั้น Num. 2 นำไปสู่ข้อผิดพลาดในการเชื่อมโยงเมื่อกำหนดและเริ่มต้นตัวแปรที่ประกาศ extern ในไฟล์ส่วนหัว ดูตัวอย่างในคำถามของฉัน คำจำกัดความของค่าคงที่ภายในเนมสเปซในไฟล์ cpp

ทุกวิธีที่ถูกต้องและแต่ละวิธีมีข้อดีและข้อเสีย

ในเวอร์ชัน 1 คุณมีข้อได้เปรียบที่ไม่ต้องเขียนเนมสเปซหน้าแต่ละฟังก์ชัน ข้อเสียคือคุณจะได้รับการระบุตัวตนที่น่าเบื่อโดยเฉพาะอย่างยิ่งหากคุณมีเนมสเปซมากกว่าหนึ่งระดับ

ในเวอร์ชัน 2 คุณทำให้โค้ดของคุณสะอาดขึ้น แต่ถ้าคุณมีมากกว่าหนึ่งเนมสเปซที่ใช้งานใน CPP หนึ่งอาจเข้าถึงฟังก์ชันและตัวแปรของอีกตัวหนึ่งโดยตรงทำให้เนมสเปซของคุณไร้ประโยชน์ (สำหรับไฟล์ cpp นั้น)

ในเวอร์ชัน 3 คุณจะต้องพิมพ์มากขึ้นและสายฟังก์ชันของคุณอาจใหญ่กว่าหน้าจอซึ่งไม่ดีต่อเอฟเฟกต์การออกแบบ

นอกจากนี้ยังมีอีกวิธีหนึ่งที่บางคนใช้ คล้ายกับเวอร์ชันแรก แต่ไม่มีปัญหาในการระบุตัวตน

มันเป็นเช่นนี้:

#define OPEN_NS1 namespace ns1 { 
#define CLOSE_NS1 }

OPEN_NS1

void MyClass::method()
{
...
}

CLOSE_NS1

ขึ้นอยู่กับคุณว่าจะเลือกอันไหนดีกว่าสำหรับแต่ละสถานการณ์ =]