Why the `T* operator->()` is applied repeatedly even if written once? But another `T& operator*()` is applied once, and should be written many times.

As known there is Execute-Around Pointer Idiom in C++. [More C++ Idioms/Execute-Around Pointer](https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Execute-Around_Pointer)

Provide a smart pointer object that transparently executes actions before and after each function call on an object, given that the actions performed are the same for all functions. And before and after each treatment to member variable of a class. For example we can performs:

* lock mutex
* log action
* visualize changing data

I added some in `main()` to [this example](https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Execute-Around_Pointer#Solution_and_Sample_Code):

```
#include <iostream>
#include <vector>

class VisualizableVector {
  public:
    class proxy {
      public:
        proxy (std::vector<int> *v) : vect (v) {
            std::cout << "Before size is: " << vect->size() << std::endl;
        }
        std::vector<int> * operator -> () { return vect; }
        std::vector<int> & operator * () { return *vect; }
        ~proxy () { std::cout << "After size is: " << vect->size() << std::endl; }
      private:
        std::vector <int> * vect;
    };        
    VisualizableVector (std::vector<int> *v) : vect(v) {}            
    ~VisualizableVector () { delete vect; }   
    proxy operator -> () { return proxy (vect); }
    proxy operator * () { return proxy (vect); }
  private:
    std::vector <int> * vect;
};

int main()
{
  VisualizableVector vecc (new std::vector<int>);

  vecc->push_back (10);         // 1. Note use of -> operator instead of . operator      
  vecc->push_back (20);         // 2. ok      
  (*vecc)->push_back (30);      // 3. ok      
  // (*vecc).push_back (40);    // 4. error      
  (**vecc).push_back (50);      // 5. ok      
  // vecc->->push_back (60);    // 6. error     
}

```

Online compiler result: <http://ideone.com/cXGdxW>

Why do we need to write twice `**`, but only once `->` ? 

Its operator return the same thing `proxy`:

```
    proxy operator -> () { return proxy (vect); }
    proxy operator * () { return proxy (vect); }

```

But why do we need to use `*` again, but we shouldn't use `->` again?:

```
  vecc->push_back (20);     // 2. ok      (vecc->) is proxy
  (**vecc).push_back (50);  // 5. ok      (*vecc) is proxy

```

Why not `vecc->->push_back (20);`?

Is there anything about this in the standard C++ (03/11/14)?

**UPDATE:**

In different cases we should use 1,2 or 3 `operator->`s : <http://ideone.com/89kfYF>

```
#include <iostream>
#include <vector>    
class VisualizableVector {
  public:
    class proxy {
      public:
        proxy (std::vector<int> *v) : vect (v) {
            std::cout << "Before size is: " << vect->size() << std::endl;
        }
        std::vector<int> * operator -> () { return vect; }
        std::vector<int> & operator * () { return *vect; }
        ~proxy () { std::cout << "After size is: " << vect->size() << std::endl; }
      private:
        std::vector <int> * vect;
    };        
    VisualizableVector (std::vector<int> *v) : vect(v) {}            
    ~VisualizableVector () { delete vect; }   
    proxy operator -> () { return proxy (vect); }
    proxy operator * () { return proxy (vect); }
  private:
    std::vector <int> * vect;
};

int main()
{
  VisualizableVector vecc (new std::vector<int>);

    vecc->push_back(30);            // ok       // one ->
  //vecc.operator->().push_back(30);// error    // one ->

  //vecc->->push_back(30);          // error    // two ->
  vecc.operator->()->push_back(30); // ok       // two ->

  auto proxy3 = vecc.operator->();      // 1st operator->()
  auto pointer = proxy3.operator->();   // 2nd operator->()
  pointer->push_back(30);               // 3rd operator->()      
  return 0;
}

```

Page 327: [Working Draft, Standard for Programming Language C++ 2014-11-19](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4296.pdf)

> 
> 13.5.6 Class member access [over.ref] 1 operator-> shall be a non-static member function taking no parameters. It implements the
>  class member access syntax that uses ->. postfix-expression ->
>  templateopt id-expression postfix-expression -> pseudo-destructor-name
>  An expression x->m is interpreted as (x.operator->())->m for a class
>  object x of type T if T::operator->() exists and if the operator is
>  selected as the best match function by the overload resolution
>  mechanism (13.3).
> 
> 
> 

I.e. `x->m` is `(x.operator->())->m`.