Member access operators

そのオペランドのメンバーにアクセスします。

説明

組み込みの 添字演算子 は、 pointer または array オペランドによって指されるオブジェクトへのアクセスを提供します。

組み込みの 間接参照 演算子は、ポインタオペランドが指すオブジェクトまたは関数へのアクセスを提供します。

組み込みの address-of 演算子は、オブジェクトまたは関数オペランドを指すポインタを作成します。

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

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

組み込み添字演算子

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

組み込みの添字式 E1 [ E2 ] は、その値カテゴリ（下記参照） および 評価順序 (C++17以降) を除き、式 * ( E1 + E2 ) と完全に同一です：ポインタオペランド（配列からポインタへの変換の結果である可能性があり、何らかの配列の要素または末尾の次を指していなければならない）は、 ポインタ算術 の規則に従って同じ配列の別の要素を指すように調整され、その後デリファレンスされます。

配列に適用される場合、添字式は lvalue 配列がlvalueの場合はlvalueとなり、そうでない場合は xvalue となる (C++11以降) 。

ポインタに適用される場合、添字式は常に左辺値です。

型 T は、 incomplete type であってはなりません。たとえ T のサイズや内部構造が & x [ 0 ] のように使用されない場合でも同様です。

ユーザー定義演算子に対するオーバーロード解決 において、あらゆるオブジェクト型 T （CV修飾されている可能性あり）に対して、以下の関数シグネチャがオーバーロード解決に参加します：

#include <iostream>
#include <map>
#include <string>
int main()
{
    int a[4] = {1, 2, 3, 4};
    int* p = &a[2];
    std::cout << p[1] << p[-1] << 1[p] << (-1)[p] << '\n';
    std::map<std::pair<int, int>, std::string> m;
    m[{1, 2}] = "abc"; // uses the [{...}] version
}

4242

組み込み間接演算子

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

組み込みの間接参照演算子のオペランドは、オブジェクトへのポインタまたは関数へのポインタでなければならず、結果は expr が指すオブジェクトまたは関数を参照する左辺値です。 expr が実際にオブジェクトまたは関数を指していない場合、動作は未定義です（ typeid で指定される場合を除く）。

（ cv 修飾される可能性のある） void へのポインタは間接参照できません。他の不完全型へのポインタは間接参照できますが、結果の左辺値は不完全型の左辺値が許可される文脈（例えば参照の初期化時）でのみ使用できます。

ユーザー定義演算子に対するオーバーロード解決 において、オブジェクト型（CV修飾可能性あり）または関数型（const修飾および参照修飾なし）であるすべての型 T について、以下の関数シグネチャがオーバーロード解決に参加します：

#include <iostream>
int f() { return 42; }
int main()
{
    int n = 1;
    int* pn = &n;
    int& r = *pn; // lvalueは参照に束縛可能
    int m = *pn;  // 間接参照 + lvalue-to-rvalue変換
    int (*fp)() = &f;
    int (&fr)() = *fp; // 関数lvalueは参照に束縛可能
    [](...){}(r, m, fr); // 未使用変数警告を抑制
}

組み込みアドレス取得演算子

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

ユーザー定義演算子に対するオーバーロード解決 において、この演算子は追加の関数シグネチャを導入しません：組み込みのアドレス取得演算子は、有効な関数であるオーバーロードされた 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); // キャストによるオーバーロード解決
}

組み込みメンバーアクセス演算子

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

id-expr は、 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 <cassert>
#include <iostream>
#include <memory>
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;
struct UPtrWrapper
{
    std::unique_ptr<std::string> uPtr;
    std::unique_ptr<std::string>& operator->() { return uPtr; }
};
int main()
{
    A<P> a(1);
    std::cout << a.n << ' '
              << a.sn << ' '   // A::snも有効
              << a.f() << ' ' 
              << a.sf() << ' ' // A::sf()も有効
//            << &a.f << ' '   // エラー: a.fがoperator()の左辺オペランドでない場合、不正な形式
                               // 
//            << a.B << ' '    // エラー: ネストされた型は許可されていない
              << a.RED << ' '; // 列挙子
    UPtrWrapper uPtrWrap{std::make_unique<std::string>("wrapped")};
    assert(uPtrWrap->data() == uPtrWrap.operator->().operator->()->data());
}

1 2 11 4 1

E2 が非静的メンバーであり、かつ E1 の結果が similar でない型を持つオブジェクトである場合、動作は未定義です：

struct A { int i; };
struct B { int j; };
struct D : A, B {};
void f()
{
    D d;
    static_cast<B&>(d).j;      // OK、オブジェクト式はdのBサブオブジェクトを指定する
    reinterpret_cast<B&>(d).j; // 未定義動作
}

組み込みポインタ-メンバアクセス演算子

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

rhs は、 T のメンバへのポインタ（ data または function ）のrvalue、または T の明確でアクセス可能な基底クラス B のメンバへのポインタのrvalueでなければなりません。

式 E1 - > * E2 は組み込み型に対して ( * E1 ) . * E2 と完全に等価です。そのため、以下の規則では E1. * E2 のみを扱います。

式 E1. * E2 において：

ユーザー定義演算子に対するオーバーロード解決 において、型 D 、 B 、 R のすべての組み合わせについて、クラス型 B が D と同じクラスであるか、または D の明確でアクセス可能な基底クラスであり、かつ 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; // error: cannot modify through mutable
    std::cout << s.*pmi << '\n';
    D d(7); // base pointers work with derived object
    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++標準に対して遡及的に適用されました。

関連項目

演算子の優先順位

演算子のオーバーロード