bool ORMtableBase::FillFiledsMap(FieldsList& fields, const ORMtableBase* _this)
{
    size_t Finish = _this->GetSize(); // size of main class
    size_t Start = _this->GetFirstField(); // offset to first field
    while(Start < Finish)
    {
        const IORMField* pField = 
            static_cast<const IORMField*> // common interface for each field
            (
                static_cast<const void*>
                (
                    (
                        static_cast<const char*>
                        (
                            static_cast<const void*>(_this)
                        ) + Start
                    )
                )
            );
        fields.insert(std::pair<std::string, FieldInfo>(pField->GetName(), FieldInfo(pField->GetType(), Start))); // sometimes it crashes here
        Start += pField->GetSize(); // sizeof(ClassFieldName)
    }
    return !fields.empty();
}

template<class T, std::size_t val = sizeof(T)>
struct MyAlign
{
    enum
    {
        Result = ((val / 8) * 8 == val) ? 0 : (((val / 8) + 1) * 8) - val
    };
};

FIELD(MyName, 50, INITVALUE("Ivan"))

#ifndef __struct_alignment_calculator_h__
#define __struct_alignment_calculator_h__

#include <vector>
#include "basic_defines.h"
#include "math_algorithms.h"

namespace logical_algs
{
    struct type_dsk
    { 
        type_dsk( unsigned int size, unsigned int alignment, unsigned int elements = 1 ) 
            : m_sizeof(size) 
            , m_alignment(alignment)
            , m_offset(0)
            , m_padding(0)
            , m_elements(elements)
        {}
        type_dsk()
            : m_sizeof(0)
            , m_alignment(0)
            , m_offset(0)
            , m_padding(0)
            , m_elements(1)
        {}

        unsigned int get_sizeof() const { return m_elements * m_sizeof; }

        unsigned int m_offset;
        unsigned int m_padding;

        unsigned int m_sizeof;
        unsigned int m_alignment;
        unsigned int m_elements;
    };

    struct struct_dsk : public type_dsk
    {
        enum ealgnment {
             algnt_def  = 0
            ,algnt_1    = 1
            ,algnt_2    = 2
            ,algnt_4    = 4
            ,algnt_8    = 8
            ,algnt_16   = 16
        };
        typedef std::vector<type_dsk> v_fields;

        void     recalculate( ealgnment algn )
        {
            unsigned int c_f_o = 0;
            unsigned int c_s_a = 1;

            v_fields::iterator it = m_fields.begin();
            for(; it != m_fields.end(); ++it ) 
            {
                c_s_a = pg_max( c_s_a, (*it).m_alignment );
                if( algnt_def != algn ) {
                    c_s_a = pg_min( c_s_a, (unsigned int)algn );
                    (*it).m_alignment = pg_min( c_s_a, (*it).m_alignment);
                }
                c_f_o = math_algs::nearest_up_multiple( c_f_o, (*it).m_alignment );
                (*it).m_offset = c_f_o;
                c_f_o += (*it).get_sizeof();
                if( m_fields.begin() != it ) {
                    (*(it-1)).m_padding = (*it).m_offset - ( (*(it-1)).m_offset + (*(it-1)).get_sizeof() );
                }
            }

            m_sizeof = math_algs::nearest_up_multiple( c_f_o, c_s_a );
            m_alignment = c_s_a;
            (*m_fields.rbegin()).m_padding = m_sizeof - ( (*m_fields.rbegin()).m_offset + (*m_fields.rbegin()).get_sizeof() );
        }

        v_fields m_fields;
    };
}

#endif

    int nearest_up_multiple( int from, int multiple )
    {
        return (int)( multiple * ceil(((double)from)/multiple) );
    }

#define ALIGNMENT  8

#if ALIGNMENT != 0
#pragma pack(push, ALIGNMENT)
#endif
    struct K
    {
        char    a; 
        double  b; 
        char    c[15];
        int     d; 
        char    e; 
    };

    struct K1
    {
        char x;   
        K    y[3];   
        int  z;   
    };
#if ALIGNMENT != 0
#pragma pack(pop)
#endif

    int tk_s = sizeof(K);
    int tk_1 = offsetof(K, a);
    int tk_2 = offsetof(K, b);
    int tk_3 = offsetof(K, c);
    int tk_4 = offsetof(K, d);
    int tk_5 = offsetof(K, e);

    struct_dsk Kdsk;
    Kdsk.m_fields.push_back( type_dsk( sizeof(char), sizeof(char) ) );
    Kdsk.m_fields.push_back( type_dsk( sizeof(double), sizeof(double) ) );
    Kdsk.m_fields.push_back( type_dsk( sizeof(char), sizeof(char), 15 ) );
    Kdsk.m_fields.push_back( type_dsk( sizeof(int), sizeof(int) ) );
    Kdsk.m_fields.push_back( type_dsk( sizeof(char), sizeof(char) ) );
    Kdsk.recalculate( (struct_dsk::ealgnment)ALIGNMENT );

    assert( tk_1 == Kdsk.m_fields[0].m_offset );
    assert( tk_2 == Kdsk.m_fields[1].m_offset );
    assert( tk_3 == Kdsk.m_fields[2].m_offset );
    assert( tk_4 == Kdsk.m_fields[3].m_offset );
    assert( tk_5 == Kdsk.m_fields[4].m_offset );
    assert( tk_s == Kdsk.m_sizeof );
   
    int tk1_s = sizeof(K1);
    int tk1_1 = offsetof(K1, x);
    int tk1_2 = offsetof(K1, y);
    int tk1_3 = offsetof(K1, z);

    struct_dsk K1dsk;
    K1dsk.m_fields.push_back( type_dsk( sizeof(char), sizeof(char) ) );
    K1dsk.m_fields.push_back( type_dsk( Kdsk.m_sizeof, Kdsk.m_alignment, 3 ) );
    K1dsk.m_fields.push_back( type_dsk( sizeof(int), sizeof(int) ) );
    K1dsk.recalculate( (struct_dsk::ealgnment)ALIGNMENT );

    assert( tk1_1 == K1dsk.m_fields[0].m_offset );
    assert( tk1_2 == K1dsk.m_fields[1].m_offset );
    assert( tk1_3 == K1dsk.m_fields[2].m_offset );
    assert( tk1_s == K1dsk.m_sizeof );

S> Чесно? -Объяснение не понятное. И что такое "сборку класса из нескольких темплейтов" — агрегация или наследование используется?

class MyClass : public iClassBase
{
public:
    int i1, i2, i3; // 3 поля гарантированные для этого класса
    std::size_t GetFirstField() const
    {
        return offsetof(MyClass, i3) + sizeof(int);
    }
    std::size_t GetSize() const
    {
        return sizeof(MyClass);
    }
    // ниже идут поля класса
    class MyField : public MyFieldBase
    {
    public:
        MyField() {/*здесь будет код*/}
        std::size_t GetSize() const
        {
             return sizeof(MyField) + MyAlign<MyField>::Result;
        } 
    };
    MyField Fild1Name;
    /* и так далее для каждого поля */
};

struct iAligment
{
    char e;
    double f;
};

struct CurrentAligment
{
    enum
    {
        Value = offsetof(iAligment, f) - offsetof(iAligment, e)
    };
};


template<class T, std::size_t val = sizeof(T), std::size_t a = CurrentAligment::Value>
struct MyAlign
{
    enum
    {
        Result = ((val / a) * a == val) ? 0 : (((val / a) + 1) * a) - val
    };
};

// использование
class ClassName
{
//.....
    std::size_t GetSize() const
    {                                    
        return sizeof( ClassName ) + MyAlign<ClassName>::Result;
    }
//.....
};

struct CurrentAligment
{
    enum
    {
        Value = __alignof(struct {})
    };
};

Пока придумал вот такую конструкцию и проверил на всех смещениях от 1 до 16 — работает.

struct CurrentAligment
{
    enum
    {
        Value = offsetof(iAligment, f) - offsetof(iAligment, e) // это значение
    };
};

S>TABLE(sysUser, ALLOWDOMAIN(true), 
S>    INT(id, 50, INITVALUE(100))
S>    STRING(name, 100, 60, INITVALUE(L"TestDefaultString"))
S>    DATE(birthday, 10, EDITABLE(false))
S>    TIME(localtime, 31)
S>    BOOL(IsOk, 25)
S>    DOUBLE(mydouble, 45)
S>    )
S>

S>sysUser su;
S>su.name = L"tralaylay";
S>su.id = 500;
S>int maxLen = su.name.GetMaxLength();
S>

struct sysUser : SomeBase
{
  Field<int,50> id;
  Field<string,100> name;
  .....

  static FieldInfo listOfFields[];
  sysUser();
};

sysUser::sysUser()
: SomeBase(????)
, id(100)
, name(L"TestDefaultString")
, .....
{}

FieldInfo sysUser::listOfFields[] = {
  { "id",   sizeof(Field<int,50>) },
  { "name", sizeof(Field<string,100>) },
  .....
}

  { "id",   sizeof(Field<int,50>),     _offsetof(sysUser,id)   },
  { "name", sizeof(Field<string,100>), _offsetof(sysUser,name) },
  .....

int roundUp(int size, int align) { return (size+align-1)%align; }

int overall_tail = sizeof(Base); // текущий хвост структуры
int overall_align = _alignof(Base); // выравнивание структуры
int overall_size = min(1, roundUp(overall_tail, overall_align); // размер структуры

.....
// для каждого очередного поля

int field_size, field_align; // размер и выравнивание текущего поля
assert(field_align > 0);
assert(field_size % field_align == 0);

int field_offset = roundUp(overall_tail, field_align);

overall_align = max(overall_align, field_align);
overall_tail = field_offset + field_size;
overall_size = roundUp(overall_tail, overall_align);

template <class T> int next_offset(int &offset, int &total_size) {
  int x = offset;
  size_t size = sizeof(T), mask = sizeof(std::remove_all_extents<T>::type) - 1,
      trusted_offset = offset;
  if (offset & mask) {
    trusted_offset = offset = (offset + mask) & ~mask;
  }
  offset += size; total_size += offset - x;
  return trusted_offset;
}

финальный размер тоже подровнять
total_size = (total_size + (compiler_opt_align -1)) &~(compiler_opt_align -1)

int offset=0, total_size =0

#define TABLE(name, meta, fields)                               \
class name : public ORMtableBase                                    \
{                                                                   \
public:                                                             \
                                                                    \
    meta                                                            \
                                                                    \
                                                                    \
    fields                                                          \
                                                                    \
private:                                                            \
    static FieldsList FieldsMap;                                    \
};                                                                  \
ORMtableBase::FieldsList name::FieldsMap;                           \

template <class T> int nextP(int &offset, int &total_size, bool &realign) {
  int prev_offset = offset;
  typedef std::remove_all_extents<T>::type U;
  size_t size = sizeof(T), mask = sizeof(U) - 1, trusted_offset = offset;
  int c = std::tr1::is_class<U>::value ? alignof(T) : 0;
  if (c) mask = c - 1;
  if (!realign && (offset & mask)) {
    trusted_offset = offset = (offset + mask) & ~mask;
  }
 #ifdef __CODEGEARC__
  if (c) realign = true; // maybe its code_gear bug
 #endif
  offset += size; total_size += offset - prev_offset;
  return trusted_offset;
}

typedef double DD[2];
typedef float FD[3];
typedef float XD[13];
struct boo {
  float k;
  double r;
  DD r1;
  char ccc[17];
};
struct goo {
  DD r1;
  short t;
  char uu[61];
  std::map <std::string, int > maps;
};
struct F {
  char a;
  short g;
  XD u;
  boo oob;
  long long b;
  std::vector <DD> vecs;
  double c;
  DD fg;
  goo oob2;
  FD fl;
};

  int offset =0, size=0; bool realm=0;
  int offs1=offsetof(F,a),    xoffs1=nextP <char> (offset,size,realm);
  int offs2=offsetof(F,g),    xoffs2=nextP <short> (offset,size,realm);
  int offs3=offsetof(F,u),    xoffs3=nextP <XD> (offset,size,realm);
  int offs4=offsetof(F,oob),  xoffs4=nextP <boo> (offset,size,realm);
  int offs5=offsetof(F,b),  xoffs5=nextP <long long> (offset,size,realm);
  int offs6=offsetof(F,vecs),  xoffs6=nextP <std::vector <DD> > (offset,size,realm);
  int offs7=offsetof(F,c),  xoffs7=nextP <double> (offset,size,realm);
  int offs8=offsetof(F,fg),  xoffs8=nextP <DD> (offset,size,realm);
  int offs9=offsetof(F,oob2),  xoffs9=nextP <goo> (offset,size,realm);
  int offs10=offsetof(F,fl),  xoffs10=nextP <FD> (offset,size,realm);  
  int opt = __alignof(F);
  unsigned S0=(size+(opt-1))&~(opt-1);
  unsigned S1=sizeof(F);

  Memo1->Lines->Add(offsetof(F,a));
  Memo1->Lines->Add(offsetof(F,g));
  Memo1->Lines->Add(offsetof(F,u));
  Memo1->Lines->Add(offsetof(F,oob));
  Memo1->Lines->Add(offsetof(F,b));
  Memo1->Lines->Add(offsetof(F,vecs));
  Memo1->Lines->Add(offsetof(F,c));
  Memo1->Lines->Add(offsetof(F,fg));
  Memo1->Lines->Add(offsetof(F,oob2));
  Memo1->Lines->Add(offsetof(F,fl));
  Memo1->Lines->Add(sizeof(F));
  int offset = 0, size = 0; bool realign = false;
  Memo1->Lines->Add(nextP<char>(offset,size,realign));
  Memo1->Lines->Add(nextP<short>(offset,size,realign));
  Memo1->Lines->Add(nextP<XD>(offset,size,realign));
  Memo1->Lines->Add(nextP<boo>(offset,size,realign));
  Memo1->Lines->Add(nextP<long long>(offset,size,realign));
  Memo1->Lines->Add(nextP<vector<DD> > (offset,size,realign));
  Memo1->Lines->Add(nextP<double>(offset,size,realign));
  Memo1->Lines->Add(nextP<DD>(offset,size,realign));
  Memo1->Lines->Add(nextP<goo>(offset,size,realign));
  Memo1->Lines->Add(nextP<FD>(offset,size,realign));
  int opt = alignof(struct{});
  Memo1->Lines->Add((size+(opt-1))&~(opt-1));

S>2) наверное только незнание того как это сделать

#define TABLE(name,meta,fields) \
  struct name : ORMtableBase { \
    meta \
    MEMBERS(fields) \
  }; \
  static ORMField name::FieldsArray[] = { METADATA(name,fields) }; \
  static const int name::FieldsCount = _countof(name::FieldsArray); \
  //endmacro

S>>2) наверное только незнание того как это сделать

К>#define TABLE(name,meta,fields) \
К>  struct name : ORMtableBase { \
К>    meta \
К>    MEMBERS(fields) \
К>  }; \
К>  static ORMField name::FieldsArray[] = { METADATA(name,fields) }; \
К>  static const int name::FieldsCount = _countof(name::FieldsArray); \
К>  //endmacro
К>

INT(id, 50, INITVALUE(100))
STRING(name, 100, 60, INITVALUE(L"TestDefaultString"))
DATE(birthday, 10)
TIME(localtime, 31)
BOOL(IsOk, 25)
DOUBLE(pisun, 45)

#define FIELD(TypeID, RealType, name, captionID, ...)            \
class RealType ## _ ## name : public ORMfield<TypeID, RealType>      \
{                                                                    \
public:                                                              \
    explicit RealType ## _ ## name () : ORMfield(#name , captionID)  \
    {                                                                \
        InitValue(FieldValue);                                       \
    }                                                                \
                                                                     \
   // куча кода опущена                                                                  \
                                                                     \
    std::size_t GetSize() const                                      \
    {                                                                \
        return sizeof( RealType ## _ ## name ) +                     \
            MyAlign<RealType ## _ ## name>::Result;                  \
    }                                                                \
                                                                     \
    __VA_ARGS__                                                      \
                                                                     \
};                                                                   \
                                                                     \
RealType ## _ ## name name;

S>INT(id, 50, INITVALUE(100))
S>STRING(name, 100, 60, INITVALUE(L"TestDefaultString"))
S>DATE(birthday, 10)
S>TIME(localtime, 31)
S>BOOL(IsOk, 25)
S>DOUBLE(pisun, 45)
S>

S>#define FIELD(TypeID, RealType, name, captionID, ...)            \
S>class RealType ## _ ## name : public ORMfield<TypeID, RealType>      \

#define MAKE_TYPE_NAME(name) MAKE_TYPE_NAME_(name)
#define MAKE_TYPE_NAME_(name) RealType##_##name

S>#define FIELD(TypeID, RealType, name, captionID, ...)            \
S>class RealType ## _ ## name : public ORMfield<TypeID, RealType>      \
S>{                                                                    \
S>public:                                                              \
S>    explicit RealType ## _ ## name () : ORMfield(#name , captionID)  \
S>    {                                                                \
S>        InitValue(FieldValue);                                       \
S>    }                                                                \
S>                                                                     \
S>   // куча кода опущена                                                                  \
S>                                                                     \
S>    std::size_t GetSize() const                                      \
S>    {                                                                \
S>        return sizeof( RealType ## _ ## name ) +                     \
S>            MyAlign<RealType ## _ ## name>::Result;                  \
S>    }                                                                \
S>                                                                     \
S>    __VA_ARGS__                                                      \
S>                                                                     \
S>};                                                                   \
S>                                                                     \
S>RealType ## _ ## name name;
S>

template<typename MDT, typename TypeID, typename TRealType> 
class ORMfield {
//  тут всё так, как у тебя и есть +
    std::size_t GetSize() const;
    {                                                                \
        return sizeof( RealType ## _ ## name ) +                     \
            MyAlign<RealType ## _ ## name>::Result;                  \
    }                                                                \
 
};
template<typename MDT, typename TypeID, typename TRealType>
std::size_t GetSize();
{                                                                
    return sizeof( MDT ) + MyAlign<MDT>::Result;                 
}

template<typename T, typename TAlignAs = double> class AlignedData {
    union {
        TAlignAs dummy;
        char buffer[sizeof( T )];
    } data;
public:
    AlignedData() { new( data.buffer ) T; }
    AlignedData( const AlignedData& other ) { new( data.buffer ) T( other.Get() ); }
    template<typename T1>
    AlignedData( T1 t1 )  { new( data.buffer ) T( t1 ); }
    template<typename T1, typename T2>
    AlignedData( T1 t1, T2 t2 )  { new( data.buffer ) T( t1, t2 ); }
    ~AlignedData() { Get().~T(); }

    void operator = ( const AlignedData& other ) { Get() = other.Get(); }

    T& Get() { return *static_cast<T*>( data.buffer ); }
    const T& Get() const { return *static_cast<const T*>( data.buffer ); }
};

S>INT(id, 50, INITVALUE(100))
S>STRING(name, 100, 60, INITVALUE(L"TestDefaultString"))
S>DATE(birthday, 10)
S>TIME(localtime, 31)
S>BOOL(IsOk, 25)
S>DOUBLE(pisun, 45)
S>

#define EXTRACT_FIELDS_END_OF_LIST_
#define EXTRACT_FIELDS_INT( NAME, TYPE_ID, INIT_VALUE ) \
    /* тут собственно кусок твоего старого определение INT */ FIELD( int, NAME, TYPE_ID, INIT_VALUE )\
    EXTRACT_FIELDS_##
EXTRACT_FIELDS( FIELDS ) EXTRACT_FIELDS_##FIELDS END_OF_LIST_ 
// Тут, на самом деле, надо немного схимичить, чтобы FIELDS подставилось раньше, чем развернётся, но я пока не буду

#include <boost/preprocessor/seq/for_each.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/preprocessor/facilities/expand.hpp>
#include <boost/preprocessor/punctuation/paren.hpp>
#include <boost/preprocessor/tuple/elem.hpp>

// T_xxx - макросы для внутреннего использования

// генератор структуры
#define TABLE(name,meta,fields) \
    struct name : ORMTableBase { \
        meta \
        BOOST_PP_SEQ_FOR_EACH(T_APPLY, (T_MEMBER,name), fields) \
        static const FieldInfo* reflection() { \
            static const FieldInfo refs[] = { \
                BOOST_PP_SEQ_FOR_EACH(T_APPLY, (T_REFLECTION,name), fields) \
                {} \
            }; \
            return refs; \
        } \
    }; \
    //ENDMACRO

// колбеки - генераторы элементов
#define T_MEMBER(name,type,var,...) type var;
#define T_REFLECTION(name,type,var,...) { BOOST_PP_STRINGIZE(var), sizeof(type), _offsetof(name,var) },

// T_APPLY - общий колбек (высшего порядка!) для макроса FOR_EACH
// принимает 3 параметра (r,data,elem)
// r - номер следующего элемента, - т.е. 2, 3, 4, и т.д. - бустовские штучки
// data - общий параметр, у нас это (T_MEMBER,name) или (T_REFLECTION,name) - т.е. колбек + имя класса
// elem - элемент серии, т.е. информация об очередном поле (type,var,etc...)

// T_APPLY(r,(macro,name),(type,var,etc...)) --> T_APPLY_( macro, name, type,var,etc... ) -- последняя пачка идёт одним аргументом!
#define T_APPLY(r,mn,fld) \
    BOOST_PP_EXPAND( \
        T_APPLY_(BOOST_PP_TUPLE_ELEM(2,0,mn), BOOST_PP_TUPLE_ELEM(2,1,mn), T_UNWRAP fld) \
    ) \
    //ENDMACRO
#define T_APPLY_(macro,name,fld) macro BOOST_PP_LPAREN() name,fld ) // --> macro ( name , type,var,etc... )

#define T_UNWRAP(...) __VA_ARGS__ // (x,y,z,t) --> x,y,z,t


// тестируем...
TABLE(foo, hello, ((int,x)) ((char,y)) )

// на выходе получилось
struct foo : ORMTableBase {
    hello
    int x;
    char y;
    static const FieldInfo* reflection() {
        static const FieldInfo refs[] = {
            { "x", sizeof(int), _offsetof(foo,x) },
            { "y", sizeof(char), _offsetof(foo,y) },
            {}
        };
        return refs;
    }
};