スコープ

int main()
{
    int a = 0; // 1つめの「a」のスコープが始まります。
    ++a; // 名前「a」はスコープ内であり、1つめの「a」を参照します。
    {
        int a = 1; // 2つめの「a」のスコープが始まります。
                   // 1つめの「a」のスコープは中断されます。
        a = 42;    // 「a」はスコープ内であり、2つめの「a」を参照します。
    } // ブロックの終わり。 2つめの「a」のスコープが終わります。
      //                    1つめの「a」のスコープが再開されます。
} // ブロックの終わり。 1つめの「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; // ラベルはブロックスコープを無視します。
}
 
void g()
{
    goto label; // エラー、 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 のスコープは終わりません (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 メンバ関数の内側では ::c ではなく X::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; // 1つめの「x」のスコープが始まります。
{
    unsigned char x = x; // 2つめの「x」のスコープは初期化子 (= x) の前で始まります。
                         // これは2つめの「x」を値32で初期化しません。
                         // これは2つめの「x」を自分自身の (不定な) 値で初期化します。
}
 
std::function<int(int)> f = [&](int n){return n>1 ? n*f(n-1) : n;};
           // 関数「f」の名前はラムダの中でスコープ内であり、
           // 正しく参照でキャプチャでき、再帰関数を与えます。

const int x = 2; // 1つめの「x」のスコープが始まります。
{
    int x[x] = {}; // 2つめの x のスコープは初期化子 (= {}) の前かつ宣言子 (x[x]) の後で
                   // 始まります。 宣言子内では外側の「x」が未だスコープ内です。
                   // この宣言は int 2個の配列を宣言します。
}

// 名前「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<typename T>
struct Array
// : std::enable_shared_from_this<Array> // エラー、注入されたクラス名はスコープ内ではありません。
   : std::enable_shared_from_this< Array<T> > // OK、テンプレート名 Array はスコープ内です。
{ // 注入されたクラス名 Array はここからパブリックメンバ名であるかのようにスコープ内になります。
    Array* p; // Array<T> へのポインタ。
};