เนมสเปซที่ไม่มีชื่อ / ไม่ระบุชื่อเปรียบเทียบกับฟังก์ชั่นแบบคงที่

คุณลักษณะของ C ++ คือความสามารถในการสร้างเนมสเปซที่ไม่มีชื่อ (ไม่ระบุชื่อ) เช่น:

namespace {
    int cannotAccessOutsideThisFile() { ... }
} // namespace

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

คำถามของฉันคือทำไมหรือเมื่อไรที่สิ่งนี้ดีกว่าที่จะใช้ฟังก์ชั่นแบบคงที่? หรือว่าพวกเขากำลังทำสิ่งเดียวกันแน่นอนสองวิธี?

C ++ Standard อ่านในส่วน 7.3.1.1 เนมสเปซที่ไม่มีชื่อวรรค 2:

การใช้คำสำคัญคงที่จะเลิกใช้เมื่อประกาศวัตถุในขอบเขต namespace, unnamed-namespace ให้ทางเลือกที่เหนือกว่า

สแตติกใช้กับชื่อของวัตถุฟังก์ชันและสหภาพที่ไม่ระบุชื่อเท่านั้นไม่พิมพ์ประกาศ

แก้ไข:

การตัดสินใจยกเลิกการใช้คำหลักแบบคงที่นี้ (ส่งผลต่อการมองเห็นการประกาศตัวแปรในหน่วยการแปล) ได้รับการย้อนกลับ ( ref ) ในกรณีนี้การใช้สแตติกหรือเนมสเปซที่ไม่มีชื่อจะกลับมาเป็นหลักสองวิธีในการทำสิ่งเดียวกัน สำหรับการอภิปรายเพิ่มเติมโปรดดูนี้คำถาม SO

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

เครดิตไปที่Mike Percyซึ่งทำให้เรื่องนี้เป็นที่สนใจของฉัน

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

และตามที่ลุคระบุไว้เนมสเปซที่ไม่ระบุชื่อเป็นที่ต้องการโดยมาตรฐานเหนือสมาชิกแบบคงที่

มีกรณีขอบหนึ่งที่คงที่มีผลที่น่าแปลกใจ (อย่างน้อยก็สำหรับฉัน) สถานะ C ++ 03 มาตรฐานใน 14.6.4.2/1:

สำหรับการเรียกใช้ฟังก์ชันที่ขึ้นอยู่กับพารามิเตอร์เทมเพลตหากชื่อฟังก์ชั่นเป็นunqualified-idแต่ไม่ใช่เท็มเพลตไอดีฟังก์ชั่นผู้สมัครจะพบโดยใช้กฎการค้นหาปกติ (3.4.1, 3.4.2) ยกเว้นว่า:

• สำหรับส่วนของการค้นหาโดยใช้การค้นหาชื่ออย่างไม่มีเงื่อนไข (3.4.1) จะพบเฉพาะการประกาศฟังก์ชันที่มีการเชื่อมโยงภายนอกจากบริบทนิยามเทมเพลตเท่านั้น
• สำหรับส่วนของการค้นหาโดยใช้เนมสเปซที่เชื่อมโยง (3.4.2) จะมีเพียงการประกาศฟังก์ชันที่มีการเชื่อมโยงภายนอกที่พบในบริบทข้อกำหนดเทมเพลตหรือบริบทการสร้างอินสแตนซ์เทมเพลต

...

รหัสด้านล่างจะโทรfoo(void*)และไม่ได้foo(S const &)ตามที่คุณคาดหวัง

template <typename T>
int b1 (T const & t)
{
  foo(t);
}

namespace NS
{
  namespace
  {
    struct S
    {
    public:
      operator void * () const;
    };

    void foo (void*);
    static void foo (S const &);   // Not considered 14.6.4.2(b1)
  }

}

void b2()
{
  NS::S s;
  b1 (s);
}

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

// bar.h
export template <typename T>
int b1 (T const & t);

// bar.cc
#include "bar.h"
template <typename T>
int b1 (T const & t)
{
  foo(t);
}

// foo.cc
#include "bar.h"
namespace NS
{
  namespace
  {
    struct S
    {
    };

    void foo (S const & s);  // Will be found by different TU 'bar.cc'
  }
}

void b2()
{
  NS::S s;
  b1 (s);
}

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

อัพเดทสำหรับ Modern C ++

ตั้งแต่ C ++ '11 สมาชิกของเนมสเปซที่ไม่มีชื่อมีการเชื่อมโยงภายในโดยนัย (3.5 / 4):

เนมสเปซที่ไม่มีชื่อหรือเนมสเปซที่ประกาศโดยตรงหรือโดยอ้อมภายในเนมสเปซที่ไม่มีชื่อมีการเชื่อมโยงภายใน

แต่ในเวลาเดียวกัน 14.6.4.2/1 ได้รับการปรับปรุงเพื่อลบการกล่าวถึงการเชื่อมโยง (สิ่งนี้นำมาจาก C ++ '14):

สำหรับการเรียกใช้ฟังก์ชั่นที่ postfix-expression เป็นชื่อที่ต้องพึ่งพาฟังก์ชันของตัวเลือกจะถูกพบโดยใช้กฎการค้นหาปกติ (3.4.1, 3.4.2) ยกเว้นว่า:

• สำหรับส่วนของการค้นหาโดยใช้การค้นหาชื่ออย่างไม่มีเงื่อนไข (3.4.1) จะพบเฉพาะการประกาศฟังก์ชันจากบริบทการกำหนดเทมเพลต

• สำหรับส่วนของการค้นหาโดยใช้เนมสเปซที่เชื่อมโยง (3.4.2) จะพบเฉพาะการประกาศฟังก์ชันที่พบในบริบทการกำหนดเทมเพลตหรือบริบทการสร้างอินสแตนซ์เทมเพลต

ผลลัพธ์คือความแตกต่างนี้ระหว่างสมาชิกเนมสเปซคงที่และไม่มีชื่อ

ฉันเพิ่งเริ่มแทนที่คำหลักคงที่ด้วย namespaces ที่ไม่ระบุชื่อในรหัสของฉัน แต่ทันทีพบปัญหาที่ตัวแปรใน namespace ไม่สามารถใช้ได้อีกต่อไปสำหรับการตรวจสอบในการดีบักเกอร์ของฉัน ฉันใช้ VC60 ดังนั้นฉันไม่รู้ว่านั่นเป็นปัญหากับตัวแก้จุดบกพร่องอื่นหรือไม่ วิธีแก้ปัญหาของฉันคือกำหนด namespace 'โมดูล' ที่ฉันให้ชื่อของไฟล์ cpp ของฉัน

ตัวอย่างเช่นในไฟล์ XmlUtil.cpp ของฉันฉันจะกำหนดเนมสเปซXmlUtil_I { ... }สำหรับตัวแปรและฟังก์ชั่นโมดูลทั้งหมดของฉัน ด้วยวิธีนี้ฉันสามารถใช้การXmlUtil_I::รับรองในโปรแกรมดีบั๊กเพื่อเข้าถึงตัวแปร ในกรณีนี้_Iความแตกต่างจาก namespace สาธารณะเช่นXmlUtilที่ฉันอาจต้องการใช้ที่อื่น

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

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

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

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

นอกจากนี้หากมีการใช้คำหลักคงที่ในตัวแปรเช่นตัวอย่างนี้:

namespace {
   static int flag;
}

มันจะไม่เห็นในไฟล์การทำแผนที่

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

#include <iostream>

namespace
{
    void unreferenced()
    {
        std::cout << "Unreferenced";
    }

    void referenced()
    {
        std::cout << "Referenced";
    }
}

static void static_unreferenced()
{
    std::cout << "Unreferenced";
}

static void static_referenced()
{
    std::cout << "Referenced";
}

int main()
{
    referenced();
    static_referenced();
    return 0;
}

รวบรวมรหัสนี้กับ VS 2017 (ระบุธงเตือนระดับ 4 / W4 เพื่อเปิดใช้งานการเตือน C4505: ฟังก์ชั่นภายในที่ไม่ได้อ้างอิงถูกลบ ) และ gcc 4.9 ด้วย -Wunused-function หรือ -Wall flag แสดงว่า VS 2017 จะสร้างคำเตือนสำหรับเท่านั้น ฟังก์ชั่นคงที่ไม่ได้ใช้ gcc 4.9 ขึ้นไปเช่นเดียวกับเสียงดังกราว 3.3 และสูงกว่าจะสร้างคำเตือนสำหรับฟังก์ชันที่ไม่ได้รับการอ้างอิงในเนมสเปซและยังเป็นคำเตือนสำหรับฟังก์ชันคงที่ที่ไม่ได้ใช้

การสาธิตสดของ gcc 4.9 และ MSVC 2017

ส่วนตัวแล้วฉันชอบฟังก์ชั่นคงที่มากกว่าเนมสเปซที่ไม่มีชื่อด้วยเหตุผลต่อไปนี้:

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

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

• ฟังก์ชั่นแบบคงที่มีพฤติกรรมคล้ายกันมากใน C หรือ C ++ ในขณะที่ namespaces ที่ไม่ระบุชื่อเป็น C ++ เท่านั้น เนมสเปซนิรนามยังเพิ่มระดับพิเศษในการเยื้องและฉันไม่ชอบ :)

ดังนั้นผมมีความสุขที่จะเห็นการใช้งานคงที่สำหรับฟังก์ชั่นที่ไม่ได้เลิกใช้อีกต่อไป

เมื่อได้เรียนรู้คุณลักษณะนี้เพียงแค่ตอนนี้ในขณะที่อ่านคำถามของคุณฉันสามารถคาดเดาได้เท่านั้น ดูเหมือนว่าจะมีข้อดีหลายประการสำหรับตัวแปรแบบคงที่ระดับไฟล์:

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

ฉันสนใจที่จะเรียนรู้ถ้ามีใครใช้เนมสเปซนิรนามในรหัสจริง

ความแตกต่างคือชื่อของตัวระบุที่ mangled ( _ZN12_GLOBAL__N_11bEvs _ZL1bซึ่งไม่สำคัญจริงๆ แต่ทั้งคู่ถูกรวมเข้ากับสัญลักษณ์ท้องถิ่นในตารางสัญลักษณ์ (ไม่มี.globalคำสั่ง asm)

#include<iostream>
namespace {
   int a = 3;
}

static int b = 4;
int c = 5;

int main (){
    std::cout << a << b << c;
}

        .data
        .align 4
        .type   _ZN12_GLOBAL__N_11aE, @object
        .size   _ZN12_GLOBAL__N_11aE, 4
_ZN12_GLOBAL__N_11aE:
        .long   3
        .align 4
        .type   _ZL1b, @object
        .size   _ZL1b, 4
_ZL1b:
        .long   4
        .globl  c
        .align 4
        .type   c, @object
        .size   c, 4
c:
        .long   5
        .text

สำหรับเนมสเปซที่ไม่ระบุชื่อแบบซ้อน:

namespace {
   namespace {
       int a = 3;
    }
}

        .data
        .align 4
        .type   _ZN12_GLOBAL__N_112_GLOBAL__N_11aE, @object
        .size   _ZN12_GLOBAL__N_112_GLOBAL__N_11aE, 4
_ZN12_GLOBAL__N_112_GLOBAL__N_11aE:
        .long   3
        .align 4
        .type   _ZL1b, @object
        .size   _ZL1b, 4

เนมสเปซที่ไม่ระบุชื่อระดับที่ 1 ทั้งหมดในหน่วยการแปลจะถูกรวมเข้าด้วยกัน, เนมสเปซที่ไม่ระบุตัวตนระดับที่ 2 ทั้งหมดในหน่วยการแปลจะรวมกัน

คุณสามารถมีเนมสเปซซ้อน (แบบอินไลน์) ในเนมสเปซที่ไม่ระบุชื่อ

namespace {
   namespace A {
       int a = 3;
    }
}

        .data
        .align 4
        .type   _ZN12_GLOBAL__N_11A1aE, @object
        .size   _ZN12_GLOBAL__N_11A1aE, 4
_ZN12_GLOBAL__N_11A1aE:
        .long   3
        .align 4
        .type   _ZL1b, @object
        .size   _ZL1b, 4

which for the record demangles as:
        .data
        .align 4
        .type   (anonymous namespace)::A::a, @object
        .size   (anonymous namespace)::A::a, 4
(anonymous namespace)::A::a:
        .long   3
        .align 4
        .type   b, @object
        .size   b, 4

คุณสามารถมีเนมสเปซอินไลน์แบบไม่ระบุชื่อ แต่เท่าที่ฉันสามารถบอกได้inlineในเนมสเปซที่ไม่ระบุตัวตนมีผล 0

inline namespace {
   inline namespace {
       int a = 3;
    }
}

_ZL1b: _Zหมายความว่านี่เป็นตัวระบุที่ถูกบันทึกไว้ หมายความว่ามันเป็นสัญลักษณ์ท้องถิ่นผ่านL คือความยาวของตัวระบุและตัวระบุstatic1bb

_ZN12_GLOBAL__N_11aE _Zหมายความว่านี่เป็นตัวบ่งชี้ที่ยุ่งเหยิง Nหมายถึงนี้เป็น namespace 12คือความยาวของชื่อ namespace ที่ไม่ระบุชื่อ_GLOBAL__N_1แล้วชื่อ namespace ที่ไม่ระบุชื่อ_GLOBAL__N_1แล้ว1คือความยาวของตัวระบุที่a, aเป็นตัวบ่งชี้aและEปิดตัวระบุที่อยู่ในใน namespace

_ZN12_GLOBAL__N_11A1aE เหมือนกับด้านบนยกเว้นมีเนมสเปซอีกระดับหนึ่งอยู่ 1A