Visible to Intel only — GUID: GUID-EEA0F3D3-B390-47B5-8B77-04ECDBF97E64
Uniform Initialization
Multithreading
Smart Pointers
Hash Tables
std::array Container
Move Semantics
Lambdas
Type Inference in C++ (auto and decltype)
Initializers in if and switch Statements
Standard Template Library (STL) on Concurrent and Parallel Algorithms
Nested Namespaces
Introduction
Nested Namespaces
Introduction to SYCL Essentials
Module 1: oneAPI Intro
Module 2: DPCPP Program Structure
Module 3: DPCPP Unified Shared Memory
Module 4: DPCPP Sub-Groups
Module 5: Intel® Advisor
Module 6: VTune™ Profiler
Module 7: DPCPP Library
Module 8: DPCPP Reduction
Module 9: DPCPP Buffers And Accessors In Depth
Module 10: DPCPP Graphs Scheduling Data Management
Module 11: Intel® Distribution for GDB
Module 12: DPCPP Local Memory And Atomics
Visible to Intel only — GUID: GUID-EEA0F3D3-B390-47B5-8B77-04ECDBF97E64
Nested Namespaces
This chapter covers C++ namespaces. You will learn the following:
What is a namespace?
How can you declare your own namespace?
How do nested namespaces work in C++?
Introduction
The namespace is a declarative region that provides scope to the identifiers like names of types, functions, and variables. Namespaces are usually used to organize the code into logical groups and to avoid name collisions. It can be especially important when you're using different libraries. One of the examples of the namespace scope is the C++ Standard Template Library (STL), where all the classes, methods, and templates are declared. You can find STL namespace in the code std::` before multiple class or function declarations from STL in C++. Sometimes you can also find the directive :code:`using namespace std;.
Defining a Namespace
To define a namespace, you have to start with the namespace keyword followed by the name:
namespace your_namespace_name {
// ...
// declarations
// ...
}Note that there is no semicolon ; after the closing bracket. To call the function or variable declared within the namespace, prepend the namespace name as shown below:
your_namespace_name::function_name(/*...*/);
your_namespace_name::variable_name;Nested Namespaces
In C++, namespaces can be nested, which makes it possible to define one namespace inside another. The resolution of namespace variables is hierarchical. The syntax is shown below:
namespace A {
// ...
// declarations
namespace B {
// ...
// declarations
namespace C {
// ...
// declarations
}
}
}As you can see, those declarations take a lot of space and sometimes it's difficult to track all the levels of the declared namespaces. But in modern C++, writing nested namespaces can be simplified:
namespace A::B::C {
// ...
// declarations
}It is useful when you want to declare functions and variables in the deepest namespace. It also allows you to easily track the namespace in which you're writing your declarations. Similarly, as with a single namespace, to call the function or variable declared within the nested namespace, you need to write all levels of the namespaces:
A::B::C::function_name(/*..*/);
A::B::C::variable_name;Now, let's see it in the real example:
#include <iostream>
// outer namespace declaration
namespace outer {
void foo() {
std::cout << "Outer foo() function call. \n";
}
// inner namespace declaration
namespace inner {
void foo() {
std::cout << "Inner foo() function call. \n";
}
}
}
int main() {
outer::inner::foo();
outer::foo();
return 0;
}The output of the code will look like this:
Inner foo() function call.
Outer foo() function call.This means that the inner foo function was called first, followed by the outer foo function.