Comment créer et utiliser un opérateur de flèche de classe?

Donc, après avoir cherché partout, je n'arrive pas à trouver comment créer une classe flèche de l'opérateur, c'est à dire,

class Someclass
{
  operator-> ()  /* ? */
  {
  }
};

J'ai juste besoin de savoir comment travailler avec elle et l'utiliser de façon appropriée.
- quels sont ses apports?
- en quoi est-il de retour?
- comment dois-je déclarer convenablement/prototype?

source d'informationauteur Codesmith | 2011-02-08

  1. 17

    L'opérateur -> est utilisé pour la surcharge de l'accès des membres. Un petit exemple:

    #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();
}

    Ce sorties:

    Hi
  2. 18

    La flèche de l'opérateur n'a pas d'entrée. Techniquement, il peut renvoyer tout ce que vous voulez, mais il doit retourner quelque chose qui est un pointeur ou peut devenir un pointeur par enchaînés -> opérateurs.

    La -> opérateur automatiquement déréférence sa valeur de retour avant d'appeler son argument à l'aide de l'intégré dans le déréférencement de pointeur, pas operator*alors vous pourriez avoir la classe suivante:

    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;
    }
};

    L'utiliser comme:

    PointerToString ptr(string("hello"));
string::size_type size = ptr->size();

    qui est transformé par le compilateur dans:

    string::size_type size = (*ptr.operator->().operator->()).size();

    (avec autant de .operator->() que nécessaire pour retourner un vrai pointeur) et de sortie

    arrow dereference
indirect dereference
dereference

    Noter, cependant, que vous pouvez effectuer les opérations suivantes:

    PointerToString::PtPtS ptr2 = ptr.operator->();

    en ligne: https://wandbox.org/permlink/Is5kPamEMUCA9nvE

    De Stroupstrup:

    La transformation de l'objet p dans le pointeur p.operator->() ne dépend pas de la membre m souligné. C'est le sens dans lequel operator->() est unaire postfix opérateur. Cependant, il n'y a pas de nouvelle syntaxe introduite, donc un nom de membre est toujours nécessaire après le ->

  3. 0
    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;
        }
};

    http://en.wikibooks.org/wiki/C++_Programming/Operators/Operator_Overloading#Address_of.2C_Reference.2C_and_Pointer_operators

  4. 0

    La "flèche" de l'opérateur peut être surchargé par:

    a->b

    sera traduit en

    return_type my_class::operator->()