Member access operators

피연산자의 멤버에 접근합니다.

설명

내장 첨자 연산자는 pointer 또는 array 피연산자가 가리키는 객체에 대한 접근을 제공합니다.

내장 간접 참조(indirection) 연산자는 포인터 피연산자가 가리키는 객체나 함수에 대한 접근을 제공합니다.

내장 address-of 연산자는 객체나 함수 피연산자를 가리키는 포인터를 생성합니다.

객체의 멤버 와 객체의 멤버에 대한 포인터 연산자는 객체 피연산자의 데이터 멤버나 멤버 함수에 대한 접근을 제공합니다.

내장 멤버 포인터 및 멤버 포인터에 대한 포인터 연산자는 포인터 피연산자가 가리키는 클래스의 데이터 멤버 또는 멤버 함수에 대한 접근을 제공합니다.

내장 첨자 연산자

첨자 연산자 표현식의 형식은 다음과 같습니다

내장 첨자 표현식 E1 [ E2 ] 는 값 범주(아래 참조) 및 평가 순서 (C++17부터) 를 제외하고 표현식 * ( E1 + E2 ) 와 완전히 동일합니다: 포인터 피연산자(배열-포인터 변환의 결과일 수 있으며, 어떤 배열의 요소나 끝의 다음을 가리켜야 함)는 포인터 연산 규칙에 따라 동일한 배열의 다른 요소를 가리키도록 조정된 후 역참조됩니다.

배열에 적용될 때, 첨자 표현식은 lvalue 입니다(배열이 lvalue인 경우). 배열이 lvalue가 아닌 경우 xvalue 입니다 (C++11부터) .

포인터에 적용될 때, 첨자 표현식은 항상 lvalue입니다.

타입 T 는 incomplete type 이어서는 안 되며, 이는 & x [ 0 ] 와 같이 T 의 크기나 내부 구조가 사용되지 않는 경우에도 마찬가지입니다.

사용자 정의 연산자에 대한 오버로드 해결 에서, 모든 객체 타입 T (cv-qualified 가능)에 대해 다음 함수 시그니처가 오버로드 해결에 참여합니다:

#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"; // [{...}] 버전 사용
}

4242

내장 역참조 연산자

간접 연산자 표현식의 형식은 다음과 같습니다

내장 역참조 연산자의 피연산자는 객체에 대한 포인터 또는 함수에 대한 포인터여야 하며, 결과는 expr 가 가리키는 객체나 함수를 참조하는 lvalue입니다. 만약 expr 이 실제로 객체나 함수를 가리키지 않는 경우, 동작은 정의되지 않습니다( typeid 에 의해 지정된 경우 제외).

( cv 한정자가 있을 수 있는) void 에 대한 포인터는 역참조할 수 없습니다. 다른 불완전한 타입에 대한 포인터는 역참조할 수 있지만, 결과로 나오는 lvalue는 불완전한 타입의 lvalue를 허용하는 상황에서만 사용할 수 있습니다. 예를 들어 참조를 초기화할 때와 같습니다.

사용자 정의 연산자에 대한 오버로드 해결 에서, 객체 타입(possibly cv-qualified)이거나 함수 타입(not const- or ref-qualified)인 모든 타입 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;
        // keyword template needed for a dependent template member
        int* p = T().template ptr<U>();
        p->~U(); // U is int, calls int's pseudo destructor
        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 also works
              << a.f() << ' ' 
              << a.sf() << ' ' // A::sf() also works
//            << &a.f << ' '   // error: ill-formed if a.f is not the
                               // left-hand operand of operator()
//            << a.B << ' '    // error: nested type not allowed
              << a.RED << ' '; // enumerator
    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;      // 정상, 객체 표현식이 d의 B 서브객체를 지정함
    reinterpret_cast<B&>(d).j; // 정의되지 않은 동작
}

내장 포인터-대-멤버 접근 연산자

멤버 접근 연산자 표현식은 멤버에 대한 포인터를 통한 다음과 같은 형식을 가집니다.

rhs 는 T 의 멤버 포인터( 데이터 또는 함수 ) 타입의 rvalue이거나, T 의 명확하고 접근 가능한 기본 클래스 B 의 멤버 포인터여야 합니다.

표현식 E1 - > * E2 는 내장 타입에 대해 ( * E1 ) . * E2 와 정확히 동일합니다. 따라서 다음 규칙들은 E1. * E2 만을 다룹니다.

표현식 E1. * E2 에서:

사용자 정의 연산자에 대한 오버로드 해결 에서, 클래스 타입 B 가 D 와 동일한 클래스이거나 D 의 명확하고 접근 가능한 기본 클래스이며, R 이 객체 또는 함수 타입인 모든 타입 조합 D , B , R 에 대해 다음 함수 시그니처가 오버로드 해결에 참여합니다:

두 피연산자가 모두 cv 한정자(cv-qualified)일 수 있으며, 이 경우 반환 타입의 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++ 표준에 소급 적용되었습니다.

참고 항목

연산자 우선순위

연산자 오버로딩