class MyBigClass
{
  int m_mySmallValue;
  ...

  MyBigClass();
  MyBigClass(X x, Y y, Z z);
  ... и еще куча конструкторов

};

MyBigClass::MyBigClass(xxxx) : ......
  // а про малюсенькое данное забыли :(
{
}

template< class T, T i = 0 >
class auto_value
{
  T t_;
public:
  typedef T data_t;
  typedef auto_value& self_t;

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

  // конструктор с 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; }
};

class MyBigClass
{
  auto_value<bool /* , false */ > m_bEnabled;
  ...

public:
  MyBigClass() {} // все члены инициализируются сами - как сумеют
  ...
  bool isEnabled() { return m_bEnabled; } // получим false, а не 0xCDCDCDCD
  void setEnabled(bool b) { m_bEnabled = b; }
  ...
};

...
К>  inline operator T  () const { return t_; }
...
К>

inline operator T const &() const { return t_; }

К>  // операторы присваивания

К>>  inline operator T  () const { return t_; }

C>inline operator T const &() const { return t_; }

  inline operator const T& () const { return t_; }

К>>  // операторы присваивания
C>

  inline self_t operator ++ ()    { ++t_; return *this; } // префиксный
  inline data_t operator ++ (int) { return t_++; } // постфиксный

К>template< class T, T i = 0 >
К>class auto_value

template< class T, class I = T, I i = 0 >
class auto_value_ex
{
  .....
};

template< class T, T i = 0 >
class auto_value : public auto_value_ex< T, T, i >
{
  .....
};

C>>inline operator T const &() const { return t_; }
К>

operator T const &() const;

auto_value<int, 3> const a;
int const &b = a;

operator T() const;

C>>>inline operator T const &() const { return t_; }

operator const T&() const

class CChannel ...
{
  ...
  auto_value<bool> m_bEnabled;
  ...
public:
  STDMETHOD(notifyReceiver)()
  {
    if( !m_bEnabled )
// error C2675: unary '!' :
// 'class auto_value<bool,0>' does not define this operator or a conversion to a type
// acceptable to the predefined operator
      ...
  }
  ...
};

operator T() const

  operator T () const { return t_; }
  operator const T& () const { return t_; }
  operator T& () { return t_; }

К>...
К>    if( !m_bEnabled )
К>...
К>

К>  operator T () const { return t_; }
К>  operator const T& () const { return t_; }
К>  operator T& () { return t_; }
К>

inline operator T const &() const { return t_; }
inline operator T () const { return t_; }

auto_value<bool> b;
!b;

    inline operator T const &() const { return t_; }
#ifdef _MSC_VER 
    inline operator T() const { return t_; }  
#endif

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

T f();

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

ME>T f();
ME>

auto_value<int> x;

const int *y = & x.data();

template< class POD >
struct auto_pod : public POD
{
  auto_pod() { memset( static_cast<POD*>(this), 0, sizeof(POD) ); }
};

#define _offsetof(type, field)    ((int)&((type*)0)->field)

template< class POD >
struct auto_pod : public POD
{
  struct _PODSize : POD { char _Dummy; };

  auto_pod() { memset( static_cast<POD*>(this), 0, _offsetof(_PODSize, _PODSize::_Dummy)); }
};

struct aa
{
    __int64    i1;
    __int8    i2;
};

16 == sizeof(aa);

БП>#define _offsetof(type, field)    ((int)&((type*)0)->field)

БП>template< class POD >
БП>struct auto_pod : public POD
БП>{
БП>  struct _PODSize : POD { char _Dummy; };

     inline static size_t sizeofpod() { return _offsetof(_PODSize, _PODSize::_Dummy); }

БП>  auto_pod() { memset( static_cast<POD*>(this), 0, sizeofpod()); }

     auto_pod(const POD& pod) { memcpy( static_cast<POD*>(this), &pod, sizeofpod() ); }

     void operator=(const POD& pod) { memcpy( static_cast<POD*>(this), &pod, sizeofpod() ); }
БП>};

template< class T >
struct struct_traits
{
  .....
  enum { isNotEmptyPOD = ..... };
  .....

  template < bool b >
  class _auto_pod_impl : public T
  { };

  template <>
  class _auto_pod_impl<false> // cпециальная версия для структур с нулевым размером
  : public T // для возможности преобразования типов
  {
    _auto_pod_impl() {}
    _auto_pod_impl(const T&) {}
    void operator=(const T&) {}
  };

  typedef _auto_pod_impl< isNotEmptyPOD > auto_pod;
};

template< class T >
class auto_pod : struct_traits<T>::auto_pod
{ };

БП>struct aa
БП>{
БП>    __int64    i1;
БП>    __int8    i2;
БП>};

БП>16 == sizeof(aa);
БП>

#define _offsetof(type, field)    ((int)&((type*)0)->field)