Correct way to using namespace in nested namespace scope

Question

We have in code one common namespace MainNamespace and a lot of namespace per module eg. ModuleNamespace, DifferentModuleNamespace. Module namespaces are inside the main namespace.

When we create a new class and need another class from different module we have to declare some using to avoid writing full namespace path.

What is consider as a good practice in such situation:

Using namespace with full path:

namespace MainNamespace {
namespace ModuleNamespace {

using MainNamespace::DifferentModuleNamespace::Foo;

       class MyClass {
           void method(Foo);
       };
}
}

or remove MainNamespace namespace from path:

namespace MainNamespace {
namespace ModuleNamespace {

using DifferentModuleNamespace::Foo;

   class MyClass {
       void method(Foo);
   };
}
}

or maybe different approach is better?

Edit:

Ok, maybe different question. Is there any situation when using absolute paths to namespace (using A = Main::ModuleA::A;) will be safer than using short paths(using A = ModuleA::C;). When we do it in the same main namespace.

file A.h:

namespace Main 
{
    namespace ModuleA {
        class A
        {
        public:
            A();
            ~A();
        };

        class C
        {
        public:
            C();
            ~C();
        };
    }
}

file B.h:

  #include "A.h"

    namespace Main {
        namespace ModuleB {

            class B
            {
                using A = Main::ModuleA::A;
                using A = ModuleA::C;

            public:
                B();
                ~B();
                void foo(A a);
                void bar(C c);
            };
        }
    }

Details Explanation is here en.cppreference.com/w/cpp/language/namespace — ArunPratap
– ArunPratap, Commented Feb 19, 2018 at 10:03

user7860670 · Accepted Answer · 2018-02-19 10:12:50Z

2

The better approach would be to declare class-level type alias for Foo and to remove using declaration from namespace scope. This will help to prevent name collisions when other classes from ModuleNamespace decide to use Foo from somewhere else.

class MyClass {
   using Foo = DifferentModuleNamespace::Foo;
   void method(Foo);
};

Alternatively, if Foo is supposed to be used in various other places of inside of ModuleNamespace then it would be worth to make a namespace-scope type alias (potentially residing in a separate header file):

// MainNamespace/ModuleNamespace/Foo.hpp
namespace MainNamespace {
namespace ModuleNamespace {

using Foo = DifferentModuleNamespace::Foo;

}
}

#include <MainNamespace/ModuleNamespace/Foo.hpp>

namespace MainNamespace {
namespace ModuleNamespace {

class MyClass {
     void method(Foo);
};

}
}

edited Feb 19, 2018 at 10:12

answered Feb 19, 2018 at 10:06

user7860670

37.9k4 gold badges65 silver badges96 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

developer Over a year ago

Declare class-level type alias probably fit to my case. Anyway I'm still confuse. Should I use: DifferentModuleNamespace::Foo or MainNamespace::DifferentModuleNamespace::Foo?

ObliteratedJillo · Accepted Answer · 2018-02-20 01:35:17Z

0

1) Avoid declaring 'using namespace' to avoid conflict ( eg init() here will conflict ). Although class member functions will not suffer from name conflict, however public helper functions could. Similar named helper functions eases in loading inherited objects together, such as in factory design pattern, and namespace will become mandatory in such case.

2) Avoid using suffix namespace as it is implied.

3) Use namespace for clarity and to avoid conflict ( eg core::module::create_factory() makes it lucid)

namespace core{
namespace module1 {

       class MyClass1 {
           void method(Foo)
              {
                 module2::init();
              }
       };
   //HelperFunction
     void init();

}
}


namespace core{
namespace module2{

   class MyClass2 {
          void method(Foo)
              {
                 module1::init();
              }
   };
     //HelperFunction
     void init();
}
}

edited Feb 20, 2018 at 1:35

answered Feb 19, 2018 at 11:38

ObliteratedJillo

5,1642 gold badges15 silver badges21 bronze badges

3 Comments

developer Over a year ago

Isn't better to remove core:: from core::module2::init() and core::module1::init(). Both are already in core namespace.

developer Over a year ago

In MyClass2 you can use module1::init(); and it is correct or I understand something wrong?

ObliteratedJillo Over a year ago

@developer: edited, yes you can use module1::init() directly.

Collectives™ on Stack Overflow

Correct way to using namespace in nested namespace scope

2 Answers 2

1 Comment

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related