作用域

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 在作用域中
// （这声明了返回 int 的 3 元素数组的指针的函数的指针）
 
// 相反
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 在作用域中，尽管之后才声明
label:;
   }
   goto label; // label 忽略块作用域
}
 
void g()
{
    goto label; // 错误： g() 中 label 不在作用域中
}

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;

unsigned char x = 32; // 第一个 'x' 的作用域开始
{
    unsigned char x = x; // 第二个 'x' 的作用域在初始化器 (= x) 前开始
                         // 这不以值 32 初始化第二个 'x' ，
                         // 这以其自身的不确定值初始化第二个 'x'
}
std::function<int(int)> f = [&](int n){return n>1 ? n*f(n-1) : n;};
           // 函数对象名 'f' 在 lambda 中在作用域中，
           // 而且能正确地被按引用俘获，给出递归函数

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

const int x = 12;
{
    enum {
        x = x + 1, // 声明点在逗号处，初始化 x 为 13
        y = x + 1  // 枚举项 x 在作用域中，初始化 y 为 14
    };
}

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
};

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               // 查找找到 unsigned char 的 typedef 名
  , T               // 查找找到模板形参
    N = 0> struct A { };