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)

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

    auto_value<int> i = 0;
    auto_value<int> j = i;

CStructPath::CStructPath(const CStructPath& sp)/*:
startIndex(sp.startIndex)*/
{
    int i = sp.startIndex;
    startIndex = i;
//    finishIndex = sp.finishIndex;
//    bterminate = sp.bterminate;
//    bcreate = sp.bcreate;
}

CStructPath::CStructPath(const CStructPath& sp):
    startIndex(sp.startIndex.data())
{}

auto_value<int> fI = 7;
int i = 5;
i = fI;

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

#define offsetof(s,m)   (size_t)&(((s *)0)->m)

18.1.5
The macro offsetof accepts a restricted set of type arguments in this International Standard. type shall be a POD structure or a POD union (clause 9). The result of applying the offsetof macro to a field that is a static data member or a function member is undefined.

class Foo
{
    struct AllMyStaff
    {
        Bar bar;
        Foobar foobar;
        AllMyStaff() : bar( barParam ), foobar( foobarParam ) {}
    } allMyStaff;
};

class Foo
{
    Bar bar;
    Foobar foobar;
    struct AllMyStaff
    {
        AllMyStaff() 
        {
            bar = Bar(barParam);
            foobar = Foobar(foobarParam);
        }
    } allMyStaff;
};

// .h
struct Foo
{
    //...
    static Foo * Make(FooParam);
};

//.cpp
namespace
{
    class FooInitializer
    {
        FooInitializer() {...};
    };
    class FooImpl : public Foo, private FooInitilizer
    {
    //...
    };
}
Foo * Foo::Make(FooParam)
{
    return new FooImpl(FooParam);
}

template<class V> auto_value(const V& v) : t_(v) {}
template<T j> auto_value(const auto_value<T,j>& v) : t_(v.data()) {}

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

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

struct aa
{
    __int8    i2;
    __int64    i1;
};

template<class T, T i = T()>
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; }

  // по умалчанию
  inline void default_() { t_=i; }
};

#define BEGIN_AUTO_MAP() \
    public: \
    void default_() \
    {

#define AUTO_VALUE(v) \
    v.default_();

#define END_AUTO_MAP() \
    }

class Test
{
 auto_value<int,5> i;
 auto_value<char,'a'> c;

 BEGIN_AUTO_MAP()
  AUTO_VALUE(i)
  AUTO_VALUE(c)
 END_AUTO_MAP()
};


void main()
{
 Test test;
 
 test.i=10;
 test.c='f';
 
 test.default_();
}

class Hello
{
    auto_value<bool,true> truth_;
    
    Hello() {}
    
    void goodbye() { truth_ = false; }
    
    bool came() const { return truth_; }
};

template<class T>
class pointer
{
  T* p;
public:
  pointer() : p(new T()) {}
  template<class V> pointer(const V& v) : p(new T(v)) {}
  pointer(const pointer<T>& ptr) : p(new T(*ptr)) {}

  ~pointer() { delete p; }

  T& operator*() { return *p; }
  const T& operator*() const { return *p; }

  T* operator->() { return p; }
  const T* operator->() const { return p; }
};

class SuperPuper
{
public:
  SuperPuper() : x_(10), y_(20), z_(30), yes_(true), no_(false), cancel_(false) {}
  SuperPuper(int x, int y, int z) : x_(x), y_(y), z_(z), yes_(true), no_(false), cancel_(false) {}
  SuperPuper(int ync) : x_(10), y_(20), z_(30), yes_(ync==0), no_(ync==1), cancel_(ync==2) {}

private:
  int x_;
  int y_;
  int z_;
  bool yes_, no_, cancel_;
  ...
  ...
  ...
  char c_; // добавили в новой версии, в конструкторы прописать забыли.
};

template<typename T>
class ExtractPtr
{
public:
    typedef T Type;
};

template<typename T>
class ExtractPtr<T*>
{
public:
    typedef T Type;
};

template<typename T,T t_init=0,T t_default=t_init>
class AutoValue
{
    T m_t;
public:
    // Constructor
    AutoValue() : m_t(t_init) {}
    template<class T2>
    AutoValue(T2& t) : m_t(t) {}

    // Data
    const T& Data() const { return m_t; }
    T& Data() { return m_t; }

    // Operators
    // T
    operator const T&() const { return m_t; }
    operator T&() { return m_t; }

    // Functor
    T& operator()() { return m_t; }
    const T& operator()() const { return m_t; }

    // Arithmetic
    template<typename T2> const AutoValue& operator=(const T2& t) { m_t=t; return *this; }
    template<typename T2> const AutoValue& operator+=(const T2& t) { m_t+=t; return *this; }
    template<typename T2> const AutoValue& operator-=(const T2& t) { m_t-=t; return *this; }
    template<typename T2> const AutoValue& operator*=(const T2& t) { m_t*=t; return *this; }
    template<typename T2> const AutoValue& operator/=(const T2& t) { m_t/=t; return *this; }
    template<typename T2> const AutoValue& operator%=(const T2& t) { m_t%=t; return *this; }
    template<typename T2> const AutoValue& operator&=(const T2& t) { m_t&=t; return *this; }
    template<typename T2> const AutoValue& operator|=(const T2& t) { m_t|=t; return *this; }
    template<typename T2> const AutoValue& operator^=(const T2& t) { m_t^=t; return *this; }
    template<typename T2> const AutoValue& operator<<=(const T2& t) { m_t<<=t; return *this; }
    template<typename T2> const AutoValue& operator>>=(const T2& t) { m_t>>=t; return *this; }

    // Compare
    template<typename T2> const bool operator==(const T2& t) const { return m_t==t; }
    template<typename T2> const bool operator!=(const T2& t) const { return m_t!=t; }
    template<typename T2> const bool operator>(const T2& t) const { return m_t>t; }
    template<typename T2> const bool operator>=(const T2& t) const { return m_t>=t; }
    template<typename T2> const bool operator<(const T2& t) const { return m_t<t; }
    template<typename T2> const bool operator<=(const T2& t) const { return m_t<=t; }

    // Increment , Decrement
    const AutoValue& operator++() { ++m_t; return *this; }
    const T& operator++(int) { return m_t++; }
    const AutoValue& operator--() { --m_t; return *this; }
    const T& operator--(int) { return m_t--; }

    // Pointers
    T* operator&() { return &m_t; }
    const T* operator&() const { return &m_t; }
    typename ExtractPtr<T>::Type& operator*() { return *m_t; }
    const typename ExtractPtr<T>::Type& operator*() const { return *m_t; }
    typename ExtractPtr<T>::Type& operator->() { return *m_t; }
    const typename ExtractPtr<T>::Type& operator->() const { return *m_t; }

    // Array
    T& operator[](int index) { return m_t[index]; }
    const T& operator[](int index) const { return m_t[index]; }

    // Functions
    void Reset() { m_t=t_default; }
};

class MyBigClass
{
  auto_value<bool /* , false */ > m_bEnabled;
  limit<auto_value<unsigned short, 5000 > 5000, 25000> m_PortNumber;
  ...

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

template< typename T, size_t min, size_t max>
class limit : public T
{
    public:
    typedef T data_t;
    typedef limit& self_t;

    //default ctor
    inline limit() : T() {}

    // ctor with 1 parameter( including copy constructor)
    template< class V >
    inline limit(V v) : T(v) {}

    //access to data
    inline const T& data() const { return (T&)*this; }
    inline T& data() { return (T&)*this; }

    // means that original type is simple
    operator T () const { return data(); }
    operator const T& () const { return data(); }
    operator T& () { return data(); }

    //assignment operators
    template< class V > inline self_t operator =   (V v) 
    { 
        if( v < min || v > max )
            throw std::out_of_range("new value not in the range");
        data() = v;
        return *this; 
    }
    template< class V > inline self_t operator +=  (V v) 
    {
        T tmp = data();
        tmp +=  v; 
        *this = tmp;
        return *this; 
    }
    template< class V > inline self_t operator -=  (V v) 
    { 
        T tmp = data();
        tmp -=  v; 
        *this = tmp;
        return *this; 
    }
    template< class V > inline self_t operator *=  (V v) 
    { 
        T tmp = data();
        tmp *=  v; 
        *this = tmp;
        return *this; 
    }
    template< class V > inline self_t operator /=  (V v) 
    { 
        T tmp = data();
        tmp /=  v; 
        *this = tmp;
        return *this;
    }
    template< class V > inline self_t operator %=  (V v) 
    { 
        T tmp = data();
        tmp %=  v; 
        *this = tmp;
        return *this;
    }
    template< class V > inline self_t operator &=  (V v) 
    { 
        T tmp = data();
        tmp &=  v; 
        *this = tmp;
        return *this;
    }
    template< class V > inline self_t operator |=  (V v) 
    {     
        T tmp = data();
        tmp |=  v; 
        *this = tmp;
        return *this;
    }
    template< class V > inline self_t operator ^=  (V v) 
    {             
        T tmp = data();
        tmp ^=  v; 
        *this = tmp;
        return *this;
    }
    template< class V > inline self_t operator <<= (V v) 
    {             
        T tmp = data();
        tmp <<=  v; 
        *this = tmp;
        return *this;
    }
    template< class V > inline self_t operator >>= (V v) 
    {             
        T tmp = data();
        tmp >>=  v; 
        *this = tmp;
        return *this;
    }
    //prefix
    inline self_t operator ++ ()    
    { 
        T tmp = data();
        ++tmp;
        *this = tmp;
        return *this;
    }
    //postfix
    inline data_t operator ++ (int) 
    { 
        T tmp = data();
        tmp++; 
        *this = tmp;
        return data();
    }
};

B>template< typename T, size_t min, size_t max>
B>class limit : public T
B>{
B>

template<typename T, T t_min, T t_max, typename TPred = std::less<T> >
class limit_t
// : public T - лучше сделать не наследование, а аггрегацию, чтобы была возможность использовать простой тип, IMHO
{
 T t;
public:
 //...
   inline T& data() { return t; }

   template< class V > inline self_t operator =   (V v) 
    { 
        if( TPed(v, t_min)
            throw std::out_of_range("new value not in the range - less than minimum");
        if( TPred(t_max, v)
            throw std::out_of_range("new value not in the range - more than maximum");
        
        data() = v;
        return *this; 
    }
};

B>>template< typename T, size_t min, size_t max>
B>>class limit : public T
B>>{
B>>

__>template<typename T, T t_min, T t_max, typename TPred = std::less<T> >
__>class limit_t
__>// : public T - лучше сделать не наследование, а аггрегацию, чтобы была возможность использовать простой тип, IMHO
__>{
__> T t;
__>public:
__> //...
__>   inline T& data() { return t; }

__>   template< class V > inline self_t operator =   (V v) 
__>    { 
__>        if( TPred(v, t_min)
__>            throw std::out_of_range("new value not in the range - less than minimum");
__>        if( TPred(t_max, v)
__>            throw std::out_of_range("new value not in the range - more than maximum");
        
__>        data() = v;
__>        return *this; 
__>    }
__>};
__>

limit_t<auto_value<int, 200>, 200, 100000> a;

B>>>template< typename T, size_t min, size_t max>
B>>>class limit : public T
B>>>{
B>>>

__>>template<typename T, T t_min, T t_max, typename TPred = std::less<T> >
__>>class limit_t
__>>// : public T - лучше сделать не наследование, а аггрегацию, чтобы была возможность использовать простой тип, IMHO
__>>{
__>> T t;
__>>public:
__>> //...
__>>   inline T& data() { return t; }

__>>   template< class V > inline self_t operator =   (V v) 
__>>    { 
__>>        if( TPred(v, t_min)
__>>            throw std::out_of_range("new value not in the range - less than minimum");
__>>        if( TPred(t_max, v)
__>>            throw std::out_of_range("new value not in the range - more than maximum");
        
__>>        data() = v;
__>>        return *this; 
__>>    }
__>>};
__>>

B>limit_t<auto_value<int, 200>, 200, 100000> a;
B>

limit<auto_value<unsigned short, 5000 > 5000, 25000> m_PortNumber;

B>>>>limit_t<auto_value<int, 200>, 200, 100000> a;
B>>>>

__>>>Здесь вы говорите обратное от того что сказано вами выше

__>>>А вообще в любом дополнительная функциональность не помешает, кроме того смысл для limit_t<std::string> можно придумать, например для ограничения длины строки

__>>>limit<auto_value<unsigned short, 5000 > 5000, 25000> m_PortNumber;
__>>>

__>>>Ничего

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

enum {def_value = i}; // где i это шаблонный параметр значения по умолчанию

#include <boost/static_assert.hpp>

    BOOST_STATIC_ASSERT( min <= T::def_value );
    BOOST_STATIC_ASSERT( max >= T::def_value );

B>>>>>>limit_t<auto_value<int, 200>, 200, 100000> a;
B>>>>>>

__>>>>>Здесь вы говорите обратное от того что сказано вами выше

__>>>>>А вообще в любом дополнительная функциональность не помешает, кроме того смысл для limit_t<std::string> можно придумать, например для ограничения длины строки

__>>>>>limit<auto_value<unsigned short, 5000 > 5000, 25000> m_PortNumber;
__>>>>>

__>>>>>Ничего

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

B>>enum {def_value = i}; // где i это шаблонный параметр значения по умолчанию
B>>

B>>#include <boost/static_assert.hpp>

B>>    BOOST_STATIC_ASSERT( min <= T::def_value );
B>>    BOOST_STATIC_ASSERT( max >= T::def_value );
B>>

const static T  def_value = i;// где i это шаблонный параметр значения по умолчанию

B>>>>>>>limit_t<auto_value<int, 200>, 200, 100000> a;
B>>>>>>>

__>>>>>>Здесь вы говорите обратное от того что сказано вами выше

__>>>>>>А вообще в любом дополнительная функциональность не помешает, кроме того смысл для limit_t<std::string> можно придумать, например для ограничения длины строки

B>Дык как я погляжу не очень получается придумать, второй день уже придумываем

__>>>>>>limit<auto_value<unsigned short, 5000 > 5000, 25000> m_PortNumber;
__>>>>>>

__>>>>>>Ничего

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

B>>>enum {def_value = i}; // где i это шаблонный параметр значения по умолчанию
B>>>

B>>>#include <boost/static_assert.hpp>

B>>>    BOOST_STATIC_ASSERT( min <= T::def_value );
B>>>    BOOST_STATIC_ASSERT( max >= T::def_value );
B>>>

B>Ну ты нудник!

B>const static T  def_value = i;// где i это шаблонный параметр значения по умолчанию
B>

B>Кстати, хорошо что вспомнил, на VC7 второй темплейт параметр с float не проходит, The C++ standard does not allow floating point non-type template parameters. К барьеру, мистер Кодт!

template<typename T, T t_value>
struct value_wrapper
{
 inline static T& data()
 {
  static T value=t_value;
  return value;
 }

 template<typename T2, T2 t_value2> 
 bool operator<(const value_wrapper<T2,t_value2>& r) const
 { return data()<r.data(); }
};

/*
Вариант №2 - Тогда не нужен вызов функции 

template<typename T, T t_value>
struct value_wrapper
{
 inline static T& data()
 { return value; }

 template<typename T2, T2 t_value2> 
 bool operator<(const value_wrapper<T2,t_value2>& r) const
 { return data()<r.data(); }
private:
 static const T value;
};

template<typename T, T t_value>
const T value_wrapper<T,t_value>::value = t_value;
*/

template<
        typename T,
        typename TMin = value_wrapper<T,T()>,
        typename TMax = value_wrapper<T,~T()>,
        typename TLess = std::less<T> >
class limit_t
{
public:
 T& data() { return static_cast<T&>(*this); }
 const T& data() const { return static_cast<const T&>(*this); }
 
 template<typename T2>
 limit_t& operator=(const limit_t<T2>& r)
 {
  if(TLess(data(),TMin::data())
   throw std::out_of_range("less than minimum");
  if(TLess(TMax::data(),data())
   throw std::out_of_range("more than maximum);
 //...
 }
};

template<
        typename T,
        T t_min,
        T t_max,
        typename TLess = std::less<T> >
class limit_t_pod : public limit_t<T,value_wrapper<T,t_min>,value_wrapper<T,t_max>,TLess>
{
//...
};

limit_t<int, value_wrapper<int,10>, value_wrapper<int,20> > limit_int_10_to_20;
limit_t_pod<int, 10, 20 > limit_pod_int_10_to_20;

B>>>>enum {def_value = i}; // где i это шаблонный параметр значения по умолчанию
B>>>>

B>>>>#include <boost/static_assert.hpp>

B>>>>    BOOST_STATIC_ASSERT( min <= T::def_value );
B>>>>    BOOST_STATIC_ASSERT( max >= T::def_value );
B>>>>

B>>Ну ты нудник!

B>>const static T  def_value = i;// где i это шаблонный параметр значения по умолчанию
B>>

__>Не вижу что с T=float будет работать это

B>>Кстати, хорошо что вспомнил, на VC7 второй темплейт параметр с float не проходит, The C++ standard does not allow floating point non-type template parameters. К барьеру, мистер Кодт!

typedef   value_wrapper< float, 10.1>  float_value_wrapper;

struct length_t : public T
{
...
    template< class V > inline self_t operator =   (V v) 
    { 
        if( v.length() != size )
            throw std::length_error("string is too big");
        data() = v;
        return *this; 
    }
...
};

template< typename T>
struct validate_iid_t : public T
{
...
    validate_iid_t () : T()
    {
      data()=default_iid;
    }
    template< class V > inline self_t operator =   (V v) 
    { 
        if( !IsValidIID(v) )
            throw std::invalid_iid_error("bla bla");
        data() = v;
        return *this; 
    }
...
};

length_t <valid_iid_t<std::string>, 36 > _ObjectID;

__>>template<typename T, T t_value>
__>>struct value_wrapper
__>>{
__>> inline static T& data()
__>> {
__>>  static T value=t_value;
__>>  return value;
__>> }

__>> template<typename T2, T2 t_value2> 
__>> bool operator<(const value_wrapper<T2,t_value2>& r) const
__>> { return data()<r.data(); }
__>>};

B>typedef   value_wrapper< float, 10.1>  float_value_wrapper;
B>

struct min_my_float
{
 static float data()
 {
  static const float value=10.1f;
  return value;
 }
};

struct max_my_float
{
 static float data()
 {
  static const float value=100.2f;
  return value;
 }
};

limit_t<float, min_my_float, max_my_float> x;

B>struct length_t : public T
B>{
B>...
B>    template< class V > inline self_t operator =   (V v) 
B>    { 
B>        if( v.length() != size )
B>            throw std::length_error("string is too big");
B>        data() = v;
B>        return *this; 
B>    }
B>...
B>};

B>template< typename T>
B>struct validate_iid_t : public T
B>{
B>...
B>    validate_iid_t () : T()
B>    {
B>      data()=default_iid;
B>    }
B>    template< class V > inline self_t operator =   (V v) 
B>    { 
B>        if( !IsValidIID(v) )
B>            throw std::invalid_iid_error("bla bla");
B>        data() = v;
B>        return *this; 
B>    }
B>...
B>};

B>

B>length_t <valid_iid_t<std::string>, 36 > _ObjectID;
B>

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

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

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


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

...

auto_value<int, 1> val;

...

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

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