Question

What shall I do in this example to trigger the right operator:

#include<iostream>
using namespace std;

class A
{
public:
    virtual void operator/(A& a){cout << "class A";}
};
class B : public A
{
public:
    void operator/(B& b){cout << "class B";}
};

int main()
{
    A* a = new B;
    A* b = new B;
    *a / *b;
    return 0;
}

The output is "class A" but it should be "class B".
How can I solve this? Thanks.

EDIT: According to answers… should I do this for every derived class:

class A
{
public:
    virtual void operator/(A& a){cout << "class A";}
};
class B : public A
{
public:
    virtual void operator/(A& a) override {cout << "class B";}
};
class C : public B
{
public:
    virtual void operator/(A& a) override {cout << "class C";}
};
class D: public C
{
public:
    void operator/(A& a) override {cout << "class D";}
};
int main()
{
    A* a = new D;
    A* b = new D;
    *a / *b;
    //...
}

Answer 1

(First, I’m going to try to explain what’s happening at the moment, but at the end I’ll try to write a ‘correct’ program.)

I’m going to use x and y instead of a and b – it’s bit less confusing.

A* x = new C;
A* y = new B;
*x / *y;

The static type of x is A – i.e. that’s what the type of the variable is. The dynamic type, the real type of the object pointed at by the variable, is C.

The static type of y is A – i.e. that’s what the type of the variable is. The dynamic type, the real type of the object pointed at by the variable, is B.

So there are four types that seem to be involved here. But actually, the dynamic type of y is never relevant, as we will see. So that leaves (at most) three relevant types. To understand this, let’s rewrite the expression as follows:

x -> operator/ (*y);

First, the compiler looks at the static type of x. In this case it is A. Then it looks for a method in the static type with the appropriate signature. What does ‘appropriate signature’ mean? The answer is that method lookup ignores the dynamic type of variables. The static type of y is A, and hence operator/(A&) is selected. (We know y is really a B, but that’s ignored. )Finally, the runtime will look at the dynamic type of x (ignoring y). The dynamic type is C. Because the operator/(A&) was virtual in A, then the runtime will actually call the C::operator/(A&) instead.

In short, the dynamic type of y is not relevant. The methods operator/(B&) or operator/(C&) will never be called. Those methods should be deleted.

There’s a fundamental asymmetry here. In *y / *x, the dynamic type of y would be relevant, but not the dynamic type of x.

How to fix it

Before ‘fixing’ the problem, we need to be sure we know what the question is. Hence, I’ll clarify my interpretation first. If this is the wrong interpretation, apologies in advance.

I’m going to assume that the questioner intends that the dynamic type of x will always be the same as the dynamic type of y, and that if they are different then there should be an error message. For example, this code is expected to work:

A * x = new A;
A * y = new A;
*x / *y; // divide an instance of A by another instance of A

and

A * x = new B;
A * y = new B;
*x / *y; // divide an instance of B by another instance of B

and

A * x = new C;
A * y = new C;
*x / *y; // divide an instance of C by another instance of C

but not

A * x = new B;
A * y = new C;
*x / *y; // should give an error

or

A * x = new C;
A * y = new B;
*x / *y; // should give an error

Here is a complete program that does this:

#include <iostream>
#include <typeinfo>
#include <cassert>
using namespace std;
class A
{
public:
    virtual void operator/(A& z) {
            assert(typeid(z) == typeid(*this));
            cout << "class A" << endl;
    }
};
class B : public A
{
public:
    virtual void operator/(A& z) {
            assert(typeid(z) == typeid(*this));
            cout << "class B" << endl;
            B& b = dynamic_cast<B&>(z);
    }
};
class C : public B
{
public:
    virtual void operator/(A& z) {
            assert(typeid(z) == typeid(*this));
            cout << "class C" << endl;
            C& c = dynamic_cast<C&>(z);
    }
};
int main()
{
    A* x = new C;
    A* y = new C;
    *x / *y;
}

The operators in B and C do two things:

• test that the type of the second operand is as expected. i.e. confirm that both side of the / have the same type.
• cast the A& to the appropriate type, allowing the division code to have full access to both operands