避免为未使用的抽象可选函数参数保留名称

Question

我有一个求解器类模板，可以使用可选的 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>()

？

我所期待的

我可以使用与

相同的重载原理

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

并且不需要为第二个参数

y

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

Answer 1

OptionalWrapper<std::ostream>=OptionalWrapper<std::ostream>()

有解析问题，您需要额外的空间：

OptionalWrapper<std::ostream> =OptionalWrapper<std::ostream>()

.

演示。

else

>=

被视为大于，（类似于关闭双模板的旧

>>

问题）。