---------------
// Graph_lib:

class Shape { /*...*/ };
class Line : public Shape { /*...*/ };
class Poly_line: public Shape { /*...*/ };      // sekwencja poczonych linii
class Text : public Shape { /*...*/ };          // etykieta tekstowa

Shape operator+(const Shape&, const Shape&); // czenie

Graph_reader open(const char*);              // otwiera plik ksztatw
---------------
// Text_lib:

class Glyph { /*...*/ };
class Word { /*...*/ }; // sekwencja glifw
class Line { /*...*/ }; // sekwencja sw
class Text { /*...*/ }; // sekwencja linii

File*open(const char*);                   // otwiera plik tekstowy

Word operator+(const Line&, const Line&); // konkatenacja
---------------
#include "Graph_lib.h"
#include "Text_lib.h"
//...
---------------
namespace Graph_lib {
    class Shape { /*...*/ };
    class Line : public Shape { /*...*/ };
    class Poly_line: public Shape { /*...*/ };      // sekwencja poczonych linii
    class Text : public Shape { /*...*/ };          // etykieta tekstowa

    Shape operator+(const Shape&, const Shape&); // czenie

    Graph_reader open(const char*);              // otwiera plik ksztatw
}
---------------
namespace Text_lib {
    class Glyph { /*...*/ };
    class Word { /*...*/ }; // sekwencja glifw
    class Line { /*...*/ }; // sekwencja sw
    class Text { /*...*/ }; // sekwencja linii

    File*open(const char*);                   // otwiera plik tekstowy

    Word operator+(const Line&, const Line&); // konkatenacja
}
---------------
class Glyph { /*...*/ };
class Line { /*...*/ };

namespace Text_lib {
    class Glyph { /*...*/ };
    class Word { /*...*/ }; // sekwencja glifw
    class Line { /*...*/ }; // sekwencja sw
    class Text { /*...*/ }; // sekwencja linii

    File*open(const char*);                   // otwiera plik tekstowy

    Word operator+(const Line&, const Line&); // konkatenacja
}

Glyph glyph(Line& ln, int i); // ln[i]
---------------
Text_lib::Glyph glyph(Text_lib::Line& ln, int i); // ln[i]
---------------
namespace nazwa-przestrzeni {
    // deklaracje i definicje
}
---------------
namespace Parser {
    double expr(bool);       // deklaracja
    double term(bool);
    double prim(bool);
}

double val = Parser::expr(); // uycie

double Parser::expr(bool b)  // definicja
{
    //...
}
---------------
void Parser::logical(bool); // bd: brak nazwy logical() w przestrzeni Parser
double Parser::trem(bool);  // bd: brak nazwy trem() w przestrzeni Parser (literwka)
double Parser::prim(int);   // bd: funkcja Parser::prim() przyjmuje argument typu bool (nieprawidowy typ)
---------------
int f();   // funkcja globalna

int g()
{
    int f; // zmienna lokalna; przesania funkcj globaln
    f();   // bd: nie mona wywoa obiektu typu int
    ::f(); // OK: wywoanie funkcji globalnej
}
---------------
#include<string>
#include<vector>
#include<sstream>

std::vector<std::string> split(const std::string& s)
    // dzieli s na podacuchy wg biaych znakw
{
    std::vector<std::string> res;
    std::istringstream iss(s);
    for (std::string buf; iss>>buf;)
        res.push_back(buf);
    return res;
}
---------------
using std::string; // niech string oznacza std::string

std::vector<string> split(const string& s)
    // dzieli s na podacuchy wg biaych znakw
{
    std::vector<string> res;
    std::istringstream iss(s)
    for (string buf; iss>>buf;)
        res.push_back(buf);
    return res;
}
---------------
namespace N {
    void f(int);
    void f(string);
};

void g()
{
    using N::f;
    f(789);     // N::f(int)
    f("Bruce"); // N::f(string)
}
---------------
using namespace std; // udostpnia wszystkie nazwy z przestrzeni nazw std

vector<string> split(const string& s)
    // dzieli s na podacuchy wg biaych znakw
{
    vector<string> res;
    istringstream iss(s);
    for (string buf; iss>>buf;)
        res.push_back(buf);
    return res;
}
---------------
namespace Graph_lib {
    class Shape { /*...*/ };
    class Line : Shape { /*...*/ };
    class Poly_line: Shape { /*...*/ }; // sekwencja poczonych linii
    class Text : Shape { /*...*/ };     // etykieta tekstowa

    Shape operator+(const Shape&, const Shape&); // skadanie

    Graph_reader open(const char*);  // otwiera plik ksztatw
}

namespace Text_lib {
    class Glyph { /*...*/ };
    class Word { /*...*/ };    // sekwencja glifw
    class Line { /*...*/ };    // sekwencja sw
    class Text { /*...*/ };    // sekwencja linii

    File*open(const char*); // otwiera plik tekstowy

    Word operator+(const Line&, const Line&); // konkatenacja
}

using namespace Graph_lib;
using namespace Text_lib;

Glyph gl;          // Text_lib::Glyph
vector<Shape*> vs; // Graph_lib::Shape
---------------
Text txt;                           // bd: niejednoznaczne
File*fp = open("my_precious_data"); // bd: niejednoznaczne
---------------
namespace Chrono {
    class Date { /*...*/ };

    bool operator==(const Date&, const std::string&);

    std::string format(const Date&); // tworzy reprezentacj acuchow
    //...
}

void f(Chrono::Date d, int i)
{
    std::string s = format(d); // Chrono::format()
    std::string t = format(i); // bd: nie ma funkcji format() w zakresie
}
---------------
void f(Chrono::Date d, std::string s)
{
    if (d == s) {
        //...
    }
    else if (d == "4 sierpnia 1914") {
        //...
    }
}
---------------
namespace N {
    struct S { int i };
    void f(S);
    void g(S);
    void h(int);
}

struct Base {
    void f(N::S);
};

struct D : Base {
    void mf();

    void g(N::S x)
    {
        f(x);  // wywoanie Base::f()
        mf(x); // wywoanie D::mf()
        h(1);  // bd: funkcja h(int) nie jest dostpna
    }
};
---------------
namespace N {
    template<class T>
        void f(T, int); // N::f()
    class X { };
}

namespace N2 {
    N::X x;

    void f(N::X, unsigned);

    void g()
    {
        f(x,1); // wywoanie N::f(X,int)
    }
}
---------------
namespace A {
    int f(); // dodanie skadowej f() do przestrzeni nazw A
}

namespace A {
    int g(); // teraz przestrze nazw A ma dwie skadowe: f() i g()
}
---------------
// mj nagwek:
    void mf(); // moja funkcja
    void yf(); // twoja funkcja
    int mg();  // moja funkcja
    //...
---------------
// mj nagwek:
    namespace Mine {
        void mf(); // moja funkcja
        //...
    }

    void yf();     // twoja funkcja (jeszcze w adnej przestrzeni nazw)

    namespace Mine {
        int mg();  // moja funkcja
        //...
    }
---------------
namespace Parser {
    double expr(bool);
    double prim(bool get) { /*...*/ }
    double term(bool get) { /*...*/ }
    double expr(bool get) { /*...*/ }
}
---------------
namespace Lexer {
    enum class Kind : char { /*...*/ };
    class Token { /*...*/ };
    class Token_stream { /*...*/ };

    Token_stream ts;
}
---------------
namespace Table {
    map<string,double> table;
}
---------------
namespace Driver {
    void calculate() { /*...*/ }
}
int main() { /*...*/ }
---------------
namespace Error {
    int no_of_errors;
    double error(const string& s) { /*...*/ }
}
---------------
namespace Parser {
    double prim(bool);
    double term(bool);
    double expr(bool);
}

double Parser::prim(bool get) { /*...*/ }
double Parser::term(bool get) { /*...*/ }
double Parser::expr(bool get) { /*...*/ }
---------------
double Parser::prim(bool get) // obsuguje wyraenia pierwotne
{
    if (get) Lexer::ts.g et();

    switch (Lexer::ts.current().kind) {
    case Lexer::Kind::number: // staa zmiennoprzecinkowa
    {   double v = Lexer::ts.current().number_value;
        Lexer::ts.g et();
        return v;
    }
    case Lexer::Kind::name:
    {   double& v = Table::table[Lexer::ts.current().string_value];
        if (Lexer::ts.g et().kind == Lexer::Kind::assign) v = expr(true); // znaleziono =: przypisanie
        return v;
    }
    case Lexer::Kind::minus:  // jednoargumentowy minus
        return -prim(true);
    case Lexer::Kind::lp:
    {   double e = expr(true);
        if (Lexer::ts.current().kind != Lexer::Kind::rp) return Error::error("Oczekiwano ')'");
        Lexer::ts.get(); // zjada ')'
        return e;
    }
    default:
        return Error::error("Oczekiwano wyraenia podstawowego");
    }
}
---------------
using Lexer::ts;      // eliminuje osiem wystpie kwalifikatora Lexer::
using Lexer::Kind;    // eliminuje sze wystpie kwalifikatora Lexer::
using Error::error;   // eliminuje dwa wystpienia kwalifikatora Error ::
using Table::table;   // eliminuje jedno wystpienie kwalifikatora Table::

double prim(bool get) // obsuguje wyraenia podstawowe
{
    if (get) ts.get();

    switch (ts.current().kind) {
    case Kind::number: // staa zmiennoprzecinkowa
    {   double v = ts.current().number_value;
        ts.g et();
        return v;
    }
    case Kind::name:
    {   double& v = table[ts.current().string_value];
        if (ts.get().kind == Kind::assign) v = expr(true); // znaleziono =: przypisanie
        return v;
    }
    case Kind::minus: // jednoargumentowy minus
        return -prim(true);
    case Kind::lp:
    {   double e = expr(true);
        if (ts.current().kind != Kind::rp) return error("Oczekiwano ')'");
        ts.get(); // zjada ')'
        return e;
    }
    default:
        return error("Oczekiwano wyraenia podstawowego");
    }
}
---------------
using namespace Lexer; // eliminuje czternacie wystpie kwalifikatora Lexer::
using namespace Error; // eliminuje dwa wystpienia kwalifikatora Error ::
using namespace Table; // eliminuje jedno wystpienie kwalifikatora Table::

double prim(bool get)  // obsuguje wyraenia podstawowe
{
    // itd.
}
---------------
namespace Parser { // interfejs uytkownika
    double expr(bool);
}
---------------
namespace Parser { // interfejs dla implementatora
    double prim(bool);
    double term(bool);
    double expr(bool);

    using namespace Lexer; // dostp do wszystkich narzdzi dostpnych w lekserze
    using Error::error;
    using Table::table;
}
---------------
namespace Parser {         // interfejs uytkownika
double expr(bool);
}

namespace Parser_impl {    // interfejs implementacyjny
    using namespace Parser;

    double prim(bool);
    double term(bool);
    double expr(bool);

    using namespace Lexer; // dostp do wszystkich narzdzi dostpnych w lekserze
    using Error::error;
    using Table::table;
}
---------------
namespace X {
    int i, j, k;
}

int k;

void f1()
{
    int i = 0;
    using namespace X; // udostpnia nazwy z przestrzeni X
    i++;               // lokalna nazwa i
    j++;               // X::j
    k++;               // bd: chodzi o k z przestrzeni X czy globaln?
    ::k++;             // globalna nazwa k
    X::k++;            // nazwa k z przestrzeni X
}

void f2()
{
    int i = 0;
    using X::i; // bd: nazwa i jest zadeklarowana dwa razy w funkcji f2()
    using X::j;
    using X::k; // zasania globaln nazw k

    i++;
    j++; // X::j
    k++; // X::k
}
---------------
namespace A {// krtka nazwa, kiedy w kocu dojdzie do konfliktu
    //...
}

A::String s1 = "Grieg";
A::String s2 = "Nielsen";
---------------
namespace American_Telephone_and_Telegraph { // za duga
// ...
}

American_Telephone_and_Telegraph::String s3 = "Grieg";
American_Telephone_and_Telegraph::String s4 = "Nielsen";
---------------
// uycie krtkiego aliasu dla dugiej nazwy:

namespace ATT = American_Telephone_and_Telegraph;

ATT::String s3 = "Grieg";
ATT::String s4 = "Nielsen";
---------------
namespace Lib = Foundation_library_v2r11;

//...

Lib::set s;
Lib::String s5 = "Sibelius";
---------------
namespace His_string {
    class String { /*...*/ };
    String operator+(const String&, const String&);
    String operator+(const String&, const char*);
    void fill(char);
    //...
}

namespace Her_vector {
    template<class T>
        class Vector { /*...*/ };
    //...
}

namespace My_lib {
    using namespace His_string;
    using namespace Her_vector;
    void my_fct(String&);
}
---------------
void f()
{
    My_lib::String s = "Byron"; // znajduje My_lib::His_string::String
    // ...
}

using namespace My_lib;

void g(Vector<String>& vs)
{
    // ...
    my_fct(vs[5]);
    // ...
}
---------------
void My_lib::fill(char c)      // bd: nie ma deklaracji funkcji fill() w przestrzeni nazw My_lib
{
    //...
}

void His_string::fill(char c)  // OK: funkcja fill() jest zadeklarowana w przestrzeni nazw His_string
{
    //...
}

void My_lib::my_fct(String& v) // OK: String to My_lib::String, co oznacza His_string::String
{
    //...
}
---------------
namespace His_lib {
    class String { /*...*/ };
    template<class T>
        class Vector { /*...*/ };
    // ...
}

namespace Her_lib {
    template<class T>
        class Vector { /*...*/ };
    class String { /*...*/ };
    // ...
}

namespace My_lib {
    using namespace His_lib; // wszystko z przestrzeni His_lib
    using namespace Her_lib; // wszystko z przestrzeni Her_lib

    using His_lib::String;   // rozwizuje potencjaln kolizj na korzy His_lib
    using Her_lib::Vector;   // rozwizuje potencjaln kolizj na korzy Her_lib

    template<class T>
        class List { /*...*/ }; // dodatkowy kod
    //...
}
---------------
namespace Lib2 {
    using namespace His_lib; // wszystko z przestrzeni nazw His_lib
    using namespace Her_lib; // wszystko z przestrzeni nazw Her_lib

    using His_lib::String;   // rozwizuje potencjaln kolizj na korzy His_lib
    using Her_lib::Vector;   // rozwizuje potencjaln kolizj na korzy Her_lib

    using Her_string = Her_lib::String; // zmiana nazwy
    template<class T>
        using His_vec = His_lib::Vector<T>; // zmiana nazwy

    template<class T>
        class List { /*...*/ }; // dodatkowy kod
    //...
}
---------------
// stara wersja A.h:
    void f(int);
    //...

// stara wersja B.h:
    void f(char);
    //...

// stara wersja user.c:
    #include "A.h"
    #include "B.h"

    void g()
    {
        f('a'); // wywouje f() z B.h
    }
---------------
// nowa wersja A.h:

    namespace A {
        void f(int);
    //...
}

// nowa wersja B.h:

    namespace B {
        void f(char);
        //...
    }

// nowa wersja user.c:

    #include "A.h"
    #include "B.h"

    using namespace A;
    using namespace B;

    void g()
    {
        f('a'); // wywouje f() z B.h
    }
---------------
sort(v.begin(),v.end());
---------------
sort(v);
---------------
#include<algorithm>

namespace Estd {
    using namespace std;
    template<class C>
        void sort(C& c) { std::sort(c.begin(),c.end()); }
    template<class C, class P>
        void sort(C& c, P p) { std::sort(c.begin(),c.end(),p); }
}
---------------
using namespace Estd;

template<class T>
void print(const vector<T>& v)
{
    for (auto& x : v)
        cout << v << ' ';
    cout << '\n';
}

void f()
{
    std::vector<int> v {7, 3, 9, 4, 0, 1};

    sort(v);
    print(v);
    sort(v,[](int x, int y) { return x>y; });
    print(v);
    sort(v.begin(),v.end());
    print(v);
    sort(v.begin(),v.end(),[](int x, int y) { return x>y; });
    print(v);
}
---------------
0 1 3 4 7 9
9 7 4 3 1 0
0 1 3 4 7 9
9 7 4 3 1 0
---------------
namespace Popular {

    inline namespace V3_2 { // V3_2 jest domyln wersj przestrzeni Popular
        double f(double);
        int f(int);
        template<class T>
            class C { /*...*/ };
    }

    namespace V3_0 {
        //...
    }
    namespace V2_4_2 {
        double f(double);
        template<class T>
            class C { /*...*/ };
    }
}
---------------
using namespace Popular;

void f()
{
    f(1);         // Popular::V3_2::f(int)
    V3_0::f(1);   // Popular::V3_0::f(double)
    V2_4_2::f(1); // Popular::V2_4_2::f(double)
}

template<class T>
Popular::C<T*>{ /*...*/ };
---------------
// plik V3_common:
    //... duo deklaracji...

// plik V3_2:

    namespace V3_2 { // V3_2 jest domyln wersj dla przestrzeni Popular
        double f(double);
        int f(int);
        template<class T>
            class C { /*...*/ };
        #include "V3_common"
    }

// plik V3_0.h:

    namespace V3_0 {
        #include "V3_common"
    }

// plik Popular.h:

    namespace Popular {
        inline
        #include "V3_2.h"
        #include "V3_0.h"
        #include "V2_4_2.h"
    }
---------------
namespace X {
    //... wszystkie moje deklaracje...
}
---------------
void h();

namespace X {
    void g();
    //...
    namespace Y {
        void f();
        void ff();
        //...
    }
}
---------------
void X::Y::ff()
{
    f(); g(); h();
}

void X::g()
{
    f();    // bd: nie ma f() w X
    Y::f(); // OK
}

void h()
{
    f();       // bd: nie ma globalnej nazwy f()
    Y::f();    // bd: nie ma globalnej Y
    X::f();    // bd: nie ma f() w X
    X::Y::f(); // OK
}
---------------
#include "header.h"
namespace Mine {
    int a;
    void f() { /*...*/ }
    int g() { /*...*/ }
}
---------------
#include "header.h"
namespace {
    int a;
    void f() { /*...*/ }
    int g() { /*...*/ }
}
---------------
namespace $$$ {
    int a;
    void f() { /*...*/ }
    int g() { /*...*/ }
}
using namespace $$$;
---------------
#include <stdio.h>

int main()
{
    printf("Witaj, wiecie!\n");
}
---------------
// cstdio:

    namespace std {
        int printf(const char*... );
    //...
}
---------------
// stdio.h:
    #include<cstdio>
    using namespace std;
---------------
#include<vector>  // ostronie unikamy zamiecenia globalnej przestrzeni nazw
vector v1;        // bd: brak nazwy vector w zakresie globalnym
#include<stdio.h> // zawiera using namespace std;
vector v2;        // ups: to teraz zadziaa
---------------
// 
stdio.h:
    #include<cstdio>
    using std::printf;
    //...