如何在C++或Python中实现指定传参规则的递归函数？

C++ 完全可行 #

C++原生支持引用传递，完全可以满足你的需求，不过需要注意一个语法细节：临时右值无法绑定到非const左值引用，所以你递归调用时不能直接传入s/2这类表达式的计算结果，需要先创建临时变量存储计算结果，递归返回后再把临时变量的值同步到上层的s、t中。
示例实现如下：

int e_euclid(int a, int b, int& s, int& t) {
    if (a == b) {
        s = 4;
        t = -3;
        return a;
    }
    if (a % 2 == 0 && b % 2 == 0) {
        int tmp_s, tmp_t;
        int res;
        if (s % 2 == 0 && t % 2 == 0) {
            tmp_s = s / 2;
            tmp_t = t / 2;
            res = e_euclid(a/2, b/2, tmp_s, tmp_t);
        } else {
            tmp_s = (s + b) / 2;
            tmp_t = (t - a) / 2;
            res = e_euclid(a/2, b/2, tmp_s, tmp_t);
        }
        // 把递归层修改后的结果同步到当前层的s、t
        s = tmp_s;
        t = tmp_t;
        return 2 * res;
    }
    // 其余逻辑省略
}

调用时直接传入外部定义的int变量的引用即可，递归底层对s、t的赋值会逐层同步到最上层的变量。

Python 无法直接实现原生引用传递效果 #

Python的参数传递规则是「传对象引用的值」，对于int、float这类不可变类型，函数内部对参数的赋值完全不会影响外部的变量：

def test(s):
    s = 4
s_out = 0
test(s_out)
print(s_out) # 输出还是0，没有变化

如果你不想用返回元组的方案，只能把s、t封装到列表这类可变对象里间接实现类似效果：

def e_euclid(a, b, st):
    s, t = st[0], st[1]
    if a == b:
        st[0] = 4
        st[1] = -3
        return a
    if a % 2 == 0 and b % 2 == 0:
        tmp_st = [0, 0]
        res = 0
        if s % 2 == 0 and t % 2 == 0:
            tmp_st[0] = s // 2
            tmp_st[1] = t // 2
            res = e_euclid(a//2, b//2, tmp_st)
        else:
            tmp_st[0] = (s + b) // 2
            tmp_st[1] = (t - a) // 2
            res = e_euclid(a//2, b//2, tmp_st)
        st[0] = tmp_st[0]
        st[1] = tmp_st[1]
        return 2 * res
    # 其余逻辑省略
}

但这种写法可读性差，而且额外的封装开销并不比返回元组小，实际上Python元组的创建和解包开销极低，更推荐直接返回(gcd, s, t)元组的方案。

内容的提问来源于stack exchange，提问作者Tobias Rieper