默認參數

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>()(...);