Member access operators

Accede a un miembro de su operando.

Explicación

El operador de subíndice incorporado proporciona acceso al objeto apuntado por el operando puntero o array .

El operador de indirección incorporado proporciona acceso a un objeto o función apuntado por el operando puntero.

Operador incorporado de dirección-de crea un puntero que apunta al objeto o función operando.

Operador de miembro de objeto y operador de puntero a miembro de objeto proporcionan acceso a un miembro de datos o función miembro del operando objeto.

Los operadores integrados miembro de puntero y puntero a miembro de puntero proporcionan acceso a un miembro de datos o función miembro de la clase apuntada por el operando puntero.

Operador de subíndice incorporado

Las expresiones del operador de subíndice tienen la forma

La expresión de subíndice incorporada E1 [ E2 ] es exactamente idéntica a la expresión * ( E1 + E2 ) excepto por su categoría de valor (ver más abajo) y el orden de evaluación (desde C++17) : el operando puntero (que puede ser resultado de una conversión de array a puntero, y debe apuntar a un elemento de algún array o una posición después del final) se ajusta para apuntar a otro elemento del mismo array, siguiendo las reglas de la aritmética de punteros , y luego se desreferencia.

Cuando se aplica a un array, la expresión de subíndice es un lvalue si el array es un lvalue, y un xvalue si no lo es (since C++11) .

Cuando se aplica a un puntero, la expresión de subíndice siempre es un lvalue.

El tipo T no puede ser un tipo incompleto , incluso si el tamaño o la estructura interna de T nunca se utiliza, como en & x [ 0 ] .

En la resolución de sobrecarga frente a operadores definidos por el usuario , para cada tipo de objeto T (posiblemente calificado cv), la siguiente firma de función participa en la resolución de sobrecarga:

#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"; // utiliza la versión [{...}]
}

4242

Operador de indirección incorporado

Las expresiones con el operador de indirección tienen la forma

El operando del operador de indirección incorporado debe ser un puntero a objeto o un puntero a función, y el resultado es el lvalue que se refiere al objeto o función al que expr apunta. Si expr no apunta realmente a un objeto o función, el comportamiento es indefinido (excepto para el caso especificado por typeid ).

Un puntero a (posiblemente cv -calificado) void no puede ser desreferenciado. Los punteros a otros tipos incompletos pueden ser desreferenciados, pero el lvalue resultante solo puede usarse en contextos que permitan un lvalue de tipo incompleto, por ejemplo, al inicializar una referencia.

En la resolución de sobrecarga contra operadores definidos por el usuario , para cada tipo T que sea tipo objeto (posiblemente calificado cv) o tipo función (no calificado const o ref), la siguiente firma de función participa en la resolución de sobrecarga:

#include <iostream>
int f() { return 42; }
int main()
{
    int n = 1;
    int* pn = &n;
    int& r = *pn; // un lvalue puede vincularse a una referencia
    int m = *pn;  // indirección + conversión lvalue-a-rvalue
    int (*fp)() = &f;
    int (&fr)() = *fp; // un lvalue de función puede vincularse a una referencia
    [](...){}(r, m, fr); // elimina posibles advertencias de "variable no utilizada"
}

Operador de dirección incorporado

Las expresiones del operador de dirección tienen la forma

En la resolución de sobrecarga frente a operadores definidos por el usuario , este operador no introduce ninguna firma de función adicional: el operador de dirección incorporado no se aplica si existe un operator & sobrecargado que sea una función viable .

void f(int) {}
void f(double) {}
struct A { int i; };
struct B { void f(); };
int main()
{
    int n = 1;
    int* pn = &n;    // puntero
    int* pn2 = &*pn; // pn2 == pn
    int A::* mp = &A::i;      // puntero a miembro de datos
    void (B::*mpf)() = &B::f; // puntero a función miembro
    void (*pf)(int) = &f; // resolución de sobrecarga por contexto de inicialización
//  auto pf2 = &f; // error: tipo de función sobrecargada ambiguo
    auto pf2 = static_cast<void (*)(int)>(&f); // resolución de sobrecarga por conversión
}

Operadores de acceso a miembros incorporados

Las expresiones de operador de acceso a miembro tienen la forma

id-expr es el nombre de (formalmente, una expresión de identificador que nombra) un miembro de datos o función miembro de T o de una clase base no ambigua y accesible B de T (por ejemplo, E1. E2 o E1 - > E2 ), opcionalmente calificado (por ejemplo, E1. B :: E2 o E1 - > B :: E2 ), opcionalmente usando el template desambiguador (por ejemplo, E1. template E2 o E1 - > template E2 ).

Si se llama a un operator - > definido por el usuario, operator - > se llama nuevamente sobre el valor resultante, recursivamente, hasta que se alcanza un operator - > que retorna un puntero simple. Después de eso, se aplica la semántica incorporada a ese puntero.

La expresión E1 - > E2 es exactamente equivalente a ( * E1 ) . E2 para tipos incorporados; por eso las siguientes reglas solo abordan E1. E2 .

En la expresión E1. E2 :

operator. no se puede sobrecargar, y para operator - > , en la resolución de sobrecarga frente a operadores definidos por el usuario , el operador incorporado no introduce ninguna firma de función adicional: el operator - > incorporado no se aplica si existe un operator - > sobrecargado que sea una función viable .

#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 también funciona
              << a.f() << ' ' 
              << a.sf() << ' ' // A::sf() también funciona
//            << &a.f << ' '   // error: mal formado si a.f no es el
                               // operando izquierdo de operator()
//            << a.B << ' '    // error: tipo anidado no permitido
              << a.RED << ' '; // enumerador
    UPtrWrapper uPtrWrap{std::make_unique<std::string>("wrapped")};
    assert(uPtrWrap->data() == uPtrWrap.operator->().operator->()->data());
}

1 2 11 4 1

Si E2 es un miembro no estático y el resultado de E1 es un objeto cuyo tipo no es similar al tipo de E1 , el comportamiento es indefinido:

struct A { int i; };
struct B { int j; };
struct D : A, B {};
void f()
{
    D d;
    static_cast<B&>(d).j;      // OK, la expresión de objeto designa el subobjeto B de d
    reinterpret_cast<B&>(d).j; // comportamiento indefinido
}

Operadores integrados de acceso a puntero a miembro

Las expresiones de operador de acceso a miembros a través de punteros a miembros tienen la forma

rhs debe ser un rvalue de tipo puntero a miembro ( data o function ) de T o puntero a miembro de una clase base B de T que sea unívoca y accesible.

La expresión E1 - > * E2 es exactamente equivalente a ( * E1 ) . * E2 para tipos incorporados; por eso las siguientes reglas abordan únicamente E1. * E2 .

En la expresión E1. * E2 :

En la resolución de sobrecarga frente a operadores definidos por el usuario , para cada combinación de tipos D , B , R , donde el tipo de clase B es la misma clase que D o una clase base unívoca y accesible de D , y R es un tipo de objeto o función, la siguiente firma de función participa en la resolución de sobrecarga:

donde ambos operandos pueden estar calificados con cv, en cuyo caso la calificación cv del tipo de retorno es la unión de las calificaciones cv de los operandos.

#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); // los punteros base funcionan con objetos derivados
    D* pd = &d;
    std::cout << (d.*pf)(7) << ' '
              << (pd->*pf)(8) << '\n';
}

7
14 15

Biblioteca estándar

El operador de subíndice está sobrecargado por muchas clases de contenedores estándar:

Los operadores de indirección y miembro están sobrecargados por muchos iteradores y clases de punteros inteligentes:

Ninguna clase de la biblioteca estándar sobrecarga operator & . El ejemplo más conocido de operator & sobrecargado es la clase Microsoft COM CComPtr , aunque también puede aparecer en EDSLs como boost.spirit .

Ninguna clase de la biblioteca estándar sobrecarga operator - > * . Se sugirió que podría ser parte de la interfaz de punteros inteligentes , y de hecho se utiliza en esa capacidad por actores en boost.phoenix , pero es más común en EDSLs como cpp.react .

Notas

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también

Precedencia de operadores

Sobrecarga de operadores