Calling operators of ancestor classes

[globos]

Hi,

I have defined a virtual operator== in a class, and redefined it in its heirs.
In the heirs i want to call operator== of the super class.
But i don't know the syntax, how do we write it?

class A
{
public:
virtual bool operator== (const A& other) const
{
//do stuff
}
};

class B : public A
{
public:
bool operator== (const A& other) const
{
const B* b = dynamic_cast<const B*> (&other);
//do stuff
//How to call A:perator== ?
}
};

--
Globos

 

[Cagliostro]

As far as I know, opeartors are not inherited.
you can use them indirectly:
class A
{
protected:
xFunction(const A& other){....
public:

virtual bool operator== (const A& other) const
{
xFunction(A);
.....
}
};

class B : public A
{
public:
bool operator== (const A& other) const
{
const B* b = dynamic_cast<const B*> (&other);
A::xFunction(*b);
....

}
};


Ion Filipski

ICQ: 95034075
AIM: IonFilipski
filipski@excite.com

 

[PerFnurt]

>I have defined a virtual operator

There is no such thing.



/Per

_{if (typos) cout << &quot;My fingers are faster than my brain. Sorry for the typos.&quot;;}

 

[globos]

>>I have defined a virtual operator

>There is no such thing.

See the example :

#include <iostream>

class A
{
public:
  A (int attr) : _attr (attr)
  {
  }
  int attr () const
  {
    return _attr;
  }
  virtual bool operator== (const A& other) const
  {
    std::cout << &quot;A operator==&quot; << std::endl;
    return _attr == other.attr ();
  }
protected:
  int _attr;
};

class B: public A
{
public:
  B (int attr) : A (attr)
  {
  }
  bool operator== (const A& other) const
  {
    std::cout << &quot;B operator==&quot; << std::endl;
    return _attr == other.attr ();
  }
};

int main ()
{
  A* b = new B (5);
  A* c = new B (5);

  if (*b == *c)
    std::cout << &quot;equals&quot; << std::endl;

  return 0;
}

Output of this program is :
B operator==
equals

It means that operator== can be virtual and redefined in heirs. Semantics of a virtual operator== is correct, and obviously, C++ supports it.
The big lack of C++ is that it doesn't allow us to do things like this :

class A
{
   virtual bool operator== (const [b]A[/b]& other) const;
};
class B : public A
{
   virtual bool operator== (const [b]B[/b]& other) const;
};

We are obliged to keep the same types for the formal arguments, that leads to use non-safe mechanisms like RTTI to simulate this.


--
Globos

 

[PerFnurt]

Sorry. Had my mind set on assignment operator.

Back to your question: Calling A's operator from B's operator would be:

bool res = A::operator == (other);

/Per

_{if (typos) cout << &quot;My fingers are faster than my brain. Sorry for the typos.&quot;;}