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

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

// newusertype.cc
namespace {
  const int SIZE_OF_ARRAY_X;
  const int SIZE_OF_ARRAY_Y;
  bool getState(userType*,otherUserType*);
}

newusertype::newusertype(...) {...

อะไรคือข้อควรพิจารณาในการออกแบบที่อาจทำให้เกิดการใช้เนมสเปซที่ไม่มีชื่อ ข้อดีและข้อเสียคืออะไร?

เนมสเปซที่ไม่มีชื่อเป็นยูทิลิตี้ในการทำให้หน่วยการแปลตัวระบุอยู่ในเครื่อง มันจะทำงานเหมือนกับว่าคุณจะเลือกชื่อที่ไม่ซ้ำกันต่อหน่วยการแปลสำหรับเนมสเปซ:

namespace unique { /* empty */ }
using namespace unique;
namespace unique { /* namespace body. stuff in here */ }

ขั้นตอนพิเศษที่ใช้เนื้อความว่างเปล่าเป็นสิ่งสำคัญดังนั้นคุณสามารถอ้างอิงภายในเนมสเปซไปยังตัวระบุเช่นเดียวกับ::nameที่กำหนดไว้ในเนมสเปซนั้นเนื่องจากการใช้คำสั่งเกิดขึ้นแล้ว

ซึ่งหมายความว่าคุณสามารถมีฟังก์ชั่นฟรีที่เรียกว่า (ตัวอย่าง) helpซึ่งมีอยู่ในหน่วยการแปลหลาย ๆ หน่วยและจะไม่ขัดแย้งกันในเวลาลิงก์ ผลกระทบเกือบจะเหมือนกับการใช้staticคำหลักที่ใช้ใน C ซึ่งคุณสามารถใส่ในการประกาศตัวระบุ เนมสเปซที่ไม่มีชื่อนั้นเป็นทางเลือกที่เหนือกว่าทำให้สามารถแปลหน่วยการพิมพ์ในท้องถิ่นได้

namespace { int a1; }
static int a2;

ทั้งสองaเป็นหน่วยแปลในท้องถิ่นและจะไม่ปะทะกันในเวลาลิงก์ แต่ความแตกต่างคือa1ในเนมสเปซที่ไม่ระบุชื่อจะได้รับชื่อที่ไม่ซ้ำกัน

อ่านบทความที่ยอดเยี่ยมที่ comeau-computing ทำไมเนมสเปซที่ไม่มีชื่อใช้แทนสแตติก ( กระจก Archive.org )

การมีบางสิ่งบางอย่างในเนมสเปซที่ไม่ระบุชื่อหมายความว่ามันอยู่ในหน่วยการแปลนี้(ไฟล์. cpp และรวมอยู่ด้วย) ซึ่งหมายความว่าหากมีการกำหนดสัญลักษณ์อื่นที่มีชื่อเดียวกันในที่อื่นจะไม่เป็นการฝ่าฝืนOne Definition Rule (ODR)

นี่เป็นวิธีเดียวกับ C ในการมีตัวแปรโกลบอลสแตติกหรือฟังก์ชันสแตติก แต่สามารถใช้สำหรับการกำหนดคลาสได้เช่นกัน (และควรใช้มากกว่าstaticใน C ++)

เนมสเปซที่ไม่ระบุชื่อทั้งหมดในไฟล์เดียวกันถือว่าเป็นเนมสเปซเดียวกันและเนมสเปซที่ไม่ระบุชื่อทั้งหมดในไฟล์ต่างกันจะแตกต่างกัน เนมสเปซที่ไม่ระบุชื่อนั้นเทียบเท่ากับ:

namespace __unique_compiler_generated_identifer0x42 {
    ...
}
using namespace __unique_compiler_generated_identifer0x42;

namespace ที่ไม่ได้ตั้งชื่อจะ จำกัด การเข้าถึงคลาสตัวแปรฟังก์ชั่นและวัตถุไปยังไฟล์ที่มีการกำหนดไว้ ฟังก์ชันเนมสเปซที่ไม่มีชื่อคล้ายกับstaticคำสำคัญใน C / C ++
staticคำหลัก จำกัด การเข้าถึงตัวแปรทั่วโลกและฟังก์ชั่นไฟล์ที่พวกเขาจะถูกกำหนด
มีความแตกต่างระหว่างเนมสเปซที่ไม่มีชื่อกับstaticคีย์เวิร์ดเนื่องจากเนมสเปซที่ไม่มีชื่อนั้นมีข้อได้เปรียบเหนือสแตติก staticคำหลักสามารถใช้กับตัวแปรฟังก์ชั่นและวัตถุ แต่ไม่สามารถใช้ได้กับคลาสที่ผู้ใช้กำหนด
ตัวอย่างเช่น:

static int x;  // Correct 

แต่,

static class xyz {/*Body of class*/} //Wrong
static structure {/*Body of structure*/} //Wrong

แต่สามารถทำได้ด้วยเนมสเปซที่ไม่มีชื่อ ตัวอย่างเช่น,

 namespace {
           class xyz {/*Body of class*/}
           static structure {/*Body of structure*/}
  } //Correct

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

ตัวอย่างเช่นในระบบของฉันรหัสต่อไปนี้ใช้เวลาประมาณ 70% ของเวลาทำงานหากใช้เนมสเปซนิรนาม (x86-64 gcc-4.6.3 และ -O2) โปรดทราบว่ารหัสพิเศษใน add_val ทำให้คอมไพเลอร์ไม่ต้องการรวม มันสองครั้ง)

#include <iostream>

namespace {
  double a;
  void b(double x)
  {
    a -= x;
  }
  void add_val(double x)
  {
    a += x;
    if(x==0.01) b(0);
    if(x==0.02) b(0.6);
    if(x==0.03) b(-0.1);
    if(x==0.04) b(0.4);
  }
}

int main()
{
  a = 0;
  for(int i=0; i<1000000000; ++i)
    {
      add_val(i*1e-10);
    }
  std::cout << a << '\n';
  return 0;
}

ตัวอย่างแสดงว่าคนในโครงการที่คุณเข้าร่วมไม่เข้าใจเนมสเปซที่ไม่ระบุชื่อ :)

namespace {
    const int SIZE_OF_ARRAY_X;
    const int SIZE_OF_ARRAY_Y;

สิ่งเหล่านี้ไม่จำเป็นต้องอยู่ในเนมสเปซที่ไม่ระบุชื่อเนื่องจากconstวัตถุมีการเชื่อมโยงแบบคงที่อยู่แล้วดังนั้นจึงไม่สามารถขัดแย้งกับตัวระบุชื่อเดียวกันในหน่วยการแปลอื่นได้

    bool getState(userType*,otherUserType*);
}

และนี่คือการมองโลกในแง่ร้าย: getState()มีการเชื่อมโยงจากภายนอก โดยปกติแล้วจะเป็นการดีกว่าที่จะชอบการเชื่อมโยงแบบคงที่เนื่องจากจะไม่ทำให้ตารางสัญลักษณ์เป็นมลพิษ มันจะดีกว่าที่จะเขียน

static bool getState(/*...*/);

ที่นี่ ฉันตกหลุมพรางเดียวกัน (มีถ้อยคำตามมาตรฐานที่แนะนำว่าไฟล์ - สแตติกถูกคัดค้านอย่างไม่ระบุชื่อ) แต่การทำงานในโครงการ C ++ ขนาดใหญ่เช่น KDE คุณจะได้รับผู้คนจำนวนมากที่หันหัวของคุณอย่างถูกวิธี อีกรอบ :)

เนมสเปซที่ไม่ระบุชื่อทำให้ตัวแปร, ฟังก์ชั่น, คลาส, ฯลฯ มีอยู่ในไฟล์นั้นเท่านั้น ในตัวอย่างของคุณเป็นวิธีหลีกเลี่ยงตัวแปรทั่วโลก ไม่มีความแตกต่างของประสิทธิภาพเวลารันไทม์หรือการคอมไพล์

มีข้อดีหรือข้อเสียไม่มากไปกว่า "ฉันต้องการให้ตัวแปรฟังก์ชันคลาส ฯลฯ เป็นแบบสาธารณะหรือส่วนตัว"