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