一种解决方案是使用平移变换在贝塞尔曲线路径上调用apply()。
您可以通过将viewB的原点转换为viewA的坐标空间来计算变换所需的x和y。
以下是一些可以放在Swift Playground中的示例代码：

// Some setup
let rectA = CGRect(x: 40, y: 60, width: 200, height: 100)
let rectB = CGRect(x: 10, y: 80, width: 200, height: 100)
let viewA = UIView(frame: rectA)
let viewB = UIView(frame: rectB)
// Create pathA
let pathA = UIBezierPath(rect: rectA)

// Calculate the offset needed to move from viewA to viewB
let offset = viewA.convert(CGPoint.zero, from: viewB)
let tranform = CGAffineTransform(translationX: offset.x, y: offset.y)
// Copy pathA
let pathB = UIBezierPath()
pathB.append(pathA)
// Shift pathB
pathB.apply(tranform)
// Check result
print(pathA)
print(pathB)

输出量：

<UIBezierPath: 0x600002c31e80; <MoveTo {40, 60}>,
 <LineTo {140, 60}>,
 <LineTo {140, 160}>,
 <LineTo {40, 160}>,
 <Close>
<UIBezierPath: 0x600002c12280; <MoveTo {10, 80}>,
 <LineTo {110, 80}>,
 <LineTo {110, 180}>,
 <LineTo {10, 180}>,
 <Close>

我相信这就是你要找的。offset的计算可能是向后的。如果pathB的结果方向错误，请将offset行更改为：

let offset = viewB.convert(CGPoint.zero, from: viewA)

以下是UIView的扩展，用于将UIBezierPath从一个视图转换为另一个视图：

extension UIView {
    private func adjust(_ path: UIBezierPath, by offset: CGPoint) -> UIBezierPath {
        let transform = CGAffineTransform(translationX: offset.x, y: offset.y)
        let result = UIBezierPath()
        result.append(path)
        result.apply(tranform)

        return result
    }

    func convert(_ path: UIBezierPath, from view: UIView) -> UIBezierPath {
        let offset = convert(CGPoint.zero, from: view)

        return adjust(path, by: offset)
    }

    func convert(_ path: UIBezierPath, to view: UIView) -> UIBezierPath {
        let offset = convert(CGPoint.zero, to: view)

        return adjust(path, by: offset)
    }
}

这个答案假设两个视图都没有应用非恒等变换。根据OP自己的回答，显然其中一个或两个视图可能具有非恒等变换。

使用像HangarRash发布的扩展，这里有一个解决方案，当两个视图具有相同的超级视图时可以工作。

func convert(_ path: UIBezierPath, from view: UIView) -> UIBezierPath {
    path.apply(view.transform)
    // we now have a path in view's superview's coordinates. Let's adjust by the origin.
    let viewTransform = CGAffineTransform(translationX: view.frame.origin.x, y: view.frame.origin.y)
    path.apply(viewTransform)
    
    // now the path is adjusted by view's origin. Next we need to subtract self's origin
    let selfTranslationTransform = CGAffineTransform(translationX: -self.frame.origin.x, y: -self.frame.origin.y)
    path.apply(selfTranslationTransform)
    
    // now adjust by self's transform
    path.apply(self.transform.inverted())
    return path
}