Mixing objects from different classes?

Hi, I am trying to overload the relational operator and compare objects from different classes.

say for instance I have:

class A{
int x;
};

class B : public A{
int y;
};

I would like to have code in main that looks like A < B, where x and y are being compared.

I don't know which class to put the operator function in.

I think I need a Programmer Defined Conversion Function? but I am not sure how to use one. Any help would be appreciated.

// One of many solutions is this


class A {
int x;
virtual int getFromChild () {return x;}
public:
int operator < (A& right) {return this -> x < right.getFromChild ();}
A (int val = 0) {x = val;}
};


class B : public A {
int y;
int getFromChild () {return y;}
public:
B (int val = 0) {y = val;}
};


#include <stdio.h>
void main () {
B right (2);
A left (1);
if (left < right) printf ("it works!\n");
}

In general terms the < operator has a left hand side and a right hand side. You need to overload the operator for all possible combinations you want to use it in. That is,if A and B are different classes then A < B is different than B < A to the compiler. You can define what < means in any way you wish, but following traditional guidelines is recommended else you end up causing more confusion than it's worth. Here's a simple example of a straightforward overloading process for < using two simple classes.

Code:

---

struct  A
{
  int Adata;
  bool operator < (A &);
  bool operator < (B &);
};

struct B
{
  int Bdata;
  bool operator < (B &);
  bool operator < (A &);
};

bool operator < (A & rhs)
{
    Adata < rhs.Adata ? return true : return false;
}

bool operator < (B & rhs)
{
    Adata < rhs.Bdata ? return true : return false;
}

bool operator < (B & rhs)
{
  Bdata < rhs.Bdata ? return true : return false;
}

bool operator < (A & rhs)
{
  Bdata < rhs.Adata ? return true : return false;
}

---

Code:

---

bool operator < (A & rhs)
{
    Adata < rhs.Adata ? return true : return false;
}
// why not write this instead
bool operator < (A & rhs)
{
    return Adata < rhs.Adata;
}

---

Seems a lot clearer to me at least.

I guess because I don't like to use return statements that have to be calculated first. I like to see exactly what I am returning. To me that's easier to understand. return Adata < rhs.Adata; etc. certainly works if you prefer that syntax.