[c++] 인라인 네임 스페이스 란 무엇입니까?

인라인 네임 스페이스는 심볼 버전 관리 와 유사한 라이브러리 버전 관리 기능 이지만 특정 바이너리 실행 형식 (예 : 플랫폼 별)의 기능이 아닌 C ++ 11 수준 (예 : 크로스 플랫폼)에서 순수하게 구현됩니다.

라이브러리 작성자는 중첩 된 네임 스페이스를 모든 선언이 주변 네임 스페이스에있는 것처럼 보이게하고 작동 할 수있는 메커니즘입니다 (인라인 네임 스페이스는 중첩 될 수 있으므로 “더 중첩 된”이름은 첫 번째가 아닌 이름까지 퍼집니다) -인라인 네임 스페이스를 사용하고 선언이 그 사이의 네임 스페이스에있는 것처럼 보입니다.

예를 들어의 STL 구현을 고려하십시오 vector. C ++의 시작부터 인라인 네임 스페이스가 있다면 C ++ 98에서 헤더 <vector>는 다음과 같을 것입니다.

namespace std {

#if __cplusplus < 1997L // pre-standard C++
    inline
#endif

    namespace pre_cxx_1997 {
        template <class T> __vector_impl; // implementation class
        template <class T> // e.g. w/o allocator argument
        class vector : __vector_impl<T> { // private inheritance
            // ...
        };
    }
#if __cplusplus >= 1997L // C++98/03 or later
                         // (ifdef'ed out b/c it probably uses new language
                         // features that a pre-C++98 compiler would choke on)
#  if __cplusplus == 1997L // C++98/03
    inline
#  endif

    namespace cxx_1997 {

        // std::vector now has an allocator argument
        template <class T, class Alloc=std::allocator<T> >
        class vector : pre_cxx_1997::__vector_impl<T> { // the old impl is still good
            // ...
        };

        // and vector<bool> is special:
        template <class Alloc=std::allocator<bool> >
        class vector<bool> {
            // ...
        };

    };

#endif // C++98/03 or later

} // namespace std

의 값에 따라 __cplusplus하나 또는 다른 vector구현이 선택됩니다. 코드베이스가 C ++ 98 이전 버전으로 작성되었고 vector컴파일러를 업그레이드 할 때 C ++ 98 버전으로 인해 문제가 발생하는 경우 “모두”는 참조를 찾는 것 std::vector입니다. 코드베이스와로 대체하십시오 std::pre_cxx_1997::vector.

을위한 새로운 공간 도입, 다음 기본으로 제공하고, STL 공급 업체는 절차를 다시 반복 std::vector과 emplace_back(++ 11 C 필요)를 지원하고 하나 IFF를 인라인 __cplusplus == 201103L.

그렇다면 왜 새로운 언어 기능이 필요합니까? 나는 이미 같은 효과를 내기 위해 다음을 할 수 있습니까?

namespace std {

    namespace pre_cxx_1997 {
        // ...
    }
#if __cplusplus < 1997L // pre-standard C++
    using namespace pre_cxx_1997;
#endif

#if __cplusplus >= 1997L // C++98/03 or later
                         // (ifdef'ed out b/c it probably uses new language
                         // features that a pre-C++98 compiler would choke on)

    namespace cxx_1997 {
        // ...
    };
#  if __cplusplus == 1997L // C++98/03
    using namespace cxx_1997;
#  endif

#endif // C++98/03 or later

} // namespace std

의 가치에 따라 __cplusplus구현 중 하나를 얻습니다.

그리고 당신은 거의 정확할 것입니다.

다음과 같은 유효한 C ++ 98 사용자 코드를 고려하십시오 ( std이미 C ++ 98의 네임 스페이스 에 있는 템플릿을 완전히 특수화 할 수 있음).

// I don't trust my STL vendor to do this optimisation, so force these 
// specializations myself:
namespace std {
    template <>
    class vector<MyType> : my_special_vector<MyType> {
        // ...
    };
    template <>
    class vector<MyOtherType> : my_special_vector<MyOtherType> {
        // ...
    };
    // ...etc...
} // namespace std

이것은 사용자가 STL에서 찾은 것보다 더 효율적인 구현을 알 수있는 유형 집합에 대해 자체 벡터 구현을 제공하는 완벽하게 유효한 코드입니다.

그러나 : 템플릿을 특수화 할 때는 vector선언 된 네임 스페이스 std에서 그렇게해야 합니다. 표준 에서는 네임 스페이스에 선언되어 있으므로 사용자가 형식을 특수하게 지정해야합니다.

이 코드는 버전이없는 네임 스페이스 std또는 C ++ 11 인라인 네임 스페이스 기능과 함께 작동하지만 사용 된 버전 관리 트릭과 는 작동하지 않습니다 . using namespace <nested>이는 vector정의 된 실제 네임 스페이스가 std직접적 으로 구현되지 않았 음을 구현 세부 사항에 노출시키기 때문입니다 .

중첩 된 네임 스페이스를 감지 할 수있는 다른 구멍이 있지만 (아래 주석 참조) 인라인 네임 스페이스는 모두 연결합니다. 그리고 그것이 전부입니다. 미래에는 엄청나게 유용하지만 표준 AFAIK는 자체 표준 라이브러리에 대해 인라인 네임 스페이스 이름을 지정하지 않으므로 (이 경우 잘못된 것으로 입증되고 싶습니다) 타사 라이브러리에만 사용할 수 있습니다. 표준 자체 (컴파일러 벤더가 이름 지정 체계에 동의하지 않는 한).

답변

// file V99.h:
inline namespace V99 {
    void f(int);    // does something better than the V98 version
    void f(double); // new feature
    // ...
}

// file V98.h:
namespace V98 {
    void f(int);    // does something
    // ...
}

// file Mine.h:
namespace Mine {
#include "V99.h"
#include "V98.h"
}

#include "Mine.h"
using namespace Mine;
// ...
V98::f(1);  // old version
V99::f(1);  // new version
f(1);       // default version

struct bar;
void Foo(bar& ref);

$ nm main.o
T__ Z1fooRK6bar 

struct bar{
   int x;
#ifndef NDEBUG
   int y;
#endif
};

#ifndef NDEBUG
inline namespace rel {
#else
inline namespace dbg {
#endif
struct bar{
   int x;
#ifndef NDEBUG
   int y;
#endif
};
}

$ nm rel.o
T__ ZROKfoo9relEbar
$ nm dbg.o
T__ ZROKfoo9dbgEbar

//library code
namespace B { //library name the user knows
    namespace A { //ABI version the user doesn't know about
        template<class T> class myclass{int a;};
    }
    using namespace A; //pre inline-namespace versioning trick
}

// user code
namespace B { //user thinks the library uses this namespace
    template<> class myclass<int> {};
}

#include <iostream>
namespace A {
    namespace B{
        int a;
        int func(int a);
        template<class T> class myclass{int a;};
        class C;
        extern int d;
    }
    using namespace B;
}
int A::d = 3; //No member named 'd' in namespace A
class A::C {int a;}; //no class named 'C' in namespace 'A' 
template<> class A::myclass<int> {}; // works; specialisation is not an out-of-line definition of a declaration
int A::func(int a){return a;}; //out-of-line definition of 'func' does not match any declaration in namespace 'A'
namespace A { int func(int a){return a;};} //works
int main() {
    A::a =1; // works; not an out-of-line definition
}

namespace library {
    inline namespace abi_v1 {
        class foo {
        }
    }
}

namespace library {
    inline namespace abi_v2 {
        class foo {
            //new member
        }
    }
}

namespace library {
    namespace abi_v1 {
        class foo {
        }
    }

    inline namespace abi_v2 {
        class foo {
            //new member
        }
    }
}