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

К>Вот, достало ловить ошибки с неинициализованными членами больших классов, вида

Давно хотел спросить: почему бы не переделать слегка этот класс:

template< class T >
class auto_value
{
  T t_;
public:
  typedef T data_t;
  typedef auto_value& self_t;

  // конструктор по умолчанию - главное достоинство этой тулзы
  inline auto_value() : t_(T()) {}

  // конструктор с 1 параметром (в том числе - конструктор копирования)
  template< class V >
  inline auto_value(V v) : t_(v) {}

  // доступ к данному
  inline const T& data() const { return t_; }
  inline T& data() { return t_; }

  // считается, что исходный тип - простой
  inline operator T  () const { return t_; }
  inline operator T& ()       { return t_; }

  // операторы присваивания
  template< class V > inline self_t operator =   (V v) { t_ =   v; return *this; }
  template< class V > inline self_t operator +=  (V v) { t_ +=  v; return *this; }
  template< class V > inline self_t operator -=  (V v) { t_ -=  v; return *this; }
  template< class V > inline self_t operator *=  (V v) { t_ *=  v; return *this; }
  template< class V > inline self_t operator /=  (V v) { t_ /=  v; return *this; }
  template< class V > inline self_t operator %=  (V v) { t_ %=  v; return *this; }
  template< class V > inline self_t operator &=  (V v) { t_ &=  v; return *this; }
  template< class V > inline self_t operator |=  (V v) { t_ |=  v; return *this; }
  template< class V > inline self_t operator ^=  (V v) { t_ ^=  v; return *this; }
  template< class V > inline self_t operator <<= (V v) { t_ <<= v; return *this; }
  template< class V > inline self_t operator >>= (V v) { t_ >>= v; return *this; }
};

Таким образом мы получим здоровую семантику нулевого объекта (а не объекта, равного нулю). Плюс поддержку не только интегральных типов.

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


O>Таким образом мы получим здоровую семантику нулевого объекта (а не объекта, равного нулю). Плюс поддержку не только интегральных типов.

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

class BigClass
{
...
  auto_value<int, 1> m_day;
  auto_value<int, 12> m_month;
  auto_value<int, 2005> m_year;
...
};

и забить на инициализацию данных членов в конструкторах

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

O>Давно хотел спросить: почему бы не переделать слегка этот класс:

<>

O>Таким образом мы получим здоровую семантику нулевого объекта (а не объекта, равного нулю). Плюс поддержку не только интегральных типов.

Класс специально был написан для того, чтобы указывать начальное значение в объявлении объекта.
Наиболее часто я им пользуюсь с булевыми переменными и различными enum-ами, реже — с целыми числами.

Для структур нет смысла делать полнофункциональный auto_value.
По-видимому, нужно вообще семейство обёрток — для интегральных, для числовых, для структур.

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

К>Класс специально был написан для того, чтобы указывать начальное значение в объявлении объекта.
К>Наиболее часто я им пользуюсь с булевыми переменными и различными enum-ами, реже — с целыми числами.

что реально пользуешся? я думал такие приколы это все теоретические изыскания...
а как же тогда быть со специализациями типа:

template<class T> void function(T t) {
    ...
}


template<> void function(int t) {
    ...
}

...

auto_value<int, 1> val;

...

function(val); // вызовется не то, что нужно

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

Y>что реально пользуешся? я думал такие приколы это все теоретические изыскания...

Реально.

Y>а как же тогда быть со специализациями типа:

Если семантика специализации не отличается от семантики первичного шаблона — то будет только потеря производительности (ради чего написана специализация).

Если же нужно добиться правильной работы — пишем шлюз

template<class T> void foo(T x) { ..... }
template<> void foo(int x) { ..... }
template<> void foo(bool x) { ..... }

template<class T, T N> void foo(auto_value<T,N> x) { foo((T)x); }