fork download

copy

#include <type_traits>
 
namespace foo {
    struct Vector {
        double x, y, z;
 
        Vector(double x, double y, double z) :
            x{x}, y{y}, z{z}
        {}
 
        template<class T>
        Vector(const T& foreign) :
            x{foreign.x}, y{foreign.y}, z{foreign.z}
        {}
 
 
        template<class T>
        operator T() const
        {
            return T{x, y, z};
        }
    };
 
 
    Vector makeAVector()
    {
        return {1, 2, 3};
    }
}
 
 
namespace bar {
 
    struct Vector3 {
        using Scalar = double;
 
        Scalar x, y, z;
 
        Vector3(Scalar x, Scalar y, Scalar z) :
            x{x}, y{y}, z{z}
        {}
 
        Vector3(const Vector3& other) :
            x{other.x}, y{other.y}, z{other.z}
        {}
 
        Vector3(const Scalar *ptr) :
            x{ptr[0]}, y{ptr[1]}, z{ptr[2]}
        {}
 
    };
 
    void doSomething(const Vector3& v, double* x)
    {}
 
    void doSomething(const Vector3& v, const Vector3&  x)
    {}
 
}
 
 
int main()
{
    bar::Vector3 a{2, 3, 4};
 
    bar::doSomething( a, foo::makeAVector() );
}
 

prog.cpp: In function ‘int main()’:
prog.cpp:66:45: error: call of overloaded ‘doSomething(bar::Vector3&, foo::Vector)’ is ambiguous
     bar::doSomething( a, foo::makeAVector() );
                                             ^
prog.cpp:66:45: note: candidates are:
prog.cpp:53:10: note: void bar::doSomething(const bar::Vector3&, double*)
     void doSomething(const Vector3& v, double* x)
          ^
prog.cpp:56:10: note: void bar::doSomething(const bar::Vector3&, const bar::Vector3&)
     void doSomething(const Vector3& v, const Vector3&  x)
          ^

Standard output is empty