Dlaczego nie mogę użyć wartości zmiennoprzecinkowej jako parametru szablonu?

Kiedy próbuję użyć floatjako parametru szablonu, kompilator woła o ten kod, podczas gdy intdziała dobrze.

Czy to dlatego, że nie mogę użyć floatjako parametru szablonu?

#include<iostream>
using namespace std;

template <class T, T defaultValue>
class GenericClass
{
private:
    T value;
public:
    GenericClass()
    {
        value = defaultValue;
    }

    T returnVal()
    {
        return value;
    }
}; 


int main()
{
    GenericClass <int, 10> gcInteger;
    GenericClass < float, 4.6f> gcFlaot;

    cout << "\n sum of integer is "<<gcInteger.returnVal();
    cout << "\n sum of float is "<<gcFlaot.returnVal();

    return 0;       
}

Błąd:

main.cpp: In function `int main()':
main.cpp:25: error: `float' is not a valid type for a template constant parameter
main.cpp:25: error: invalid type in declaration before ';' token

main.cpp:28: error: request for member `returnVal' in `gcFlaot',
                    which is of non-class type `int'

Czytam „Struktury danych dla programistów gier” Rona Pentona, autor podaje float, ale kiedy próbuję, nie wydaje się, aby się kompilował.

Obecny standard C ++ nie zezwala float(tj. Liczby rzeczywistej) lub literałów ciągu znaków na używanie jako parametrów innych niż typowe dla szablonu . Możesz oczywiście używać typów floati char *jako zwykłych argumentów.

Być może autor używa kompilatora, który nie jest zgodny z obecnym standardem?

PROSTA ODPOWIEDŹ

Standard nie dopuszcza zmiennoprzecinkowych jako argumentów szablonowych innych niż typowe , o których można przeczytać w poniższej sekcji standardu C ++ 11;

14.3.2 / 1 Argumenty inne niż typowe w szablonie [temp.arg.nontype]

Argument szablonowy dla parametru szablonowego innego niż typowy i inny niż szablonowy to:

• dla nietypowego parametru-szablonu o typie całkowitym lub wyliczeniowym, przekształcone wyrażenie stałe (5.19) typu parametr-szablon;

• nazwa parametru szablonu innego niż typ; lub

• wyrażenie stałe (5.19), które wyznacza adres obiektu ze statycznym czasem trwania i powiązaniem zewnętrznym lub wewnętrznym lub funkcją z połączeniem zewnętrznym lub wewnętrznym, w tym szablony funkcji i identyfikatory szablonów funkcji, ale z wyłączeniem niestatycznych składowych klas, wyrażone (ignorując nawiasy) jako & id-wyrażenie, z tą różnicą, że & można pominąć, jeśli nazwa odnosi się do funkcji lub tablicy, i należy go pominąć, jeśli odpowiedni parametr szablonu jest odniesieniem; lub

• wyrażenie stałe, którego wynikiem jest wartość wskaźnika zerowego (4.10); lub

• wyrażenie stałe, którego wynikiem jest pusta wartość wskaźnika elementu członkowskiego (4.11); lub

• wskaźnik do pręta wyrażony jak opisano w 5.3.1.

Ale… ale… DLACZEGO !?

Wynika to prawdopodobnie z faktu, że obliczeń zmiennoprzecinkowych nie można przedstawić w dokładny sposób. Gdyby było dozwolone, mogłoby / spowodowałoby błędne / dziwne zachowanie podczas robienia czegoś takiego;

func<1/3.f> (); 
func<2/6.f> ();

Chcieliśmy wywołać tę samą funkcję dwa razy, ale może tak nie być, ponieważ nie ma gwarancji, że reprezentacja zmiennoprzecinkowa dwóch obliczeń będzie dokładnie taka sama.

Jak przedstawiłbym wartości zmiennoprzecinkowe jako argumenty szablonu?

Ze C++11można napisać całkiem zaawansowanych stałym wyrażeń ( constexpr ), które mogłyby obliczyć licznik / mianownik pływającej czasie wartość kompilacji, a następnie przekazać te dwa odsunięte całkowitych.

Pamiętaj, aby zdefiniować jakiś rodzaj progu, aby wartości zmiennoprzecinkowe blisko siebie dawały ten sam licznik / mianownik , w przeciwnym razie jest to trochę bezcelowe, ponieważ wtedy da ten sam wynik wspomniany wcześniej jako powód, aby nie zezwalać na wartości zmiennoprzecinkowe jako inne niż typ argumenty szablonu .

Wystarczy podać jeden z powodów, dla których jest to ograniczenie (przynajmniej w obecnym standardzie).

Podczas dopasowywania specjalizacji szablonu kompilator dopasowuje argumenty szablonu, w tym argumenty inne niż typowe.

Ze swej natury wartości zmiennoprzecinkowe nie są dokładne, a ich implementacja nie jest określona przez standard C ++. W rezultacie trudno jest zdecydować, kiedy dwa argumenty zmiennoprzecinkowe nietypowe naprawdę pasują do siebie:

template <float f> void foo () ;

void bar () {
    foo< (1.0/3.0) > ();
    foo< (7.0/21.0) > ();
}

Wyrażenia te niekoniecznie generują ten sam „wzorzec bitowy”, więc nie byłoby możliwe zagwarantowanie, że używają tej samej specjalizacji - bez specjalnego sformułowania, które to obejmuje.

Rzeczywiście, nie można używać literałów typu float jako parametrów szablonu. Patrz sekcja 14.1 („Parametr szablonu inny niż typ powinien mieć jeden z następujących (opcjonalnie kwalifikowanych jako CV) typów…”) normy.

Możesz użyć odwołania do float jako parametru szablonu:

template <class T, T const &defaultValue>
class GenericClass

.
.

float const c_four_point_six = 4.6; // at global scope

.
.

GenericClass < float, c_four_point_six> gcFlaot;

Umieść parametr (y) w ich własnej klasie jako constexprs. W rzeczywistości jest to podobne do cechy, ponieważ parametryzuje klasę za pomocą zestawu liczb zmiennoprzecinkowych.

class MyParameters{
    public:
        static constexpr float Kd =1.0f;
        static constexpr float Ki =1.0f;
        static constexpr float Kp =1.0f;
};

a następnie utwórz szablon, przyjmując typ klasy jako parametr

  template <typename NUM, typename TUNING_PARAMS >
  class PidController {

      // define short hand constants for the PID tuning parameters
      static constexpr NUM Kp = TUNING_PARAMS::Kp;
      static constexpr NUM Ki = TUNING_PARAMS::Ki;
      static constexpr NUM Kd = TUNING_PARAMS::Kd;

      .... code to actually do something ...
};

a potem użyj go tak ...

int main (){
    PidController<float, MyParameters> controller;
    ...
    ...
}

Dzięki temu kompilator może zagwarantować, że dla każdego wystąpienia szablonu z tym samym pakietem parametrów zostanie utworzone tylko jedno wystąpienie kodu. To omija wszystkie problemy i możesz używać pływaków i podwajać jako constexpr wewnątrz klasy szablonowej.

Jeśli możesz mieć stałą wartość domyślną dla typu, możesz utworzyć typ, aby zdefiniować go jako stałą i wyspecjalizować go w razie potrzeby.

template <typename T> struct MyTypeDefault { static const T value; };
template <typename T> const T MyTypeDefault<T>::value = T();
template <> struct MyTypeDefault<double> { static const double value; };
const double MyTypeDefault<double>::value = 1.0;

template <typename T>
class MyType {
  public:
    MyType() { value = MyTypeDefault<T>::value; }
  private:
    T value;
 };

Jeśli masz C ++ 11, możesz użyć constexpr podczas definiowania wartości domyślnej. W C ++ 14 MyTypeDefault może być zmienną szablonu, która jest nieco czystsza pod względem składniowym.

//C++14
template <typename T> constexpr T MyTypeDefault = T();
template <> constexpr double MyTypeDefault<double> = 1.0;

template <typename T>
class MyType {
  private:
    T value = MyTypeDefault<T>;
 };

Inne odpowiedzi dają dobre powody, dla których prawdopodobnie nie chcesz parametrów szablonu zmiennoprzecinkowego, ale prawdziwym IMO hamującym transakcje jest to, że równość przy użyciu '==' i równości bitowej to nie to samo:

1. -0.0 == 0.0, ale 0.0i -0.0nie są równe bitowo

2. NAN != NAN

Żaden rodzaj równości nie jest dobrym rozwiązaniem dla równości typów: oczywiście, punkt 2. sprawia, że ​​użycie ==równości typów jest nieprawidłowe. Zamiast tego można by użyć równości bitowej, ale wtedy x != ynie oznacza to MyClass<x>i MyClass<y>są to różne typy (przez 2.), co byłoby raczej dziwne.

Zawsze możesz to udawać ...

#include <iostream>

template <int NUM, int DEN>
struct Float
{
    static constexpr float value() { return (float)NUM / (float)DEN; }
    static constexpr float VALUE = value();
};

template <class GRAD, class CONST>
struct LinearFunc
{
    static float func(float x) { return GRAD::VALUE*x + CONST::VALUE; }
};


int main()
{
    // Y = 0.333 x + 0.2
    // x=2, y=0.866
    std::cout << " func(2) = "
              << LinearFunc<Float<1,3>, Float<1,5> > ::func(2) << std::endl;
}

Ref: http://code-slim-jim.blogspot.jp/2013/06/c11-no-floats-in-templates-wtf.html

Jeśli nie potrzebujesz podwójnego, aby był stałą czasu kompilacji, możesz przekazać go jako wskaźnik:

#include <iostream>

extern const double kMyDouble = 0.1;;

template <const double* MyDouble>
void writeDouble() {
   std::cout << *MyDouble << std::endl; 
}

int main()
{
    writeDouble<&kMyDouble>();
   return 0;
}

Począwszy od C ++ 20 jest to możliwe .

To również daje odpowiedź na pierwotne pytanie:

Why can't I use float value as a template parameter?

Ponieważ nikt jeszcze tego nie wdrożył w standardzie. Nie ma żadnego podstawowego powodu.

W C ++ 20 parametrach szablonów innych niż typowe mogą teraz być zmiennoprzecinkowe, a nawet obiekty klas.

Istnieją pewne wymagania dotyczące obiektów klas (muszą być typem literału ) i spełniają inne wymagania, aby wykluczyć patologiczne przypadki, takie jak operator zdefiniowany przez użytkownika == ( Szczegóły ).

Możemy nawet użyć auto

template <auto Val>
struct Test {
};

struct A {};
static A aval;
Test<aval>  ta;
Test<A{}>  ta2;
Test<1.234>  tf;
Test<1U>  ti;

Zauważ, że GCC 9 (i 10) implementuje parametry szablonu inne niż klasowe, ale jeszcze nie dla liczb zmiennoprzecinkowych .

Jeśli chcesz reprezentować tylko stałą precyzję, możesz użyć takiej techniki, aby przekonwertować parametr float na wartość int.

Na przykład tablicę ze współczynnikiem wzrostu 1,75 można utworzyć w następujący sposób, zakładając 2 cyfry dokładności (podzielenie przez 100).

template <typename _Kind_, int _Factor_=175>
class Array
{
public:
    static const float Factor;
    _Kind_ * Data;
    int Size;

    // ...

    void Resize()
    {
         _Kind_ * data = new _Kind_[(Size*Factor)+1];

         // ...
    }
}

template<typename _Kind_, int _Factor_>
const float Array<_kind_,_Factor_>::Factor = _Factor_/100;

Jeśli nie podoba ci się reprezentacja 1,75 jako 175 na liście argumentów szablonu, zawsze możesz owinąć ją jakimś makrem.

#define FloatToIntPrecision(f,p) (f*(10^p))

template <typename _Kind_, int _Factor_=FloatToIntPrecision(1.75,2)>
// ...