03 - namespaces

namespace foo { void f1(); }

// namespaces can be opened multiple times, potentially in different files
namespace foo { void f2(); }

// namespaces can be nested and entities can appear at any level
namespace bar {
	void f3();

	namespace foo { // bar::foo is not the same as foo
		void f4();

		namespace baz {
			void f5();
		}

		void f6();
	}
}

// definitions of entities can appear in another namespace definition...
namespace foo { void f1() {} }
// ...or use qualified name
void foo::f2() {}

// inside a namespace, enclosing namespace names can be skipped
// this applies to any code that uses entities from enclosed namespace
namespace bar {
	void f3() {}
	void foo::f4() {}      // no need to write bar::foo::f4
	void foo::baz::f5() {} // no need to write bar::foo::baz::f5
}

// out-of-namespace definitions and redeclarations can not appear
// in a namespace that does not enclose original declaration
namespace xyz {
	// error: xyz::bar::foo::f6 does not exist
	// this syntax (qualified-id) can not be used to declare new entities
	// void bar::foo::f6() {}
}

// :: can be used before the name to refer to shadowed entity
void f();
namespace abc {
	void f() // hides (shadows) global f
	{
		::f(); // ok: calls ::f (not a recursion)
	}
}

// it's possible to create namespace aliases
namespace abc {
	namespace bfb = ::bar::foo::baz;
}

void f7()
{
	abc::bfb::f5(); // ok: calls bar::foo::baz::f5
}

void f();

namespace abc
{
	void g1();
	void g2();
}

namespace xyz
{
	using ::f;
	using abc::g1;
}

void h()
{
	xyz::f();  // calls ::f
	xyz::g1(); // calls abc::g1

	using abc::g2;
	g2(); // calls abc::g2
}

namespace abc
{
	void f(int);
}
using abc::f; // ::f is now a synonym for abc::f(int)

namespace abc
{
	void f(char); // does not change what ::f means
}

void foo()
{
	f('a'); // calls f(int), even though f(char) exists.
}

void bar()
{
	using abc::f; // introduces both overloads
	f('a');       // calls f(char)
}

namespace abc
{
	void f(int);
	void f(double);

	void g(int);
}

namespace xyz
{
	void f(int);
	void f(double);
	void f(char);
}

void g();
// using abc::g; // error: g already in this scope

// no error even though some overloads are identical
using abc::f;
using xyz::f;

// void f(int); // error: conflicts with abc::f(int) and xyz::f(int)

void h()
{
	f('h'); // calls xyz::f(char)
	f(1.0); // error: ambiguity between abc::f(double) and xyz::f(double)
}

namespace abc
{
	int i = 1;
	void f(char);
}

namespace foo
{
	int i = 2;
	int j = 3;

	namespace bar
	{
		namespace baz
		{
			// names from abc injected into global namespace
			// (including any names later declared in abc)
			using namespace abc;

			int j = 4;
			int k = 5;
			int a = i; // ok: foo::i hides abc::i
		}

		// names from baz injected into bar
		// names from abc injected into global namespace (using namespace is transitive)
		using namespace baz;

		int l = k; // ok, uses baz::k
		int k = 6; // ok, no name conflict
		int m = k; // error: bar::k or baz::k?
		int n = i; // ok: foo::i hides abc::i
		int o = j; // ok: baz::j hides foo::j
	}
}

using namespace abc;

namespace xyz
{
	int e = 7;
	void f(int);
}

namespace abc
{
	int d = 8;
	using namespace xyz;
	void f(int);
}

int d = 9;

void func()
{
	++d;      // error: ::d or abc::d?
	++::d;    // ok
	++abc::d; // ok
	++e;      // ok (using namespace is transitive)

	f(1);     // error: xyz::f(int) or abc::f(int)?
	f('a');   // ok: abc::f(char)
}

enum class fruit { apple, orange };
enum class color { green, orange, red };

struct boo
{
	using enum fruit;
};

void f()
{
	// ok: auto = fruit
	auto x = boo::orange;
	// also ok, but I wouldn't write such code
	// I guess this syntax is allowed to make writing templates easier
	boo b;
	auto y = b.orange;
}

void g()
{
	using enum fruit; // ok: you can now use apple and orange
	using enum color; // error: fruit::orange and color::orange conflict
}

// header
std::string important_complex_function(int x, int y, double n)

// source
namespace {
	// many helper functions that are used only in this file
	// all will have *internal linkage*
	// the same names can be reused in other TUs
}

std::string important_complex_function(int x, int y, double n)
{
	// uses many helper functions...
}

namespace foo {
	inline namespace bar {
		void f();

		inline namespace baz {
			void g();
		}
	}
}

void func()
{
	// namespace names can be specified explicitly
	foo::bar::f();
	foo::bar::baz::g();

	// namespace names can have inline namespaces ommitted
	foo::f();
	foo::g();
}

// C++17 - multiple usings in one statement
using ::f; using abc::g; using xyz::h;
using ::f, abc::g, xyz::h;

// C++17 - defining nested namespaces with one keyword and one {}
namespace na { namespace nb { namespace nc { /* ... */ }}}
namespace na::nb::nc { /* ... */ } // no prior appearance of na and na::nb is required

// C++20 - additionally supports inline
namespace nd::ne { inline namespace nf { /* ... */ }}
namespace nd::ne::inline nf { /* ... */ }

namespace ng { inline namespace nh { namespace ni { /* ... */ }}}
namespace ng::inline nh::ni { /* ... */ }