Implement two functions with the same name but different, non-covariant return types due to multiple abstract base classes
===

If I have two abstract classes defining a pure virtual function with the same name, but different, non-covariant return types, how can I derive from these and define an implementation for both their functions?

    #include <iostream>
    
    class ITestA {
        public:
            virtual ~ITestA() {};
            virtual float test() =0;
    };
    
    class ITestB {
        public:
            virtual ~ITestB() {};
            virtual bool test() =0;
    };
    
    class C : public ITestA, public ITestB {
        public:
        /* Somehow implement ITestA::test and ITestB::test */
    };
    
    
    int main() {
        ITestA *a = new C();
        std::cout << a->test() << std::endl; // should print a float, like "3.14"
        ITestB *b = dynamic_cast<ITestB *>(a);
        if (b) {
            std::cout << b->test() << std::endl; // should print "1" or "0"
        }
        delete(a);
        return 0;
    }

As long as I don't call C::test() directly there's nothing ambiguous, so I think that it should work somehow and I guess I just didn't find the right notation yet. Or is this impossible, if so: Why?