operator->

Two questions...
What does operator->* do? (and operator.* also)

and

Is it possible to overload the operator-> so that some function tacked on to the end of it is applied to a bunch of other objects?

Ie:

Code:

---

template<class T> class Set {
  std::vector<T> members;
  //...other stuff
};
Set<Expression> s_e;
s_e->combine();

---

Where s_e->combine() would call that function of every 'T' in members?

Quote:

---

Originally posted by ygfperson
Two questions...
What does operator->* do? (and operator.* also)

---

To use pointer to members, you have to use those operators.

Code:

---

struct AStruct
{
 int b,c;
};
AStruct obj;
AStruct* pobj = &obj;
int AStruct::* p = &AStruct::b;
obj.*p = 2;
p = &AStruct::c;
pobj->*p = 3;

---

Quote:

---

Originally posted by ygfperson

Is it possible to overload the operator-> so that some function tacked on to the end of it is applied to a bunch of other objects?

Ie:

Code:

---

template<class T> class Set {
  std::vector<T> members;
  //...other stuff
};
Set<Expression> s_e;
s_e->combine();

---

Where s_e->combine() would call that function of every 'T' in members?

---

You will need some kind of helper class that operator-> can return a pointer to.

Code:

---

template<typename T>
class SetHelper
{
  public:

  SetHelper(Set<T>& set)
  {
    mySet = set;
  }

  void combine()
  {
    //Call combine for every entry
  }

  protected:

  Set<T>& mySet;
};

template<class T> class Set {
...
 Set()
 {
    seth = new SetHelper<T>( *this );
 }

 ~Set()
 {
    delete seth;
 }

SetHelper<T>* operator->()
{
  return seth;
}

SetHelper<T>* seth;

---

I have certainly not tested this, it's just from the top of my head.

>> You will need some kind of helper class that operator-> can return a pointer to.

I don't see why. Since 'members' is member data of 'Set', you could just define 'combine()' in 'Set', and use the default behavior of 'operator->'. Maybe I'm missing something though...

'->' is member access operator and
'->*' is pointer to member access operator.

These both operator can't be overload. because basically they take member name as argument.

for example :

struct ABC
{
int i;
};

code :
----------------
ABC* abc;
abc->i = 11;
----------------

Actually, they can be overloaded. The only operators which cannot are: '.', '.*', and '::'.

You can't overload '?' or ':' either.

what's the '?' operator used for?

Don't think '.' equals to '->' and '.*' equals to '->*' ?

Code:

---

if (a == b)
  statement1;
else
  statement2;

---

is equivalent to

Code:

---

(a == b) ? statement1 : statement2;

---

Lots of times it's used to save typing, such as:

Code:

---

if (a == b)
  cout << string1;
else
  cout << string2;

---

could be:

Code:

---

cout << ((a == b) ? string1 : string2);

---

>> Don't think '.' equals to '->' and '.*' equals to '->*' ?

I don't quite follow what your saying.

-------------------------------------------------------------------------
>> Don't think '.' equals to '->' and '.*' equals to '->*' ?

I don't quite follow what your saying.
-------------------------------------------------------------------------


Sorry.......sorry....... I wanted to say :

Don't you think '.' is conceptually equals to '->' and '.*' is conceptually equals to '->*' ???

Both are used to access member of structure or class. So I want to say that if '.' can't be overload than '->' must not be overload.
And similar with '.*' and '->*'.

Thats all !!!!!!!!!

Okay, got it.

It makes sense that the . and .* operators cannot be overloaded. It is nice sometimes to overload -> though.

Your right though, they do seem conceptually the same.

if operator -> couldn't be overloaded how could we have smart pointers???

It'd be possible, but the syntax wouldn't be as nice.

I have even read also in one C++ book that operator -> can't be overloaded.

If you think that it can be overloaded, please give me some example if you can.

Directly from the auto_ptr class of the <memory> header in my STL implementation:

Code:

---

  /**
  *  @brief  Smart pointer dereferencing.
  *
  *  This returns the pointer itself, which the language then will
  *  automatically cause to be dereferenced.
  */
  element_type*
  operator->() const throw() { return _M_ptr; }

---

Code:

---

template<typename Y>
class UselessExample
{
public:
  Y* operator ->() { return ptr_;}
  Y& operator *() { return *ptr_;}
private:
  Y* ptr_;
};

---

There you go.

Stroustrup's C++PL, Special Edition, p. 262.

The only one's which cannot be redefined are '::', '.', and '.*'. Of course, '?:' can't be either, but its sort of a weird 'operator' anyways.