c++ - सी++ 11 में ग्लोबल नेमस्पेस को कैसे नाम दिया जाए




c++11 namespaces (2)

लघु प्रपत्र : मैं सी ++ 11 में रूट (वैश्विक) नेमस्पेस के लिए एक उपनाम कैसे परिभाषित कर सकता हूं? ऐसा लग सकता है

namespace root_namespace = :: ;

जहां इसके नग्न रूप में स्कोप रेज़ोल्यूशन ऑपरेटर वैश्विक नामस्थान के कुछ संभाल के लिए एक जगह धारक है। मैंने जीसीसी इंटरनेशनल मैनुअल में पढ़ा है

... [कंपाइलर] संपूर्ण मध्यवर्ती प्रतिनिधित्व की मूल चर वैश्विक_नामस्थान है यह नामस्थान निर्दिष्ट है :: सी ++ स्रोत कोड में ... वैश्विक नामस्थान का नाम :: , भले ही सी ++ में वैश्विक नामस्थान का नाम नहीं है।

पीएस संपादित करें : उत्तरदाताओं को आज तक, मैं निम्नलिखित लंबे फॉर्म के बाद कुछ चिंताओं को दूर करने के लिए एक दर्दनाक रूप से लंबा रूप जोड़ता हूं, क्योंकि यह कुछ चीजें स्पष्ट कर सकता है । और अनुयायियों, अगर आप हमें एक-दूसरे की बजाय बात करते देखते हैं,

लांग फॉर्म : इसकी संभावित उपयोग का एक उदाहरण निम्नानुसार है। यदि असंतोषजनक है, तो हाँ, यह एक अकादमिक प्रश्न है; इस एक के बाद दर्दनाक रूप से लंबा रूप देखें

कल्पना कीजिए कि आपका बॉस एक दिन में बार्ज करता है और कहता है, "मैं सिर्फ पोस्ट-पॉजिटिविज़्म के बारे में एक किताब पढ़ता हूं। namespace ObjectiveReality से namespace ObjectiveReality जाओ। नीचे दिए गए कोड में, आपको 'सभी' करना होगा जो मैंने लिखी हुई लाइनों को /* -> */ this /* <- */ रूप में चिह्नित किया है आप वर्तमान में घोंसले के शिकार के मध्यवर्ती स्तरों के लिए ऐसा कर सकते हैं; हालांकि, मैं अनिश्चित हूँ कि वैश्विक गैर-वैश्विक नामस्थान की सरल अभिव्यक्ति की अनुमति देने के लिए वैश्विक-क्षेत्र namespace current_authority को कैसे परिभाषित किया जाए।

#include <iostream>
#include <iomanip>


// ...
using cat_is_alive = std::true_type ; // because I like cats
using cat_is_alive = ::cat_is_alive ; // seems to work, see `g++ -v` below
// ...


// ASIDE: I originally had `namespace higher_authority = COMPILER ;` as a comment, but changed it for simpler chaining closure

// The next two lines are the crux of my question...

namespace higher_authority = global_namespace ;
namespace current_authority = global_namespace ; // a.k.a. the naked ::

// If the above two lines defined aliases for the (unnamed) global namespace, then the suggested elisions/replacements work...

/* -> */
namespace ObjectiveReality {
/* <- */
// Simplest fix: replace with `using ObjectiveReality = current_authority ;`
//   (Otherwise, a few other changes are necessary)

    namespace higher_authority = current_authority ;
    namespace current_authority = ObjectiveReality ;

    using cat_is_alive = higher_authority::cat_is_alive ;

    namespace EntangledObserver {

        namespace higher_authority = current_authority ;
        namespace current_authority = EntangledObserver ;

        using cat_is_alive = higher_authority::cat_is_alive ;
    } ;
/* -> */
} ;
/* <- */


int main( int argc, char** argv ) {

    std::cout
        << "It is "
        << ObjectiveReality::EntangledObserver::cat_is_alive::value
       << " that the cat is alive." << std::endl ;

    return 0 ;
}


// EOF

कंपाइलर जानकारी की आवश्यकता होने पर:

$ g++ -std=c++11 -v

Using built-in specs.
COLLECT_GCC=g++
COLLECT_LTO_WRAPPER=/usr/lib/gcc/i686-linux-gnu/4.7/lto-wrapper
Target: i686-linux-gnu
Configured with: ../src/configure -v --with-pkgversion='Ubuntu/Linaro 4.7.2-11precise2' 
--with-bugurl=file:///usr/share/doc/gcc-4.7/README.Bugs 
--enable-languages=c,c++,go,fortran,objc,obj-c++ --prefix=/usr --program-suffix=-4.7 
--enable-shared --enable-linker-build-id --with-system-zlib --libexecdir=/usr/lib 
--without-included-gettext --enable-threads=posix
--with-gxx-include-dir=/usr/include/c++/4.7 --libdir=/usr/lib
--enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug 
--enable-libstdcxx-time=yes --enable-gnu-unique-object --enable-plugin
--enable-objc-gc --enable-targets=all --disable-werror --with-arch-32=i686
--with-multilib-list=m32,m64 --with-tune=generic --enable-checking=release 
--build=i686-linux-gnu --host=i686-linux-gnu --target=i686-linux-gnu
Thread model: posix
gcc version 4.7.2 (Ubuntu/Linaro 4.7.2-11precise2) 

गंभीर रूप से लंबे समय से फ़ॉर्म : "नेस्टेड नेमस्पेस से शुरू होने वाले" के बारे में कुछ उत्तरों की प्रतिक्रिया के रूप में, ध्यान दें कि 'होम!' दुर्गम है, और यह कि मेरे पास किसी टीम में नाम-स्थान का चयन करने का विलासिता नहीं है।

//
// alice.cpp
//


#include <iostream>
#include <type_traits>


/////
///// The Setup
/////

//
// One-and-a-half macros
//

// BOO! Get rid of this case!
#define ENABLE_SUBSPACE_1( namespace_name ) \
    namespace namespace_name { \
    namespace last_namespace = ::namespace_name ; \
    namespace this_namespace = ::namespace_name ;

// YEAH! Instead, define 'namespace this_namespace = :: ;' and then...
#define ENABLE_SUBSPACE( namespace_name ) \
    namespace namespace_name { \
    namespace last_namespace = this_namespace ; \
    namespace this_namespace = last_namespace::namespace_name ;

//
// Some characters
//

struct dorothy {
    static constexpr auto obvious_statement = "There's no place like " ;
} ;

struct rabbit {
    template< typename T >
    static constexpr char const* says( T ) {
        return T::value ? "I'm late!" : "I'm late, but I ditched that addled girl." ;
    }
} ;

struct alice {

    using blue_pill = std::false_type ;
    static constexpr auto where_am_i = "HOME!" ;
} ;


/////
///// The Central Structure
/////

ENABLE_SUBSPACE_1( oxford_england ) // {

    using has_strangers_with_candy = std::true_type ;

    struct alice {
        using blue_pill = this_namespace::has_strangers_with_candy ;
        static constexpr auto where_am_i = "Uncle Charles' picnic blanket." ;
    } ;

ENABLE_SUBSPACE( rabbit_hole ) // {
    struct rabbit { using is_late = typename alice::blue_pill ; } ;
ENABLE_SUBSPACE( rabbit_hole ) // {
    struct rabbit { using is_late = typename alice::blue_pill ; } ;
ENABLE_SUBSPACE( rabbit_hole ) // {
    struct rabbit { using is_late = typename alice::blue_pill ; } ;
    using has_strangers_with_candy = std::false_type ; ///// Different...
ENABLE_SUBSPACE( rabbit_hole ) // {
    struct rabbit { using is_late = typename alice::blue_pill ; } ;
ENABLE_SUBSPACE( rabbit_hole ) // {
    struct rabbit { using is_late = typename alice::blue_pill ; } ;
    struct alice { ///// Different...
        using blue_pill = has_strangers_with_candy ;
        static constexpr auto where_am_i = "needing a fix." ;
    } ;
ENABLE_SUBSPACE( rabbit_hole ) // {
    struct rabbit { using is_late = typename alice::blue_pill ; } ;
    struct alice : last_namespace::alice { ///// Different...
        static constexpr auto where_am_i = "an empty rabbit hole." ;
    } ;
} ; // END rabbit_hole
} ; // END rabbit_hole
} ; // END rabbit_hole
} ; // END rabbit_hole
} ; // END rabbit_hole
} ; // END rabbit_hole
} ; // END oxford_england


/////
///// Snarky Output
/////

int main( int argc, char** argv ) {

    std::cout << std::endl
        << dorothy::obvious_statement
        << alice::where_am_i
        << std::endl ; // There's no place like HOME!

    std::cout
        << dorothy::obvious_statement
        << oxford_england::rabbit_hole::rabbit_hole::rabbit_hole::rabbit_hole::rabbit_hole::alice::where_am_i
        << std::endl ; // There's no place like needing a fix.

    std::cout
        << dorothy::obvious_statement
        << oxford_england::rabbit_hole::rabbit_hole::rabbit_hole::rabbit_hole::rabbit_hole::rabbit_hole::alice::where_am_i
        << std::endl ; // There's no place like an empty rabbit hole.

    std::cout << std::endl
        << rabbit::says(
            oxford_england::
                rabbit_hole::
                    rabbit_hole::
                        rabbit_hole::
                            rabbit_hole::
                                rabbit_hole::rabbit::is_late()
        ) << std::endl ; // I'm late!
    std::cout
        << rabbit::says(
            oxford_england::
                rabbit_hole::
                    rabbit_hole::
                        rabbit_hole::
                            rabbit_hole::
                                rabbit_hole:: // NOTE : alice::blue_pill is false_type
                                    rabbit_hole::rabbit::is_late() // ... not this time ; Alice is crashing.
        ) << std::endl ; // I'm late, but I ditched that addled girl.

    std::cout << std::endl
        << dorothy::obvious_statement
        << oxford_england::
                rabbit_hole:: // 1
                    rabbit_hole:: // 2
                        rabbit_hole:: // 3
                            rabbit_hole:: // 4
                                rabbit_hole:: // 5
                                    rabbit_hole:: // rabbit_hole #6
                                last_namespace:: // rabbit_hole #5
                            last_namespace:: // rabbit_hole #4
                        last_namespace:: // rabbit_hole #3
                    last_namespace:: // rabbit_hole #2
                last_namespace:: // rabbit_hole #1
            last_namespace::alice::where_am_i // oxford_england
        << std::endl ; // There's no place like Uncle Charles' picnic blanket.
    std::cout
        << dorothy::obvious_statement
        << oxford_england::
                rabbit_hole::
                    rabbit_hole::
                        rabbit_hole::
                            rabbit_hole::
                                rabbit_hole::
                                    rabbit_hole::
                                last_namespace::
                            last_namespace::
                        last_namespace:: // 3
                    last_namespace:: // 2
                last_namespace:: // 1
            last_namespace:: // oxford
        last_namespace::alice::where_am_i // not the global namespace!
        << ".. but I'd rather be " << ::alice::where_am_i // the global namespace.
        << std::endl ; // There's no place like Uncle Charles' picnic blanket... but I'd rather be HOME!

    std::cout << std::endl ;
    return 0 ;
}


/////
///// EOF
/////


/* Compiled with:
    `g++ -std=c++11 -o alice alice.cpp`
*/

/* Output of `alice` :

There's no place like HOME!
There's no place like needing a fix.
There's no place like an empty rabbit hole.

I'm late!
I'm late, but I ditched that addled girl.

There's no place like Uncle Charles' picnic blanket.
There's no place like Uncle Charles' picnic blanket... but I'd rather be HOME!

*/

मुझे नहीं लगता कि आप वैश्विक नाम स्थान को उपनाम कर सकते हैं।

मानक एक नेमस्पेस उपनाम को परिभाषित करता है: इसे सिर्फ एक अन्य नेमस्पेस नाम की तरह व्यवहार करने के बजाय स्पष्ट रूप से कहा जाता है:

7.3.2   Namespace alias
A namespace-alias-definition declares an alternate name for a namespace according to the following grammar:
namespace-alias:
    identifier 
namespace-alias-definition:
    namespace identifier = qualified-namespace-specifier ;
qualified-namespace-specifier:
    ::_opt nested-name-specifier_opt namespace-name

ध्यान दें कि :: ऑप्ट (वैकल्पिक) है, लेकिन नाम-स्थान-नाम नहीं है।

हालांकि, क्या आप केवल अपने नेमस्पेस स्टैक की शुरुआत के रूप में वैश्विक नेमस्पेस के अलावा किसी अन्य चीज़ का उपयोग नहीं कर सकते हैं और फिर भी आपके द्वारा उल्लिखित पैटर्न का अनुसरण कर सकते हैं?

यह भी ध्यान रखें कि आपके उदाहरण को वास्तव में कुछ अतिरिक्त लाइनों को संपादित करने की आवश्यकता होती है, जब आप उद्देश्यरेखा हटाते हैं:

namespace current_authority = ObjectiveReality ;

तथा:

<< ObjectiveReality::EntangledObserver::cat_is_alive::value

आपके नेमस्पेस स्टैक की जड़ के रूप में ग्लोबल नेमस्पेस के बजाय नेमस्पेस "कुछ" का प्रयोग करने का आपका उदाहरण यह है।

#include <iostream>
#include <iomanip>


// ...                                                                                                                                                                                                                                                                                                                                                                    
namespace something {
  using cat_is_alive = std::true_type ; // because I like cats                                                                                                                                                                                                                                                                                                            
}
using namespace something;
// ...                                                                                                                                                                                                                                                                                                                                                                    


// ASIDE: I originally had `namespace higher_authority = COMPILER ;` as a comment, but changed it for simpler chaining closure                                                                                                                                                                                                                                            

// The next two lines are the crux of my question...                                                                                                                                                                                                                                                                                                                      

namespace higher_authority = something;
namespace current_authority = something;                                                                                                                                                                                                                                                                                                         

// If the above two lines defined aliases for the (unnamed) global namespace, then the suggested elisions/replacements work...                                                                                                                                                                                                                                            

/* -> */
namespace ObjectiveReality {
  /* <- */
  // Simplest fix: replace with `using ObjectiveReality = current_authority ;`                                                                                                                                                                                                                                                                                            
  //   (Otherwise, a few other changes are necessary)                                                                                                                                                                                                                                                                                                                     

  namespace higher_authority = current_authority ;
  namespace current_authority = ObjectiveReality ;

  using cat_is_alive = higher_authority::cat_is_alive ;

  namespace EntangledObserver {

    namespace higher_authority = current_authority ;
    namespace current_authority = EntangledObserver ;

    using cat_is_alive = higher_authority::cat_is_alive ;
  } ;
  /* -> */
} ;
/* <- */


int main( int argc, char** argv ) {

  std::cout
    << "It is "
    << ObjectiveReality::EntangledObserver::cat_is_alive::value
    << " that the cat is alive." << std::endl ;

  return 0 ;
}


// EOF

मुझे डिफ़ॉल्ट नाम स्थान के सीधे नाम से जाने के तरीके के बारे में पता नहीं है, लेकिन एक वैकल्पिक रूप से आप एक मैक्रो का इस्तेमाल कर सकते हैं (मान लें कि आप मैक्रो के नाम से असंबंधित प्रतीकों के साथ टकराने के लिए तैयार हैं)।

#define root_namespace

उपयोग:

root_namespace::cat_is_alive

चूंकि म्यूइंग डक सही ढंग से बताता है, यह हैक क्लाजों using करने के साथ काम नहीं करेगा।





global-scope