c++ - tutorial - ¿Cómo creo y uso un operador de flecha de clase?
tutorial tag questions (4)
Por lo tanto, después de buscarlo en todas partes, parece que no encuentro cómo crear un operador de flecha de clase, es decir,
class Someclass
{
operator-> () /* ? */
{
}
};
Solo necesito saber cómo trabajar con él y usarlo adecuadamente. - ¿Cuáles son sus entradas? - ¿A qué vuelve? - ¿Cómo lo declaro / prototipo correctamente?
El operador "flecha" puede ser sobrecargado por:
a->b
será traducido a
return_type my_class::operator->()
El operador -> se utiliza para sobrecargar el acceso de miembros. Un pequeño ejemplo:
#include <iostream>
struct A
{
void foo() {std::cout << "Hi" << std::endl;}
};
struct B
{
A a;
A* operator->() {
return &a;
}
};
int main() {
B b;
b->foo();
}
Esto produce:
Hi
El operador de flecha no tiene entradas. Técnicamente, puede devolver lo que quieras, pero debería devolver algo que sea un puntero o que pueda convertirse en un puntero a través de operadores encadenados .
El operador -> anula automáticamente su valor de retorno antes de llamar a su argumento utilizando la anulación de puntero incorporada, no el operator* , por lo que podría tener la siguiente clase:
class PointerToString
{
string a;
public:
class PtPtS
{
public:
PtPtS(PointerToString &s) : r(s) {}
string* operator->()
{
std::cout << "indirect arrow/n";
return &*r;
}
private:
PointerToString & r;
};
PointerToString(const string &s) : a(s) {}
PtPtS operator->()
{
std::cout << "arrow dereference/n";
return *this;
}
string &operator*()
{
std::cout << "dereference/n";
return a;
}
};
Utilízalo como:
PointerToString ptr(string("hello"));
string::size_type size = ptr->size();
que es convertida por el compilador en:
string::size_type size = (*ptr.operator->().operator->()).size();
(con tantos .operator->() como sea necesario para devolver un puntero real) y debe mostrarse
arrow dereference
indirect dereference
dereference
Tenga en cuenta, sin embargo, que puede hacer lo siguiente:
PointerToString::PtPtS ptr2 = ptr.operator->();
ejecutar en línea: https://wandbox.org/permlink/Is5kPamEMUCA9nvE
Desde Stroupstrup:
La transformación del objeto p en el puntero
p.operator->()no depende del miembro m apuntado. Ese es el sentido en el que eloperator->()es un operador único de postfix. Sin embargo, no se ha introducido una nueva sintaxis, por lo que aún se requiere un nombre de miembro después de->
class T {
public:
const memberFunction() const;
};
// forward declaration
class DullSmartReference;
class DullSmartPointer {
private:
T *m_ptr;
public:
DullSmartPointer(T *rhs) : m_ptr(rhs) {};
DullSmartReference operator*() const {
return DullSmartReference(*m_ptr);
}
T *operator->() const {
return m_ptr;
}
};