问：

我有一个求解器类模板，可以使用可选的 ostream 调用其求解例程。

在所述类模板的专用化下，从不使用 ostream。

问题

为什么我不能从下面的最小示例中删除字符序列“fdsa”，并让它实现与我从代码中类似的期望相同的行为，即：foo

1. 我在一个地方定义。foo
2. 我不需要为 . 的第二个参数添加标签。foo
3. 我可以用一个或两个参数调用。foo

最小示例

#include <iostream>
#include <cassert>

template<typename T>
class OptionalWrapper{
    T* p;
public:
    const bool is_empty;
    OptionalWrapper(void):is_empty(true),p(NULL){}
    OptionalWrapper(T& r):is_empty(false),p(&r){}
    T& operator()(void){ assert(!is_empty); return *p; }
    T const& operator()(void)const{ assert(!is_empty); return *p; }
};

template<typename Tfloat>
struct Solver{
    // ... lot of other code
    void compute(Tfloat&x, OptionalWrapper<std::ostream> o=OptionalWrapper<std::ostream>() ){
        if(!o.is_empty) o()<<"solver<float>::compute("<<x<<");\n";
    }
};

template<>
struct Solver<double>{
    // ... lot of uncorrelated specialized code
    void compute(double&x, OptionalWrapper<std::ostream> fdsa=OptionalWrapper<std::ostream>() ){
        std::cout << "solver<double>::compute("<<x<<");\n";
    }
};

int main() {
    //
    float xf = 1;
    double xd = 2;
    //
    Solver<float> sf;
    Solver<double> sd;
    //
    sf.compute(xf,std::cout);
    sf.compute(xf);
    //
    sd.compute(xd,std::cout);
    sd.compute(xd);
}

它是否与 3/5 的规则有关，我不能随便用 ？OptionalWrapper<std::ostream> fdsa=OptionalWrapper<std::ostream>()OptionalWrapper<std::ostream> =OptionalWrapper<std::ostream>()

（备注：在类专用化体之外定义函数将导致 GCC 接受，并且上述不带“fdsa”的代码将被 CLANG、MVSC、ICX 和 ZIG 接受。因此，也许从这个问题中确实没有太多的见解。我很抱歉现在才知道。

我的期望

我可以使用与

int foo(int x, int=0){
    return 2*x;
}
int main() {
    foo(1);
    foo(2,3);
    return 0;
}

并且不需要为 ，第二个参数提供标签。基本上，我认为对于编译器来说，第二个参数的类型甚至无关紧要，因为它无论如何都不会被函数体处理。y