abstract class question

[www.brook]

I want to enfore the implementation of the operator overloading eg

class Interface_
{
public:
virtual void operator = (const Interface &other)=0;
virtual void operator +=(const Interface &other)=0;
}
class A:public Interface_
{
public:
int m_a;
virtual void operator =(const A &other) {m_a = other.m_a;}
virtual void operator+=(const A &other){m_a += other.m_a;}
}

this will not work, since the interefaces are different, A v.s.
Interace_
So a solution I have is to use

class Interface_
{
public:
virtual void operator = (const Interface *other)=0;
virtual void operator +=(const Interface *other)=0;
}
class A:public Interface_
{
public:
int m_a;
virtual void operator =(const _Interface *other) {m_a =
((A*)(other))->m_a;}
virtual void operator+=(const _Interface *other){m_a +=
((A*)(other))->m_a;}
};
But this looks not clean, because of the pointer conversion, it is not
safe, Is there better solution?

Thanks in advance!

[Victor Bazarov]

ww*******@gmail.com wrote:

[...]

'comp.lang.c++' is not a chat-room, nor is it an IRC channel.
Post and _wait_ for replies. Patience is a virtue.

V
--
Please remove capital As from my address when replying by mail

[Greg]

ww*******@gmail.com wrote:

I want to enfore the implementation of the operator overloading eg

class Interface_
{
public:
virtual void operator = (const Interface &other)=0;
virtual void operator +=(const Interface &other)=0;
}
class A:public Interface_
{
public:
int m_a;
virtual void operator =(const A &other) {m_a = other.m_a;}
virtual void operator+=(const A &other){m_a += other.m_a;}
}

this will not work, since the interefaces are different, A v.s.
Interace_
So a solution I have is to use

class Interface_
{
public:
virtual void operator = (const Interface *other)=0;
virtual void operator +=(const Interface *other)=0;
}
class A:public Interface_
{
public:
int m_a;
virtual void operator =(const _Interface *other) {m_a =
((A*)(other))->m_a;}
virtual void operator+=(const _Interface *other){m_a +=
((A*)(other))->m_a;}
};
But this looks not clean, because of the pointer conversion, it is not
safe, Is there better solution?

Why bother? If the overloaded operator is not implemented, than any
code that would have used the overloaded operator had it been
implemented, will fail to compile when no overloaded operator is found.
And if the overloaded operator is not used anywhere in the program, why
waste time requiring that an implementation be written anyway, even
though it will not be called?

Greg

[Victor Bazarov]

Greg wrote:

ww*******@gmail.com wrote:

I want to enfore the implementation of the operator overloading eg
[..]

Why bother? If the overloaded operator is not implemented, than any
code that would have used the overloaded operator had it been
implemented, will fail to compile when no overloaded operator is
found.
And if the overloaded operator is not used anywhere in the program,
why waste time requiring that an implementation be written anyway,
even though it will not be called?

If the class does not declare/define a final overrider for a pure
function, such class cannot be instantiated.

V
--
Please remove capital As from my address when replying by mail

[Greg]

Victor Bazarov wrote:

Greg wrote:

ww*******@gmail.com wrote:

I want to enfore the implementation of the operator overloading eg
[..]

Why bother? If the overloaded operator is not implemented, than any
code that would have used the overloaded operator had it been
implemented, will fail to compile when no overloaded operator is
found.
And if the overloaded operator is not used anywhere in the program,
why waste time requiring that an implementation be written anyway,
even though it will not be called?

If the class does not declare/define a final overrider for a pure
function, such class cannot be instantiated.

Granted, but I'm saying that using an abstract method to force the
implementation of the overloaded operator is superfluous here. The user
will be forced to write the routine anyway - if it is at all needed.

In the event that the overloaded operator is left unimplemented then
any expression that would use the operator will fail to compile. So to
be able to build the program successfully, the user will have to
implement the referenced - but unimplemented - overloaded operator -
and will have to do so whether or not an abstract class exists that
compels the same.

Greg

[www.brook]

If abstract class is used, error could happen at run time if you use
pointers.
eg

interface_ * a, * b,

you do not know what actually pointed by a and b
when you call
*a += *b,
if the base class implemented the operator +=, but the subclass did
not, wired things could happen.