Üstbilgi içinde C ++ 'da yuvalanmış ad alanlarını ifade etmenin daha iyi bir yolu var mı?

C ++ 'dan Java ve C #' a geçtim ve ad alanlarının / paketlerinin kullanımının burada çok daha iyi olduğunu düşünüyorum (iyi yapılandırılmış). Sonra C ++ 'ya geri döndüm ve ad alanlarını aynı şekilde kullanmaya çalıştım ancak gerekli sözdizimi başlık dosyasında korkunç.

namespace MyCompany
{
    namespace MyModule
    {
        namespace MyModulePart //e.g. Input
        {
            namespace MySubModulePart
            {
                namespace ...
                {
                    public class MyClass    

Aşağıdakiler de bana garip geliyor (derin girintiyi önlemek için):

namespace MyCompany
{
namespace MyModule
{
namespace MyModulePart //e.g. Input
{
namespace MySubModulePart
{
namespace ...
{
     public class MyClass
     {

Yukarıdaki şeyi ifade etmenin daha kısa bir yolu var mı? Gibi bir şey özlüyorum

namespace MyCompany::MyModule::MyModulePart::...
{
   public class MyClass

Güncelleme

Tamam, bazıları Java / C # ve C ++ 'da kullanım kavramının farklı olduğunu söylüyor. Gerçekten mi? (Dinamik) sınıf yüklemesinin ad alanlarının tek amacı olmadığını düşünüyorum (bu çok teknik gerekçeli bir bakış açısıdır). Okunabilirlik ve yapılandırma için neden kullanmayayım, örneğin "IntelliSense" i düşünün.

Şu anda, bir ad alanı ile orada bulabilecekleriniz arasında mantık / tutkal yoktur. Java ve C # bunu çok daha iyi yapar ... Neden <iostream>ad alanı dahil edilsin ve var std? Tamam, mantığın dahil edilecek başlığa dayanması gerektiğini söylüyorsanız, #include neden #include <std::io::stream>veya gibi "IntelliSense" dostu bir sözdizimi kullanmıyor <std/io/stream>? Varsayılan kitaplıklardaki eksik yapılanmanın Java / C # ile karşılaştırıldığında C ++ 'nın bir zayıflığı olduğunu düşünüyorum.

Hırslı çatışmaların benzersizliği bir Nokta ise (ki bu da C # ve Java'nın bir noktasıdır), proje adını veya şirket adını ad alanı olarak kullanmak iyi bir fikirdir, öyle değil mi?

Bir yandan C ++ 'nın en esnek olduğu söyleniyor ... ama herkes "bunu yapma" mı dedi? Bana öyle geliyor ki C ++ pek çok şey yapabilir ancak C # ile karşılaştırıldığında çoğu durumda en kolay şeyler için bile korkunç bir sözdizimine sahiptir.

Güncelleme 2

Çoğu kullanıcı, iki Düzeyden daha derin bir yuvalama oluşturmanın saçma olduğunu söylüyor. Tamam, peki ya Windows :: UI :: Xaml ve Windows :: UI :: Xaml :: Controls :: Win8 geliştirmesindeki Primitives ad alanları? Bence Microsoft'un ad alanlarını kullanması mantıklı ve gerçekten de 2 Düzeyden daha derin. Bence daha büyük kütüphaneler / projeler daha derin bir yuvaya ihtiyaç duyar (ExtraLongClassNameBecauseEveryThingIsInTheSameNameSpace gibi sınıf isimlerinden nefret ederim ... o zaman her şeyi global ad alanına da koyabilirsiniz.)

Güncelleme 3 - Sonuç

Çoğu "bunu yapma" der, ancak ... güçlendirme bile bir veya iki seviyeden daha derin bir yuvaya sahiptir. Evet, bu bir kitaplıktır ancak: Yeniden kullanılabilir kod istiyorsanız - kendi kodunuza başka birine vereceğiniz bir kitaplık gibi davranın. Ayrıca ad alanlarını kullanarak keşif amacıyla daha derin bir yuvalama kullanıyorum.

C ++ 17, iç içe geçmiş ad alanı tanımını basitleştirebilir:

namespace A::B::C {
}

eşdeğerdir

namespace A { namespace B { namespace C {
} } }

Cppreference adresindeki ad alanı sayfasında (8) 'e bakın:
http://en.cppreference.com/w/cpp/language/namespace

Gerçekten derin girintileme yapmaktan kaçınmak için bunu genellikle şu şekilde yaparım:

namespace A { namespace B { namespace C
{
    class X
    {
        // ...
    };
}}}

Peterchen'in cevabını tamamen destekliyorum ama sorunuzun başka bir kısmına hitap eden bir şey eklemek istiyorum.

İsim alanlarını bildirmek, C ++ 'da #defines kullanımını sevdiğim çok nadir durumlardan biridir .

#define MY_COMPANY_BEGIN  namespace MyCompany { // begin of the MyCompany namespace
#define MY_COMPANY_END    }                     // end of the MyCompany namespace
#define MY_LIBRARY_BEGIN  namespace MyLibrary { // begin of the MyLibrary namespace
#define MY_LIBRARY_END    }                     // end of the MyLibrary namespace

Bu aynı zamanda ad alanının kapanış parantezinin yanında yorum yapma ihtiyacını da ortadan kaldırır (Daha önce büyük bir kaynak dosyanın altına kaydırıp hangi parantezin hangi kapsamı kapattığına ilişkin yorumları eksik olan parantezleri eklemeyi / kaldırmayı / dengelemeyi denediniz mi? .).

MY_COMPANY_BEGIN
MY_LIBRARY_BEGIN

class X { };

class Y { };

MY_LIBRARY_END
MY_COMPANY_END

Tüm ad alanı bildirimlerini tek bir satıra koymak istiyorsanız, bunu biraz (oldukça çirkin) önişlemci sihri ile de yapabilirsiniz:

// helper macros for variadic macro overloading
#define VA_HELPER_EXPAND(_X)                    _X  // workaround for Visual Studio
#define VA_COUNT_HELPER(_1, _2, _3, _4, _5, _6, _Count, ...) _Count
#define VA_COUNT(...)                           VA_HELPER_EXPAND(VA_COUNT_HELPER(__VA_ARGS__, 6, 5, 4, 3, 2, 1))
#define VA_SELECT_CAT(_Name, _Count, ...)       VA_HELPER_EXPAND(_Name##_Count(__VA_ARGS__))
#define VA_SELECT_HELPER(_Name, _Count, ...)    VA_SELECT_CAT(_Name, _Count, __VA_ARGS__)
#define VA_SELECT(_Name, ...)                   VA_SELECT_HELPER(_Name, VA_COUNT(__VA_ARGS__), __VA_ARGS__)

// overloads for NAMESPACE_BEGIN
#define NAMESPACE_BEGIN_HELPER1(_Ns1)             namespace _Ns1 {
#define NAMESPACE_BEGIN_HELPER2(_Ns1, _Ns2)       namespace _Ns1 { NAMESPACE_BEGIN_HELPER1(_Ns2)
#define NAMESPACE_BEGIN_HELPER3(_Ns1, _Ns2, _Ns3) namespace _Ns1 { NAMESPACE_BEGIN_HELPER2(_Ns2, _Ns3)

// overloads for NAMESPACE_END
#define NAMESPACE_END_HELPER1(_Ns1)               }
#define NAMESPACE_END_HELPER2(_Ns1, _Ns2)         } NAMESPACE_END_HELPER1(_Ns2)
#define NAMESPACE_END_HELPER3(_Ns1, _Ns2, _Ns3)   } NAMESPACE_END_HELPER2(_Ns2, _Ns3)

// final macros
#define NAMESPACE_BEGIN(_Namespace, ...)    VA_SELECT(NAMESPACE_BEGIN_HELPER, _Namespace, __VA_ARGS__)
#define NAMESPACE_END(_Namespace, ...)      VA_SELECT(NAMESPACE_END_HELPER,   _Namespace, __VA_ARGS__)

Şimdi bunu yapabilirsiniz:

NAMESPACE_BEGIN(Foo, Bar, Baz)

class X { };

NAMESPACE_END(Baz, Bar, Foo) // order doesn't matter, NAMESPACE_END(a, b, c) would work equally well

Foo::Bar::Baz::X x;

Üç seviyeden daha derin yuvalama için, istenen sayıya kadar yardımcı makrolar eklemeniz gerekir.

C ++ ad alanları, bileşenleri bölmek veya politik bölünmeyi ifade etmek için değil, arabirimleri gruplamak için kullanılır.

Standart, ad alanlarının Java benzeri kullanımını yasaklamak için yolunun dışına çıkıyor. Örneğin, ad alanı takma adları , iç içe geçmiş veya uzun ad alanı adlarını kolayca kullanmanın bir yolunu sağlar.

namespace a {
namespace b {
namespace c {}
}
}

namespace nsc = a::b::c;

Ancak namespace nsc {}bu durumda bir hata olur, çünkü bir ad alanı yalnızca orijinal ad alanı adı kullanılarak tanımlanabilir . Esasen kolay için standart markaları şeyler kullanıcıya için böyle bir kütüphanenin ama sert uygulayıcısı . Bu, insanları bu tür şeyler yazmaktan caydırır, ancak yazarlarsa etkilerini azaltır.

Her arabirim için bir dizi ilişkili sınıf ve işlev tarafından tanımlanan bir ad alanına sahip olmalısınız. Dahili veya isteğe bağlı alt arabirimler, iç içe geçmiş ad alanlarına gidebilir. Ancak iki seviyeden fazla derinlik çok ciddi bir kırmızı bayrak olmalıdır.

::Operatörün gerekli olmadığı durumlarda alt çizgi karakterleri ve tanımlayıcı önekleri kullanmayı düşünün .

Hayır, lütfen bunu yapma.

Ad alanlarının amacı, öncelikle genel ad alanındaki çatışmaları çözmektir.

İkincil bir amaç, simgelerin yerel kısaltmasıdır; örneğin, karmaşık bir UpdateUIyöntem, using namespace WndUIdaha kısa sembolleri kullanmak için bir kullanabilir.

1.3MLoc projesindeyim ve sahip olduğumuz tek ad alanları:

• içe aktarılan harici COM kitaplıkları (esas olarak #importve arasındaki başlık çakışmalarını izole etmek için #include windows.h)
• Belirli yönler (UI, DB erişimi vb.) İçin bir düzey "genel API" ad alanları
• Genel API'nin parçası olmayan "Uygulama Ayrıntısı" ad alanları (.cpp'lerdeki anonim ad alanları veya ModuleDetailHereBeTygersyalnızca başlık kitaplıklarındaki ad alanları)
• numaralandırmalar benim deneyimimdeki en büyük sorun. Deli gibi kirletiyorlar.
• Hala çok fazla ad alanı olduğunu hissediyorum

Bu projede, sınıf adları vb. İki veya üç harfli bir "bölge" kodu kullanır (örneğin CDBNodebunun yerine DB::CNode). İkincisini tercih ederseniz, ikinci düzey "genel" ad alanları için yer vardır, ancak daha fazlası yoktur.

Sınıfa özgü numaralandırmalar vb. Bu sınıfların üyeleri olabilir (bunun her zaman iyi olmadığını kabul etsem de ve bazen yapmanız gerekip gerekmediğini söylemek zor)

İkili olarak dağıtılan 3. taraf kitaplıklarla ilgili büyük sorunlar yaşıyorsanız, kendi ad alanlarını sağlamıyorsanız ve kolayca bir ad alanına (örneğin bir ikili dosyada) eklenemiyorsanız, bir "şirket" ad alanına da nadiren ihtiyaç duyulur. dağıtım). Yine de deneyimlerime göre onları bir isim alanına zorlamak çok daha kolay.

[değiştir] Stegi'nin takip sorusuna göre:

Tamam, peki ya Windows :: UI :: Xaml ve Windows :: UI :: Xaml :: Controls :: Win8 geliştirmesindeki Primitives ad alanları? Bence Microsoft'un ad alanlarını kullanması mantıklı ve gerçekten de 2 Düzeyden daha derin

Yeterince net olamadıysam özür dilerim: İki seviye kesin bir sınır değildir ve daha fazlası özünde kötü değildir. Deneyimlerime göre, büyük bir kod tabanında bile nadiren ikiden fazlasına ihtiyacınız olduğunu belirtmek istedim . Daha derin veya daha sığ yuva yapmak bir değiş tokuştur.

Şimdi, Microsoft davası muhtemelen farklı. Muhtemelen çok daha büyük bir ekip ve tüm kod kitaplıktır.

Microsoft'un burada ad alanlarının kapsamlı kitaplığın keşfedilebilirliğine katkıda bulunduğu .NET Kitaplığı'nın başarısını taklit ettiğini varsayıyorum . (.NET'in yaklaşık 18000 türü vardır.)

Ayrıca bir isim alanında optimal (büyüklük sırası) bir sembol olduğunu varsayıyorum. Diyelim ki 1 mantıklı değil, 100 ses doğru, 10000 çok açık.

TL; DR: Bu bir değiş tokuş ve elimizde kesin rakamlar yok. Güvenli oynayın, hiçbir yönde aşırıya kaçmayın. "Bunu yapma" sadece "Bununla ilgili sorunların var, bununla sorunlar yaşarım ve buna neden ihtiyacın olacağına dair bir neden göremiyorum" dan gelir.

İşte Lzz (Lazy C ++) belgelerinden bir alıntı :

Lzz, aşağıdaki C ++ yapılarını tanır:

ad alanı tanımı

Adsız bir ad alanı ve tüm kapalı bildirimler kaynak dosyaya çıktı olarak verilir. Bu kural diğerlerini geçersiz kılar.

Adlandırılmış bir ad alanının adı nitelenebilir.

   namespace A::B { typedef int I; }

eşdeğerdir:

   namespace A { namespace B { typedef int I; } }

Elbette bu tür araçlara bağlı olan kaynakların kalitesi tartışmalı ... C ++ 'nın neden olduğu sözdizimi hastalığının birçok şekilde olabileceğini gösteren daha çok bir merak olduğunu söyleyebilirim (bende de var ...)

Her iki standart da (C ++ 2003 ve C ++ 11), ad alanının adının bir tanımlayıcı olduğu konusunda çok açıktır. Bu, açıkça iç içe geçmiş başlıkların gerekli olduğu anlamına gelir.

Bunun, ad alanının basit bir adının yanı sıra nitelikli tanımlayıcı yerleştirilmesine izin vermek için önemli bir şey olmadığı, ancak bazı nedenlerden dolayı buna izin verilmediğine dair izlenimim.

Bu makale konuyu oldukça iyi kapsamaktadır: İsim Alanı Kağıdı

Temelde bunu kaynatır. Ad alanlarınız ne kadar uzunsa, insanların using namespaceyönergeyi kullanma şansı o kadar artar .

Aşağıdaki koda bakarak bunun size zarar vereceği bir örnek görebilirsiniz:

namespace abc { namespace testing {
    class myClass {};
}}

namespace def { namespace testing {
    class defClass { };
}}

using namespace abc;
//using namespace def;

int main(int, char**) {
    testing::myClass classInit{};
}

Bu kod iyi derlenir, ancak, satırın açıklamasını kaldırırsanız, //using namespace def;o zaman "test etme" ad alanı belirsiz hale gelir ve adlandırma çakışmaları olur. Bu, kod tabanınızın bir 3. taraf kitaplığı ekleyerek kararlıdan kararsız duruma geçebileceği anlamına gelir.

C #, kullanmak için olsa bile using abc;ve using def;derleyici olduğunu kabul edebilir testing::myClassya da sadece myClasstek içindedir abc::testingad, ancak C ++ bu tanımaz ve bir çarpışma olarak algılanır.

Evet, bunu beğenmen gerekecek

namespace A{ 
namespace B{
namespace C{} 
} 
}

Ancak, ad alanlarını kullanılmaması gereken bir şekilde kullanmaya çalışıyorsunuz. Bu soruyu kontrol edin , belki faydalı bulacaksınız.

Bu sözdizimini kullanabilirsiniz:

namespace MyCompany {
  namespace MyModule {
    namespace MyModulePart //e.g. Input {
      namespace MySubModulePart {
        namespace ... {
          class MyClass;
        }
      }
    }
  }
}

// Here is where the magic happens
class MyCompany::MyModule::MyModulePart::MySubModulePart::MyYouGetTheIdeaModule::MyClass {
    ...
};

Bu sözdiziminin C ++ 98'de bile geçerli olduğunu ve iç içe geçmiş ad alanı tanımlarına sahip C ++ 17'de mevcut olana neredeyse benzer olduğunu unutmayın .

Mutlu unnesting!

Kaynaklar:

• http://seanmiddleditch.com/unnest-c-namespaces/
• http://www.nuonsoft.com/blog/2017/08/01/c17-nested-namespaces/

[ DÜZENLE: ]
c ++ 17 iç içe geçmiş ad alanı standart bir dil özelliği olarak desteklendiğinden ( https://en.wikipedia.org/wiki/C%2B%2B17 ). Şu an itibariyle bu özellik g ++ 8'de desteklenmemektedir, ancak clang ++ 6.0 derleyicisinde bulunabilir.

[SONUÇ:]
Kullanımclang++6.0 -std=c++17 Varsayılan derleme komutunuz olarak . O zaman her şey yolunda gitmeli - ve ile derleyebileceksiniznamespace OuterNS::InnerNS1::InnerNS2 { ... } dosyalarınızda .

[ORİJİNAL CEVAP:]
Bu soru biraz eski olduğu için, devam ettiğinizi varsayacağım. Ancak hala bir cevap arayan diğerleri için şu fikri buldum:

(Burada Emacs için bir reklam yapabilir miyim :)?) Bir resim göndermek, kodu postalamaktan çok daha kolay ve daha okunaklı. Tüm köşe vakalarının tam bir cevabını vermek niyetinde değilim, sadece biraz ilham vermek istedim. (C # 'ı tamamen destekliyorum ve çoğu durumda C ++' nın bazı OOP özelliklerini benimsemesi gerektiğini düşünüyorum, çünkü C # esas olarak karşılaştırılan kullanım kolaylığı nedeniyle popülerdir).