#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
                 ,
                 class = typename std::enable_if<
                     std::is_constructible<T, double,double,double>::value
                     >::type
                 >
        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() );
}