Thread: operator->

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;

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 '::'.

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.