float в аргументе шаблона - C/C++

Есть идея сделать как-нибудь так:

template<typename T, typename TFloatValueStruct>
class X
{
 bool b;
public:
 X(T t)
 {
  b = t==TFloatValueStruct::value;
 }
};

А TFloatValueStruct описать как-нибудь так:

struct MyFloatValue
{ static const float value; }
const float MyFloatValue::value = 10.1;

X<float,MyFloatValue> x;

Неудобство заключается в том что нужно создавать дополнительный класс.

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

Вроде такого :

X<float,
  float_value_wrapper<false, // +
      10,0, // 10*10^0
      1,1 // 1/10^1
  >
> x; // + (10*10^0 + 1/10^1) = + 10.1

Примерная реализация

template<typename T,
         bool t_t_bminus,
         size_t t_n1,
         int t_pow1,
         size_t t_n2,
         int t_pow2
        >
struct nonintegral_value_wrapper
{
 static const T value;
};

template<typename T,
         bool t_t_bminus,
         size_t t_n1,
         size_t t_pow1,
         size_t t_n2,
         size_t t_pow2
        >
const T nonintegral_value_wrapper<T,t_bminus,t_n1,t_pow1,t_n2,t_pow2>::value =
 (
  static_cast<T>(t_n1) * static_cast<T>(pow10_t<t_pow1>::value)  // t_n1*(10^t_pow1) - целая часть
  +
  static_cast<T>(t_n2) / static_cast<T>(pow10_t<t_pow2>::value)  // t_n2/(10"t_pow2) - дробная часть
 )
 *
 (t_bminus?static_cast<T>(-1):static_cast<T>(+1)); // отрицательное или положительное число

// для float
template<bool t_t_bminus,
         size_t t_n1,
         size_t t_pow1,
         size_t t_n2,
         size_t t_pow2
        >
struct float_value_wrapper :
 public nonintegral_value_wrapper
 <
  float,
  t_bminus,
  t_n1,
  t_pow1,
  t_n2,
  t_pow2
 >
{};

// для double
template<bool t_t_bminus,
         size_t t_n1,
         size_t t_pow1,
         size_t t_n2,
         size_t t_pow2
        >
struct double_value_wrapper :
 public nonintegral_value_wrapper
 <
  double,
  t_bminus,
  t_n1,
  t_pow1,
  t_n2,
  t_pow2
 >
{};

Буду рад комментариям.

_nn_ wrote:

[]

> Буду рад комментариям.

Мне ни разу не приходилось использовать вещественные числа в качестве параметров шаблона и я не могу придумать для этого применения. Было бы интересно увидеть, что позволяет твоя штука, и чем она лучше чем:

template<double const* d> class some { /*...*/ };
extern double const d(22.0/7);
some<&d> s;

--
Maxim Yegorushkin

Posted via RSDN NNTP Server 1.9 gamma

Здравствуйте, MaximE, Вы писали:

ME>_nn_ wrote:

ME>[]

>> Буду рад комментариям.

ME>Мне ни разу не приходилось использовать вещественные числа в качестве параметров шаблона и я не могу придумать для этого применения. Было бы интересно увидеть, что позволяет твоя штука, и чем она лучше чем:

ME>

ME>template<double const* d> class some { /*...*/ };
ME>extern double const d(22.0/7);
ME>some<&d> s;
ME>

ME>--
ME>Maxim Yegorushkin

Ну скажем для такого случая

template<typename T, typename TMin, typename TMax, typename TLess=std::less<T> >
class limit_t
{
    T t;
public:
    limit_t() : T(TMin::value) {}

    limit_t& operator=(const limit_t& r)
    { set_data(r.t); return *this; }

    void set_data(const T& set_value)
    {
        if(TLess(set_value,TMin::value))
            throw std::out_of_range("value is less than minimum");
        if(TLess(TMax::value,set_value)
            throw std::out_of_range("value is more than maximum");
        t=r.t;
        return *this;
    }
};

template<typename T, T t>
struct integral_value_wrapper
{ static const T value = t; };

// nonintegral_value_wrapper
// ...

class some_class
{
public:
    limit_t<
        int,
        integral_value_wrapper<int,10>,
        integral_value_wrapper<int,20>
    >limit_int_10_to_20;
    limit_t<
        double,
        nonintegral_value_wrapper<double,10,1,1,1>,
        nonintegral_value_wrapper<double,20,1,1,1>
    >limit_double_10_1_to_20_1;
};

Выглядит немного некрасиво, но позволяет не создавать дополнительных переменных.

ME>template<double const* d> class some { /*...*/ };
ME>extern double const d(22.0/7);
ME>some<&d> s;
ME>

ME>--
ME>Maxim Yegorushkin

Ну так все таки, как же запараметризировать шаблон вещественным числом, пример может быть самый простой, например как сконструировать auto_value<float>, все таки вещественные поля класса так же как и интегральные не инициализируются автоматически.

Здравствуйте, Batiskaf, Вы писали:

B>Здравствуйте, MaximE, Вы писали:

ME>>_nn_ wrote:

ME>>[]

>>> Буду рад комментариям.

ME>>Мне ни разу не приходилось использовать вещественные числа в качестве параметров шаблона и я не могу придумать для этого применения. Было бы интересно увидеть, что позволяет твоя штука, и чем она лучше чем:

ME>>

ME>>template<double const* d> class some { /*...*/ };
ME>>extern double const d(22.0/7);
ME>>some<&d> s;
ME>>

ME>>--
ME>>Maxim Yegorushkin

B>Ну так все таки, как же запараметризировать шаблон вещественным числом, пример может быть самый простой, например как сконструировать auto_value<float>, все таки вещественные поля класса так же как и интегральные не инициализируются автоматически.

Напрямую на текущий момент никак, только в обход.

Можно вместо числа передавать класс, где будет это число в виде статической перемменной.
Можно использовать указатель на глобальную переменную, но надо для каждого значения создавать глобальную переменную.

А все же чем не нравится через класс ?

template<typename T, typename TInit>
class auto_value_t {...};

template<typename T, T t_init>
class auto_value : public auto_value_t<T,value_wrapper<t_init> > {...};


auto_value<int,10> int_10;

auto_value_t<int,value_wrapper<10> > int_wrapper_10;

auto_value_t<double, value_wrapper<double,22,1,7,1> > double_wrapper_22_7;

Здравствуйте, _nn_, Вы писали:

__>Здравствуйте, Batiskaf, Вы писали:

B>>Здравствуйте, MaximE, Вы писали:

ME>>>_nn_ wrote:

ME>>>[]

>>>> Буду рад комментариям.

ME>>>Мне ни разу не приходилось использовать вещественные числа в качестве параметров шаблона и я не могу придумать для этого применения. Было бы интересно увидеть, что позволяет твоя штука, и чем она лучше чем:

ME>>>

ME>>>template<double const* d> class some { /*...*/ };
ME>>>extern double const d(22.0/7);
ME>>>some<&d> s;
ME>>>

ME>>>--
ME>>>Maxim Yegorushkin

B>>Ну так все таки, как же запараметризировать шаблон вещественным числом, пример может быть самый простой, например как сконструировать auto_value<float>, все таки вещественные поля класса так же как и интегральные не инициализируются автоматически.

__>Напрямую на текущий момент никак, только в обход.

__>Можно вместо числа передавать класс, где будет это число в виде статической перемменной.
__>Можно использовать указатель на глобальную переменную, но надо для каждого значения создавать глобальную переменную.

__>А все же чем не нравится через класс ?

__>

__>template<typename T, typename TInit>
__>class auto_value_t {...};

__>template<typename T, T t_init>
__>class auto_value : public auto_value_t<T,value_wrapper<t_init> > {...};


__>auto_value<int,10> int_10;

__>auto_value_t<int,value_wrapper<10> > int_wrapper_10;

__>auto_value_t<double, value_wrapper<double,22,1,7,1> > double_wrapper_22_7;
__>

Вот не понял с value_wrapper-ом это:

auto_value_t<double, value_wrapper<double,22,1,7,1> > double_wrapper_22_7;

мы же как раз пытаемся избежать передачи вещественных значений через аргументы шаблона.

Здравствуйте, Batiskaf, Вы писали:

B>Здравствуйте, _nn_, Вы писали:

__>>Здравствуйте, Batiskaf, Вы писали:

B>>>Здравствуйте, MaximE, Вы писали:

ME>>>>_nn_ wrote:

ME>>>>[]

>>>>> Буду рад комментариям.

ME>>>>Мне ни разу не приходилось использовать вещественные числа в качестве параметров шаблона и я не могу придумать для этого применения. Было бы интересно увидеть, что позволяет твоя штука, и чем она лучше чем:

ME>>>>

ME>>>>template<double const* d> class some { /*...*/ };
ME>>>>extern double const d(22.0/7);
ME>>>>some<&d> s;
ME>>>>

ME>>>>--
ME>>>>Maxim Yegorushkin

B>>>Ну так все таки, как же запараметризировать шаблон вещественным числом, пример может быть самый простой, например как сконструировать auto_value<float>, все таки вещественные поля класса так же как и интегральные не инициализируются автоматически.

__>>Напрямую на текущий момент никак, только в обход.

__>>Можно вместо числа передавать класс, где будет это число в виде статической перемменной.
__>>Можно использовать указатель на глобальную переменную, но надо для каждого значения создавать глобальную переменную.

__>>А все же чем не нравится через класс ?

__>>

__>>template<typename T, typename TInit>
__>>class auto_value_t {...};

__>>template<typename T, T t_init>
__>>class auto_value : public auto_value_t<T,value_wrapper<t_init> > {...};


__>>auto_value<int,10> int_10;

__>>auto_value_t<int,value_wrapper<10> > int_wrapper_10;

__>>auto_value_t<double, value_wrapper<double,22,1,7,1> > double_wrapper_22_7;
__>>

B>Вот не понял с value_wrapper-ом это:

B>

B>auto_value_t<double, value_wrapper<double,22,1,7,1> > double_wrapper_22_7;
B>

value_wrapper у это как бы выбор автоматический между nonintergal_value_wrapper и integral_value_wrapper

// nonintegral_value_wrapper - из предыдущего поста
template<typename T,
         bool t_bminus
         size_t t_n1,
         int t_pow1,
         size_t t_n2,
         int t_pow2,
        >
struct nonintegral_value_wrapper
{...};

template<typename T, T t_value>
struct integral_value
{ static T value = t_value; };

B>мы же как раз пытаемся избежать передачи вещественных значений через аргументы шаблона.
Как раз в auto_value мы пытается и передать значения в шаблоне.
Ведь класс и создался чтобы не писать такое:

struct x
{
 float f;
 double d;
 x() : f(0), d(0) {}
 x(int) : f(0), d(0) {}
 x(char) : f(0), d(0) {}
 x(double) : f(0), d(0) {}
 //...
};

А такое:

struct x
{
 auto_value_t<float, nonintegral_value_wrapper<float, false, 0, 0, 0, 0> > f;
 auto_value_t<double, nonintegral_value_wrapper<double, false, 0, 0, 0, 0> > d;

 x() {}
 x(int) {}
 x(char) {}
 x(double) {}
};

Или я вас не понял правильно

От:	_nn_	www.nemerleweb.com
Дата:	17.10.04 13:31
Оценка:

	От:	MaximE
	Дата:	17.10.04 17:36
	Оценка:

От:	_nn_	www.nemerleweb.com
Дата:	18.10.04 11:24
Оценка:

От:	Batiskaf	http://www.mult.ru/
Дата:	27.10.04 09:51
Оценка:

От:	_nn_	www.nemerleweb.com
Дата:	27.10.04 11:53
Оценка: