默认参数

Question

我想要什么语法实现对用户侧：

double a(1.), b(2.), deps(.1); 
bool res1 = compare<double>()(a, b);  // works with default eps 
bool res2 = compare<double, &deps>()(a, b); // works with explicitly provided eps 
float c(1.), d(1.). feps(.1); 
bool res3 = compare<float>()(c, d); // don't have default eps - must not compile 
bool res4 = compare<float, &feps>()(c, d); // works only with provided eps 

我现在（不工作，因为偏特默认参数是不允许的）有哪些实现了这一点：

extern double eps_double; // somewhere defined and initialized 

template<typename T, const T* eps> 
struct compare { // actually inherits std::binary_function 
    bool operator()(const T& t1, const T& t2) { 
    return t1 < t2 - *eps; 
    } 
}; 
template<const double* eps = &eps_double> 
struct compare<double, eps> { // the same as in default implementation 
}; 

我试着用enable_if和包装类有静态成员，但静态成员不能被分配给extern变量;

更新： 实际的问题是一般结构和专用结构的名称相等。我不知道如何度过，即使没有重命名工作：

// treats all explicitly passed eps and don't need default parameter 
template<typename T, const T* eps> 
struct compare_eps { // need another name! 
    bool operator()(const T& t1, const T& t2) { 
    return t1 < t2 - *eps; 
    } 
}; 
// don't need default parameter either 
// because we always know what eps to use for a concrete type 
template<typename T> 
struct compare { 
    // define nothing -> will not compile on types we don't have specialization for 
}; 
template<> 
struct compare<double> { 
    // use here eps_double hardcoded 
}; 

Answer 1

我不知道为什么你认为这是否有道理

compare<double, deps> 

您无法完成此工作：模板参数不能是double类型的值（它们可能是double类型的左值，但您的模板需要地址为double，因此关闭）。

您可以使用函数模板，使你的语法工作

extern double eps_double; 

template<typename T> 
types::compare<T, &eps_double> compare(
    typename enable_if<is_same<T, double>>::type * = 0 
) { 
    return types::compare<T, &eps_double>(); 
} 

template<typename T, const T *eps> 
types::compare<T, eps> compare() { 
    return types::compare<T, eps>(); 
} 

或者，你可以使用类模板，如果你是为某些丑陋的黑客

template<typename T, const T* eps = &eps_double> 
struct compare { 
    bool operator()(const T& t1, const T& t2) { 
    return t1 < t2 - *eps; 
    } 
}; 

默认参数将不被使用如果你提供两个参数。如果您仅提供<double>，则将使用默认参数并且可以使用。如果您只提供<float>，则也会使用默认参数，但不起作用。

Answer 2

您需要更改该公司拥有的比较操作，这样你可以专注外模板结构，请参阅：http://ideone.com/xqtjz

代码：

extern double eps_double; // somewhere defined and initialized 
extern double deps; // NOTE: you have to make these extern a well, else cannot work 
extern float feps; 

template<typename T> 
struct compare { 
    // this internal structure now has the operator() 
    template <const T* eps> 
    struct it 
    { 
    bool operator()(const T& t1, const T& t2) const { 
     return t1 < t2 - *eps; 
    } 
    }; 
}; 

// specialize compare for double 
template<> 
struct compare<double> 
{ 
    // here you can provide the default 
    template<const double* eps=&eps_double> 
    struct it 
    { 
    bool operator()(const double& t1, const double& t2) 
    { 
     return t1 < t2 - *eps; 
    } 
    }; 
}; 

int main(void) 
{ 
    double a(1.), b(2.); 
    bool res1 = compare<double>::it<>()(a, b);  // works with default eps 
    bool res2 = compare<double>::it<&deps>()(a, b); // works with explicitly provided eps 
    float c(1.), d(1.); 
    bool res3 = compare<float>::it<>()(c, d); // don't have default eps - will not compile 
    bool res4 = compare<float>::it<&feps>()(c, d); // works only with provided eps 
} 

Answer 3

我会去与性状类似的方法：

template<class T> 
struct DefaultEps; 

template<> 
struct DefaultEps<double> 
{ 
    static const double eps = 4.0; 
}; 

// may or may not be needed in .cpp 
// const double DefaultEps<double>::eps; 

template<> 
struct DefaultEps<float> 
{ 
    static const float eps = 4.0; 
}; 

// may or may not be needed in .cpp 
// const float DefaultEps<float>::eps; 

template<class T, class E = DefaultEps<T> > 
struct Compare 
{ 
    bool operator()(T const &t1, T const &t2) 
    { 
    return(t1 < t2 - E::eps); 
    } 
}; 

，然后当需要特定的ε-：

struct SpecificEps 
{ 
    static const float eps = 4.0; 
}; 

// may or may not be needed in .cpp 
// const float SpecificEps::eps; 

，并使用它：

Compare<float, SpecificEps>()(...);