C ++: template & lt; typename T, T t & gt; и создание экземпляра с помощью float [duplicate]

Оберните параметр (ы) в своем классе как constexprs. Эффективно это похоже на черту, поскольку она параметризует класс с набором поплавков.

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

, а затем создает шаблон, в котором используется тип класса в качестве параметра

  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 ...
};

а затем использовать его так ...

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

Это позволяет компилятору гарантировать, что для каждого экземпляра шаблона с одним и тем же пакетом параметров создается только один экземпляр кода. Это касается всех проблем, и вы можете использовать float и doubles как constexpr внутри шаблонного класса.

Вы всегда можете подделать его ...

#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;
}

Ссылка: http://code-slim-jim.blogspot.jp/2013/06/c11-no-floats- в-шаблоны-wtf.html

Если вы хотите представлять только фиксированную точность, то вы можете использовать такую ​​технику, чтобы преобразовать параметр float в int.

Например, может быть создан массив с коэффициентом роста 1,75 следующим образом, предполагая 2 цифры точности (разделите на 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;

Если вам не нравится представление 1,75 как 175 в списке аргументов шаблона, вы всегда можете перенести его в некоторый макрос.

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

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

Если у вас нормально фиксированное значение по умолчанию для типа, вы можете создать тип, чтобы определить его как константу и специализировать его по мере необходимости.

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;
 };

Если у вас есть C ++ 11, вы можете используйте constexpr при определении значения по умолчанию. С C ++ 14 MyTypeDefault может быть переменной шаблона, которая синтаксически немного чиста.

//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>;
 };

Действительно, вы не можете использовать float-литералы в качестве параметров шаблона. См. Раздел 14.1 («Параметр шаблона, не относящийся к типу, должен иметь один из следующих (необязательно cv-квалифицированных) типов ...») стандарта.

Вы можете использовать ссылку на float в качестве параметра шаблона:

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;

Просто для того, чтобы указать одну из причин, почему это ограничение (по крайней мере в текущем стандарте).

При сопоставлении специализированных шаблонов компилятор сопоставляет аргументы шаблона, в том числе аргументы не-типа.

По самой своей природе значения с плавающей запятой не являются точными, и их реализация не указана стандартом C ++. В результате трудно решить, когда два аргумента non-типа с плавающей запятой действительно соответствуют:

template <float f> void foo () ;

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

Эти выражения не обязательно приводят к одному и тому же «битовому шаблону», и поэтому было бы невозможно гарантировать что они использовали ту же специализацию - без специальной формулировки, чтобы покрыть это.

Если вам не нужно, чтобы double являлся константой времени компиляции, вы можете передать ее как указатель:

#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;
}

ПРОСТОЙ ОТВЕТ

Стандарт не допускает плавающие точки как шаблонные аргументы не-типа , о которых можно прочитать в следующем разделе C ++ 11,

14.3.2 / 1 & nbsp; & nbsp; & nbsp; & nbsp; Шаблон не-типа аргументов & nbsp; & nbsp; & nbsp; & nbsp; [temp.arg.nontype]

Аргумент шаблона для непигового шаблона-шаблона без шаблона должен быть одним из:

• для не-типа шаблон-параметр интегрального или перечисляемого типа, преобразованное константное выражение (5.19) типа шаблона-параметра;
• имя непигового шаблона-параметра; или
• константное выражение (5.19), которое обозначает адрес объекта со статической продолжительностью хранения и внешней или внутренней связью или функцию с внешней или внутренней связью, включая шаблоны функций и идентификаторы шаблонов функций, -статические члены класса, выраженные (игнорируя круглые скобки) как & amp; id-expression, за исключением того, что & amp; может быть опущено, если имя относится к функции или массиву и должно быть опущено, если соответствующий шаблон-параметр является ссылкой; или
• константное выражение, которое вычисляет значение нулевого указателя (4.10); или
• константное выражение, которое вычисляет значение указателя пустого элемента (4.11); или
• указатель на элемент, выраженный как описано в 5.3.1.

---

Но .. но .. ПОЧЕМУ??

Вероятно, это связано с тем, что вычисления с плавающей запятой не могут быть представлены точно. Если это было разрешено, это могло бы / приводило бы к ошибочному / странному поведению при выполнении чего-то такого:

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

Мы хотели дважды вызвать ту же функцию, но это может быть не так, поскольку представление с плавающей запятой

---

Как я представляю значения с плавающей запятой в качестве аргументов шаблона?

С помощью C++11 вы могли бы написать некоторые довольно продвинутые константные выражения ( constexpr ), которые вычисляли числитель / знаменатель времени компиляции с плавающим значением, а затем передавали эти два в виде отдельных целых аргументов.

Не забудьте определить какой-то порог, так что значения с плавающей запятой, близкие друг к другу, дают один и тот же числитель / знаменатель , в противном случае это бесполезно, так как тогда он даст тот же результат, который ранее упоминался как причина не разрешить значения плавающей запятой в качестве аргументов шаблона непигового типа .