ポインタ宣言

struct C {
   int x, y;
} c;
 
int* px = &c.x;   // px の値は「c.x へのポインタ」です。
int* pxe= px + 1; // pxe の値は「c.x の最後の次へのポインタ」です。
int* py = &c.y;   // py の値は「c.y へのポインタ」です。
 
assert(pxe == py); // == は2つのポインタが同じアドレスを表すかどうか判定します。
                   // 成立するかもしれませんし、しないかもしれません。
 
*pxe = 1; // たとえ assert に引っかからなくても未定義動作です。

int n;
int* np = &n; // int へのポインタ。
int* const* npp = &np; // 非 const な int への const なポインタへの非 const なポインタ。
 
int a[2];
int (*ap)[2] = &a; // int の配列へのポインタ。
 
struct S { int n; };
S s = {1};
int* sp = &s.n; // s のメンバである int へのポインタ。

int n;
int* p = &n;     // n へのポインタ。
int& r = *p;     // 参照は n を表す左辺値式に束縛されます。
r = 7;           // n に int の 7 を格納します。
std::cout << *p; // 左辺値から右辺値への暗黙の変換により n から値が読み出されます。

int a[2];
int* p1 = a; // 配列 a の最初の要素 a[0] (int) へのポインタ。
 
int b[6][3][8];
int (*p2)[3][8] = b; // 配列 b の最初の要素 b[0] (int 8個の配列3個の配列) へのポインタ。

struct Base {};
struct Derived : Base {};
 
Derived d;
Base* p = &d;

int n = 1;
int* p1 = &n;
void* pv = p1;
int* p2 = static_cast<int*>(pv);
std::cout << *p2 << '\n'; // 1 を表示します。

void f(int);
void (*p1)(int) = &f;
void (*p2)(int) = f; // &f と同じです。

int f(int n)
{
    std::cout << n << '\n';
    return n * n;
}
 
int main()
{
    int (*p)(int) = f;
    int x = p(7); // f を呼びます。
}

int f();
int (*p)() = f;  // ポインタ p は f を指しています。
int (&r)() = *p; // f を表す左辺値が参照に束縛されます。
r();             // 左辺値参照を通して関数 f が呼ばれます。
(*p)();          // 関数の左辺値を通して関数 f が呼ばれます。
p();             // ポインタを直接通して関数 f が呼ばれます。

template<typename T> T f(T n) { return n; }
double f(double n) { return n; }
 
int main()
{
    int (*p)(int) = f; // f<int> を実体化して選択します。
}

struct C { int m; };
 
int main()
{
    int C::* p = &C::m;          // クラス C のデータメンバ m へのポインタ。
    C c = {7};
    std::cout << c.*p << '\n';   // 7 を表示します。
    C* cp = &c;
    cp->m = 10;
    std::cout << cp->*p << '\n'; // 10 を表示します。
}

struct Base { int m; };
struct Derived : Base {};
 
int main()
{
    int Base::* bp = &Base::m;
    int Derived::* dp = bp;
    Derived d;
    d.m = 1;
    std::cout << d.*dp << ' ' << d.*bp << '\n'; // 1 1 を表示します。
}

struct Base {};
struct Derived : Base { int m; };
 
int main()
{
    int Derived::* dp = &Derived::m;
    int Base::* bp = static_cast<int Base::*>(dp);
 
    Derived d;
    d.m = 7;
    std::cout << d.*bp << '\n'; // OK、 7 を表示します。
 
    Base b;
    std::cout << b.*bp << '\n'; // 未定義動作。
}

struct A
{
    int m;
    // 非 const なメンバへの const なポインタ。
    int A::* const p;
};
 
int main()
{
    // 非 const なメンバへの const なポインタであるデータメンバへの非 const なポインタ。
    int A::* const A::* p1 = &A::p;
 
    const A a = {1, &A::m};
    std::cout << a.*(a.*p1) << '\n'; // 1 を表示します。
 
    // 非 const なメンバへの const なポインタへの非 const な普通のポインタ。
    int A::* const* p2 = &a.p;
    std::cout << a.**p2 << '\n'; // 1 を表示します。
}

struct C
{
    void f(int n) { std::cout << n << '\n'; }
};
 
int main()
{
    void (C::* p)(int) = &C::f; // クラス C のメンバ関数 f へのポインタ。
    C c;
    (c.*p)(1);                  // 1 を表示します。
    C* cp = &c;
    (cp->*p)(2);                // 2 を表示します。
}

struct Base
{
    void f(int n) { std::cout << n << '\n'; }
};
struct Derived : Base {};
 
int main()
{
    void (Base::* bp)(int) = &Base::f;
    void (Derived::* dp)(int) = bp;
    Derived d;
    (d.*dp)(1);
    (d.*bp)(2);
}

struct Base {};
struct Derived : Base
{
    void f(int n) { std::cout << n << '\n'; }
};
 
int main()
{
    void (Derived::* dp)(int) = &Derived::f;
    void (Base::* bp)(int) = static_cast<void (Base::*)(int)>(dp);
 
    Derived d;
    (d.*bp)(1); // OK、 1 を表示します。
 
    Base b;
    (b.*bp)(2); // 未定義動作。
}

// pc は const な int への非 const なポインタです。
// cpc は const な int への const なポインタです。
// ppc は const な int への非 const なポインタへの非 const なポインタです。
const int ci = 10, *pc = &ci, *const cpc = pc, **ppc;
// p は非 const な int への非 const なポインタです。
// cp は非 const な int への const なポインタです。
int i, *p, *const cp = &i;
 
i = ci;    // OK、const な int の値が非 const な int にコピーされます。
*cp = ci;  // OK、非 const な int (const なポインタによって指されている) は変更できます。
pc++;      // OK、非 const なポインタ (const な int を指している) は変更できます。
pc = cpc;  // OK、非 const なポインタ (const な int を指している) は変更できます。
pc = p;    // OK、非 const なポインタ (const な int を指している) は変更できます。
ppc = &pc; // OK、const な int へのポインタのアドレスは const な int へのポインタへのポインタです。
 
ci = 1;    // エラー、const な int は変更できません。
ci++;      // エラー、const な int は変更できません。
*pc = 2;   // エラー、const な int (非 const なポインタによって指されている) は変更できません。
cp = &ci;  // エラー、const なポインタ (非 const な int を指している) は変更できません。
cpc++;     // エラー、const なポインタ (const な int を指している) は変更できません。
p = pc;    // エラー、非 const な int へのポインタは const な int を指すことはできません。
ppc = &p;  // エラー、const な int へのポインタへのポインタは
           // 非 const な int へのポインタを指すことはできません。