Доминирующий пользовательский оператор литья

Question

Скажем, у меня есть два класса: A и B. Я определяю, как отливать A в B и B - A. Я также определяю operator<, operator> и operator== для обоих из них, поэтому я могу сравнить A с A или B с другим B. Затем я делаю экземпляр класса A, например. a и один из классов B, b. Я сравниваю их:

if(a>b){...} 

Какой из них будет преобразован в другую? Есть ли способ повлиять на это, кроме явного литья?

EDIT: Я сделал пример своего вопроса, надеюсь, это поможет мне объяснить. Скажем, я хочу хранить целые числа. Я могу хранить их в A или в B. В A, i только sotore положительные значения. В B, только отрицательный. Полный код приведен ниже. Если a преобразуется в B, то a>b является истинным. Если b преобразуется в A, это неверно. Попробуйте. Для меня, если я не использую его, a>b является ложным. Я спрашиваю, может ли быть сделана конверсия, чтобы в этих ситуациях я мог быть уверен, что происходит?

хиджры

#ifndef _A 
#define _A 

class B; 

class A{ 
    private: 
     int val; 
    public: 
     A(int val); 
     operator B()const; 
     bool operator==(const A& a)const; 
     bool operator>(const A& a)const; 
     bool operator<(const A& a)const; 
}; 

#endif 

B.h

#ifndef _B 
#define _B 

class A; 

class B{ 
    private: 
     int val; 
    public: 
     B(int val); 
     operator A()const; 
     bool operator==(const B& b)const; 
     bool operator>(const B& b)const; 
     bool operator<(const B& b)const; 
}; 

#endif 

a.cpp

#include "A.h" 
#include "B.h" 

A::A(int val){ 
    this->val=val>=0?val:-val; 
} 
A::operator B()const{ 
    return B(-val); 
} 
bool A::operator==(const A& a)const{ 
    return val==a.val?true:false; 
} 
bool A::operator>(const A& a)const{ 
    return val>a.val?true:false; 
} 
bool A::operator<(const A& a)const{ 
    return val<a.val?true:false; 
} 

B.cpp

#include "A.h" 
#include "B.h" 

B::B(int val){ 
    this->val=val>0?-val:val; 
} 
B::operator A()const{ 
    return A(-val); 
} 
bool B::operator==(const B& b)const{ 
    return val==b.val?true:false; 
} 
bool B::operator>(const B& b)const{ 
    return val>b.val?true:false; 
} 
bool B::operator<(const B& b)const{ 
    return val<b.val?true:false; 
} 

main.cpp

#include <iostream> 
using namespace std; 

#include "A.h" 
#include "B.h" 

int main(){ 
    A a(5); 
    B b(-7); 
    if(a>b) cout << "a>b is true" << endl; 
    else cout << "a>b is false" << endl; 
    return 0; 
} 

EDIT: Для меня это всегда правый операнд >, который получает литой (в основном). Кроме того, если я объявляю операторы сравнения как функции друзей, код не будет компилироваться, с ошибкой ambiguous overload for 'operator>' in 'b > a', которую я как бы ожидал.

Answer 1

operator> ничего не будет делать. Он будет просто сравнивать два операнда с определенной перегрузкой. Если такой перегрузки нет, ваш код не будет компилироваться.

Это будет выглядеть следующим образом:

bool operator>(const A& lhs, const B& rhs) 
{ 
    return lhs.foo > rhs.bar; // 
} 

Если вы хотите преобразование между A и B вы бы B в A конструктора, так что вы можете сделать это:

A::A(const B& b) {} //do stuff to convert B to A 

A a = someb; 

, которая равна A a(someb);