Область видимости

int main()
{
    int a = 0; // начинается область видимости первой 'a'
    ++a; // имя 'a' находится в области видимости и ссылается на первую 'a'
    {
        int a = 1; // начинается область видимости второй 'a'
                   // область видимости первой 'a' прервана
        a = 42;    // 'a' входит в область видимости и ссылается на вторую 'a'                 
    } // блок заканчивается, область видимости второй 'a' заканчивается
      //             область видимости первой 'a' восстанавливается
} // блок заканчивается, область видимости первой 'a' заканчивается
int b = a; // Ошибка: имя 'a' вне области видимости

try {   
    f();
} catch(const std::runtime_error& re) { // начинается область видимости re
    int n = 1; // начинается область видимости n
    std::cout << re.what(); // re находится в области видимости
} // область видимости re заканчивается, область видимости n заканчивается
 catch(std::exception& e) {
    std::cout << re.what(); // ошибка: re находится вне области видимости
    ++n; // ошибка: n находится вне области видимости
}

Base* bp = new Derived;
if(Derived* dp = dynamic_cast<Derived*>(bp))
{
    dp->f(); // dp входит в область видимости
} // область видимости dp заканчивается
        
for(int n = 0; // область видимости n начинается
    n < 10;    // n в области видимости
    ++n)       // n в области видимости
{
    std::cout << n << ' '; // n в области видимости
} // область видимости n заканчивается

const int n = 3;

int f1(int n,     // область видимости глобальной 'n' прервана,
                  // область видимости параметра 'n' начинается
       int y = n); // ошибка: аргумент по умолчанию ссылается на параметр

int (*(*f2)(int n))[n]; // OK: область видимости параметра функции 'n'
                        // заканчивается в конце декларатора своей функции
                        // в деклараторе массива, глобальная n находится в области
// видимости (это объявление указателя на функцию, возвращающую указатель на массив
// из 3-х int)

// напротив
auto (*f3)(int n)->int (*)[n]; // ошибка: параметр 'n' как граница массива


int f(int n = 2)  // область видимости 'n' начинается
try // блок try функции
{         // тело функции начинается
   ++n;   // 'n' находится в области видимости и ссылается на параметр функции
   {
      int n = 2; // область видимости локальной переменной 'n' начинается
                 // область видимости параметра функции 'n' прервана 
      ++n; // 'n' ссылается на локальную переменную в этом блоке
    }            // область видимости локальной переменной 'n' прервана
                 // область видимости параметра функции 'n' возобновляется
} catch(...) {
   ++n; // n находится в области видимости и ссылается на параметр функции
   throw;
} // последний обработчик исключений заканчивается, область видимости параметра
  // функции 'n' заканчивается
int a = n; // OK: глобальная 'n' находится в области видимости

void f()
{
   {   
       goto label; // метка в области видимости, даже если объявлена позже
label:;
   }
   goto label; // метка игнорирует область видимости блока
}

void g()
{
    goto label; // ошибка: метка не входит в область видимости g()
}

namespace N { // область видимости N начинается (как элемент глобального пространства имён)
    int i; // область видимости i начинается
    int g(int a) { return a; } // область видимости g начинается
    int j(); // область видимости j начинается
    void q(); // область видимости q начинается
    namespace {
        int x; // область видимости x начинается
    } // область видимости x не заканчивается
    inline namespace inl { // область видимости inl начинается
      int y; // область видимости y начинается
    } // область видимости y не заканчивается
} // область видимости i,g,j,q,inl,x,y прервана

namespace {
    int l=1; // область видимости l начинается
} // область видимости l не заканчивается (это элемент безымянного пространства имён)

namespace N { // область видимости i,g,j,q,inl,x,y продолжается
    int g(char a) {  // перегружает N::g(int)
        return l+a;  // l из безымянного пространства имён входит в область видимости
    }
    int i; // ошибка: повторяющееся определение (i уже входит в область видимости)
    int j(); // OK: повторное объявления функции разрешено
    int j() { // OK: определение ранее объявленной N::j()
        return g(i); // вызов N::g(int)
    }
    int q(); // ошибка: q уже находится в области с другим возвращаемым типом
} // область видимости i,g,j,q,inl,x,y прервана

int main() {
    using namespace N; // область видимости i,g,j,q,inl,x,y возобновляется
    i = 1; // N::i входит в область видимости
    x = 1; // N::(анонимная)::x входит в область видимости
    y = 1; // N::inl::y входит в область видимости
    inl::y = 2; // N::inl также входит в область видимости
} // область видимости i,g,j,q,inl,x,y прервана

class X {
    int f(int a = n) { // X::n находится в области видимости внутри параметра по умолчанию
         return a*n;   // X::n находится в области видимости внутри тела функции
    }
    using r = int;
    r g();
    int i = n*2;   // X::n находится в области видимости внутри инициализатора

//  int x[n];      // Ошибка: n не входит в область видимости тела класса
    static const int n = 1;
    int x[n];      // OK: n теперь находится в области видимости тела класса
};

//r X::g() {       // Ошибка: r не входит в область видимости тела функции-элемента
                   // вне класса
auto X::g()->r {   // OK: конечный возвращаемый тип X::r находится в области видимости
    return n;      // X::n находится в области видимости тела функции-элемента вне класса
}

typedef int c; // ::c
enum { i = 1 }; // ::i
class X {
    char v[i]; // Ошибка: в этой точке, i ссылается на ::i,
               // но есть ещё X::i
    int f() {
         return sizeof(c); // OK: X::c, не ::c находится в области видимости внутри функции-элемента
    }
    char c; // X::c
    enum { i = 2 }; // X::i
};

typedef char* T;
struct Y {
    T a; // Ошибка: в этой точке, T ссылается на ::T,
         // но есть также Y::T
    typedef long T;
    T b;
};

enum e1_t { // перечисление без области видимости
  A,
  B = A*2
}; // область видимости A и B не заканчивается

enum class e2_t { // перечисление с областью видимости
    SA,
    SB = SA*2 // SA находится в области видимости
}; // область видимости SA и SB заканчивается

e1_t e1 = B; // OK, B находится в области видимости
// e2_t e2 = SB; // Ошибка: SB не находится в области видимости
e2_t e2 = e2_t::SB; // OK

template< typename T, // область видимости T начинается
          T* p,       // T может использоваться для параметра, не являющегося типом
          class U = T // T может использоваться для типа по умолчанию
        >
class X : public Array<T> // T может использоваться в имени базового класса
{
   // T можно использовать и внутри тела
}; // область видимости T и U закончилась, область видимости X продолжается

template< template< // шаблонный параметр шаблона
                    typename Y,     // область видимости Y начинается
                    typename G = Y // Y находится в области видимости
                  > // область видимости Y и G закончилась
          class T,
//          typename U = Y // Ошибка: Y находится вне области видимости
          typename U
        >
class X
{
}; // область видимости T и U закончилась

typedef int N;
template< N X, // параметр не тип типа int
          typename N, // область видимости этого N начинается, область видимости
                      // ::N прервана
          template<N Y> class T // N здесь параметр шаблона, а не int
         > struct A;

int x = 32; // внешний x находится в области видимости
{
    int x = x; // внутренний x находится в области видимости до инициализатора (= x)
               // при этом внутренний x не инициализируется значением внешнего x (32),
               // при этом внутренний x инициализируется собственным (неопределённым)
               // значением
}
std::function<int(int)> f = [&](int n){return n>1 ? n*f(n-1) : n;};
           // имя функции 'f' находится в области видимости лямбда и
           // может быть правильно захвачено по ссылке, делая вызов функции рекурсивным

const int x = 2; // область видимости первого 'x' начинается
{
    int x[x] = {}; // область видимости второго x начинается до инициализатора (= {}),
                   // но после декларатора (x[x]). Внутри декларатора внешний
                   // 'x' всё ещё в области видимости. Это объявляет массив из 2-х int.
}

// S находится в области видимости через двоеточие
struct S: std::enable_shared_from_this<S> {};

enum E : int { // E уже в области видимости
    A = sizeof(E)
};

using T = int; // точка объявления T находится в точке с запятой
using T = T;   // то же, что и T = int

template<int N>
class base {
protected:
    static const int next = N + 1;
    static const int value = N;
};

struct derived : base<0>, base<1>, base<2> {
    using base<0>::next, // next теперь в области видимости
          base<next>::value; // derived::value равно 1
};

const int x = 12;
{
    enum { x = x + 1, // точка объявления находится в запятой, x инициализируется
                      // значением 13
           y = x + 1  // перечислитель x теперь находится в области видимости,
                      // y инициализируется значением 14
         };
}

template<typename T>
struct Array
// : std::enable_shared_from_this<Array> // Ошибка: имя внедрённого класса не входит в
                                         // область видимости
   : std::enable_shared_from_this< Array<T> > //OK: имя шаблона Array находится в
                                              // области видимости
{ // внедрённое имя класса Array теперь находится в области видимости, как если бы имя
  // открытого элемента
    Array* p; // указатель на Array<T>
};

typedef unsigned char T;
template<class T
  = T               // поиск находит имя typedef unsigned char
  , T               // поиск находит параметр шаблона
    N = 0> struct A { };