one-way implicit conversion between two classes

I have two classes, Polynomial and Fractional:

#include <vector>

class Polynomial;
class Fractional;

class Polynomial {
    private:
        std::vector<double> coefficients;
        int degree;

    public:
        Polynomial(std::string p);
        operator Fractional() const;
        friend Polynomial operator + (const Polynomial &p, const Polynomial &q);
        // lots of other overloaded operators here such as -, *, /, etc. 
};

class Fractional {
    private:
        Polynomial quotient, remainder, divider;

    public:
        Fractional(Polynomial q, Polynomial r, Polynomial d);
        operator Polynomial() const;
        friend Fractional operator + (const Fractional &p, const Fractional &q);
        // lots of other overloaded operators here such as -, *, /, etc. 
};

Fractional is a class that holds a group of polynomials. It is meant to handle inexact Polynomial divisions of the form A / B = Q + R / B (where Q stands for quotient and R, remainder).

Problem is, when I add a Fractional object to a Polynomial one, the Fractional object always gets implicitly converted to a Polynomial (losing the "fractional" part), instead of the Polynomial getting implicitly converted to a Fractional.

int main()
{
    Polynomial p("3x^2"), q("2x + 1"), r("-10");
    Fractional f(p, q, r);   // 3x^2 + (-10) / (2x + 1)
    Polynomial s("6x^2");

    std::cout << f + s;
}

Doing the math:

f + s = { 3x^2 + (-10) / (2x + 1) } + 6x^2
f + s = 9x^2 + (-10) / (2x + 1)

But since f gets implicitly converted into a Polynomial object, I get:

f + s = 9x^2
// note that the fractional part "(-10) / (2x + 1)" got lost

I tried removing operator Polynomial() from the Fractional class, but VS 2017 throws:

error C2678: binary '+': no operator found which takes a left-hand operand of type 'Fractional' (or there is no acceptable conversion)
note: could be 'Fractional operator +(const Fractional &,const Fractional&)'
note: or       'Polynomial operator +(const double,const Polynomial &)'
note: or       'Polynomial operator +(const Polynomial &,const double)'
note: or       'Polynomial operator +(const Polynomial &,const Polynomial &)'
note: while trying to match the argument list '(Fractional, Polynomial )'

By the way, I know implicit conversion between two classes isn't good, though I believe it's not a big deal since Fractional can behave just like a Polynomial (having R = 0 and B = 1 so that A / B = Q + R / B becomes A = Q).