メンバアクセス演算子

被演算子のメンバにアクセスします。

[編集] 説明

組み込みの添字演算子はポインタまたは配列の被演算子が指す先のオブジェクトへのアクセスを提供します。

組み込みの間接参照演算子はポインタの被演算子が指す先のポインタまたは関数へのアクセスを提供します。

組み込みのアドレス取得演算子はオブジェクトまたは関数の被演算子を指すポインタを作成します。

オブジェクトのメンバおよびオブジェクトのメンバへのポインタ演算子はオブジェクトの被演算子のデータメンバまたはメンバ関数へのアクセスを提供します。

組み込みのポインタのメンバおよびポインタのメンバへのポインタ演算子はポインタの被演算子が指す先のクラスのデータメンバまたはメンバ関数へのアクセスを提供します。

[編集] 組み込みの添字演算子

添字演算子式は以下の形式を持ちます。

組み込みの添字式 E1[E2] は評価順序を除いて (C++17以上)式 *(E1 + E2) と正確に同一です。 つまり、そのポインタの被演算子 (配列からポインタへの変換の結果かもしれません) (何らかの配列の要素またはその最後の次を指していなければなりません) はポインタ算術のルールに従って同じ配列の別の要素を指すように調節され、そして逆参照されます。

配列に適用したとき、添字式は lvalue (その配列が lvalue の場合) または xvalue (そうでない場合) (C++11以上) です。

ポインタに適用したとき、添字式は常に lvalue です。

たとえ &x[0] のようにサイズや内部構造が使用されなくとも、型 T は不完全型であることは許されていません。

ユーザ定義に演算子に対するオーバーロード解決において、すべてのオブジェクト型 (およびその cv 修飾された型) T について、以下の関数シグネチャがオーバーロード解決に参加します。

#include <iostream>
 
int main()
{
    int a[4] = {1, 2, 3, 4};
    int* p = &a[2];
    std::cout << p[1] << p[-1] << 1[p] << (-1)[p] << '\n';
}

4242

[編集] 組み込みの間接参照演算子

間接参照演算子式は以下の形式を持ちます。

組み込みの間接参照演算子の被演算子はオブジェクトへのポインタまたは関数へのポインタでなければならず、結果は expr が指す先のポインタまたは関数を参照する lvalue です。

void (または cv 修飾された void) へのポインタは逆参照できません。 それ以外の不完全型へのポインタは逆参照できますが、結果の lvalue は不完全型の lvalue が許容される文脈 (参照を初期化するときなど) でのみ使用できます。

ユーザ定義の演算子に対するオーバーロード解決において、オブジェクト型 (またはその cv 修飾された型) または関数型 (const 修飾も ref 修飾もされていない) であるすべての型 T について、以下の関数シグネチャがオーバーロード解決に参加します。

#include <iostream>
 
int f() { return 42; }
 
int main()
{
    int n = 1;
    int* pn = &n;
 
    int& r = *pn;  // 左辺値は参照に束縛できます
    int m = *pn;   // 間接参照+左辺値から右辺値への変換
 
    int (*fp)() = &f;
    int (&fr)() = *fp; // 関数左辺値は参照に束縛できます
}

[編集] 組み込みのアドレス取得演算子

アドレス取得演算子式は以下の形式を持ちます。

ユーザ定義の演算子に対するオーバーロード解決において、この演算子はいかなる追加の関数シグネチャも導入しません。 適用可能なオーバーロードされた operator& が存在する場合、組み込みのアドレス取得演算子は適用されません。

void f(int) {}
void f(double) {}
struct A { int i; };
struct B { void f(); };
 
int main()
{
    int n = 1;
    int* pn = &n; // ポインタ
    int* pn2 = &*pn; // pn2 == pn
    int A::* mp = &A::i; // データメンバへのポインタ
    void (B::*mpf)() = &B::f; // メンバ関数へのポインタ
 
    void (*pf)(int) = &f; // 初期化の文脈によるオーバーロード解決
//  auto pf2 = &f; // エラー、オーバーロードされた関数の曖昧な型
    auto pf2 = static_cast<void (*)(int)>(&f); // キャストによるオーバーロード解決
}

[編集] 組み込みのメンバアクセス演算子

メンバアクセス演算子式は以下の形式を持ちます。

どちらの演算子も1つめの被演算子はたとえ必要でなくとも評価されます (2つめの被演算子が静的メンバを表すときなど)。

どちらの演算子も2つめの被演算子は T の、または T の曖昧でないアクセス可能な基底クラス B の、データメンバまたはメンバ関数の名前 (形式的には、それらを表す識別子式) です (E1.E2 や E1->E2 など)。 修飾付きであったり (E1.B::E2 や E1->B::E2 など)、template 曖昧性解消子を使用することもあります (E1.template E2 や E1->template E2 など)。

ユーザ定義の operator-> が提供される場合、プレーンなポインタを返す operator-> に到達するまで、その戻り値に対して operator-> が再び、再帰的に呼ばれます。

式 E1->E2 は組み込み型については (*E1).E2 と正確に同等です。 そのため以下のルールでは E1.E2 についてのみ述べます。

式 E1.E2 において、

operator. はオーバーロードできません。 operator-> については、ユーザ定義の演算子に対するオーバーロード解決において、組み込みの演算子はいかなる追加の関数シグネチャも導入しません。 適用可能なオーバーロードされた operator-> が存在する場合、組み込みの operator-> は適用されません。

#include <iostream>
 
struct P
{
    template<typename T>
    static T* ptr() { return new T; }
};
 
template<typename T>
struct A
{
    A(int n): n(n) {}
    int n;
    static int sn;
    int f() { return 10 + n; }
    static int sf() { return 4; }
    class B {};
    enum E {RED = 1, BLUE = 2};
 
    void g()
    {
        typedef int U;
        // 依存テンプレートメンバのためキーワード template が必要です
        int* p = T().template ptr<U>();
        p->~U(); // U は int であり、 int の疑似デストラクタを呼びます
        delete p;
    }
};
template<> int A<P>::sn = 2;
 
int main()
{
    A<P> a(1);
    std::cout << a.n << ' '
              << a.sn << ' '   // a.A::sn でも構いません
              << a.f() << ' ' 
              << a.sf() << ' ' // a.A::sf() でも構いません
//            << a.B << ' '    // エラー、ネストした型は使用できません
              << a.RED << ' '; // 列挙子
}

1 2 11 4 1

[編集] 組み込みのメンバポインタアクセス演算子

メンバへのポインタを通したメンバアクセス演算子式は以下の形式を持ちます。

どちらの演算子も2つめの被演算子は T のメンバ (データメンバまたはメンバ関数) へのポインタ型または T の曖昧でないアクセス可能な基底クラス B のメンバへのポインタ型の式です。

式 E1->*E2 は組み込み型の場合 (*E1).*E2 と正確に同等です。 このため以下のルールでは E1.*E2 についてのみ述べます。

式 E1.*E2 において、

ユーザ定義の演算子に対するオーバーロード解決において、クラス型 B が D と同じクラスであるか D の曖昧でなくアクセス可能な基底クラスであり、 R がオブジェクト型または関数型であるような、型 D、 B、 R のすべての組み合わせについて、以下の関数シグネチャがオーバーロード解決に参加します。

ただし、どちらの被演算子も cv 修飾されていても良く、その場合、戻り値の型の cv 修飾は被演算子の cv 修飾の和です。

#include <iostream>
 
struct S
{
    S(int n): mi(n) {}
    mutable int mi;
    int f(int n) { return mi + n; }
};
 
struct D: public S
{
    D(int n): S(n) {}
};
 
int main()
{
    int S::* pmi = &S::mi;
    int (S::* pf)(int) = &S::f;
 
    const S s(7);
//  s.*pmi = 10; // エラー、 mutable を通して変更することはできません
    std::cout << s.*pmi << '\n';
 
    D d(7); // 基底クラスのポインタを派生オブジェクトで使用できます
    D* pd = &d;
    std::cout << (d.*pf)(7) << ' '
              << (pd->*pf)(8) << '\n';
}

7
14 15

[編集] 標準ライブラリ

添字演算子は多くの標準のコンテナクラスでオーバーロードされています。

間接参照およびメンバ演算子は多くのイテレータやスマートポインタクラスでオーバーロードされています。

operator& をオーバーロードする標準ライブラリのクラスはありません。 operator& のオーバーロードの最も知られている例は Microsoft COM のクラス CComPtr です。 また boost.spirit などの EDSL でも見ることができます。

operator->* をオーバーロードする標準ライブラリのクラスはありません。 スマートポインタのインタフェースの一部となることが提案され、実際 boost.phoenix のアクタによってその用途で使用されていますが、 cpp.react などの EDSL で使用される方がより一般的です。

[編集] 欠陥報告

以下の動作変更欠陥報告は以前に発行された C++ 標準に遡って適用されました。

[編集] 関連項目

演算子の優先順位

演算子オーバーロード