Kayan nokta tipine (upcast) cxx11 içinde entegre

Question

Örneğin, yukarı doğru yayınlar için otomatik kayan nokta (şablon) yer tutucu var mı? int türleri? Bir parametre alan ve otomatik upcast'leri dikkate alan uygun boyutta bir kayan nokta türü döndüren bir sınıf ya da ilgili bir şeyi kastediyorum.

Satırı beğenmedim, çünkü int durumunda, dönüşüm için doğru tür bir çift olur.

if (var_high - var_low <= std::numeric_limits<T>::epsilon()) 

Ayrıca değiştirmeniz gerekir: O tipi için en küçük gösterilebilen farkı (yüksek-düşük) karşılaştırabilirsiniz

template <class T> 
T linear_interpolate(const T &low_output, const T &high_output, 
        const T &var_value, 
        const T &var_low, const T &var_high) 
{ 
    if (var_value <= var_low) { 
     return low_output; 
    } 
    if (var_value >= var_high) { 
     return high_output; 
    } 
    // avoid zero divisions or zero like divisions 
    if(is_equal((float)var_high, (float)var_low)) { 
     return low_output; 
    } 

    T p = (var_value - var_low)/(var_high - var_low); 
    return low_output + p * (high_output - low_output); 
} 

Answer 1

: Bu örnekteki

if(is_equal((float)var_high, (float)var_low)) { 

int ile çalışmak için aritmetik - p geçici değişkeni, T bir tam sayı ise, her zaman sıfır olacaktır. Birkaç testlerle

Tam kod,: Size zaten farz gibi ben value<low vb testleri dahil değil

#include <limits> 

template <class T> 
T linear_interpolate(const T &low_output, const T &high_output, 
        const T &var_value, 
        const T &var_low, const T &var_high) 
{ 
    if (var_value <= var_low) { 
     return low_output; 
    } 
    if (var_value >= var_high) { 
     return high_output; 
    } 
    // avoid zero divisions or zero like divisions 
    if (var_high - var_low <= std::numeric_limits<T>::epsilon()) { 
     return low_output; 
    } 

    return low_output 
     + (var_value - var_low) * (high_output - low_output)/(var_high - var_low); 
} 


#include <iostream> 
int main() 
{ 
    std::cout << linear_interpolate(1, 10, 6, 0, 9) << std::endl; 
    std::cout << linear_interpolate(1, 10, 0, 0, 0) << std::endl; 
    std::cout << linear_interpolate(1, 10, 1, 0, 1) << std::endl; 

    std::cout << linear_interpolate(1.0, 10.0, 6.0, 0.0, 9.0) << std::endl; 
    std::cout << linear_interpolate(1.0, 10.0, 0.0, 0.0, 0.0) << std::endl; 
    std::cout << linear_interpolate(1.0, 10.0, 1.0, 0.0, 1.0) << std::endl; 
} 

olanlar var.

---

Muhtemelen doğrusal enterpolasyon giriş ve çıkış için farklı türde isteme ihtimali olduğunu dikkate almak gerektiğini:

"dönüşüm için doğru tip bir çift olacağını int durumunda"

template <class T, class S=T> 
S linear_interpolate(const S &low_output, const S &high_output, 
        const T &var_value, 
        const T &var_low, const T &var_high)