namespace item_type
{

template <typename T>
class base_item_type
{
        public:
                typedef T::value_type value_type;

                base_item_type(int length)
                {
                        
                };

                void write() {};
                void read() {};
        private:
                value_type m_value;
};

namespace format_style
{
        class C
        {
                public:
                        typedef std::string value_type;
        };
}

typedef base_item_type<format_style::C> C;

}

class C
{
        public:
                typedef std::string value_type;
                static void write(const std::ostream &os, 
                  const value_type &value, int length) {};
};

base_item_type::write(){T::write(...)}

class file_001
{
  item_type::C item1(10);
  item_type::D item2(2);
...

}

value_type m_value;

template<class Data, class Fmt>
struct apply_fmt
{
  Data data; // пока что обойдемся без операторов приведения типа, как в auto_value.
};

template<class Data, class Fmt>
ostream& operator<< (ostream& ost, apply_fmt<Data,Fmt> const& v)
{
  return ostream << Fmt() << v.data;
}

// отдельные команды

template<int w> struct fmt_setw {};

template<int w> ostream& operator<< (ostream& ost, fmt_setw<w> _)
{
  return ost << setw(w);
}

template<char f> struct fmt_setfill {};

template<char f> ostream& operator<< (ostream& ost, fmt_setfill<f> _)
{
  return ost << setfill(f);
}

template<int b> struct fmt_setbase {};

template<int b> ostream& operator<< (ostream& ost, fmt_setbase<b> _)
{
  return ost << setbase(b);
}

struct fmt_hex {};
inline ostream& operator<< (ostream& ost, fmt_hex _) { return ost << hex; }

struct fmt_dec {};
struct fmt_left {};
struct fmt_right {};
// и т.д.

// наконец, пустой формат
struct fmt_void {};

inline ostream& operator<< (ostream& ost, fmt_void _) { return ost; }

// связывание форматов
// можно воспользоваться Loki::TypeList или boost::что-то-там-щас-не-помню

template<class F1, class F2> struct fmt_chain {};

template<class F1, class F2> ostream& operator<< (ostream& ost, fmt_chain<F1,F2> _)
{
  return ost << F1() << F2();
}

#define FMT_CONS(f1,f2) fmt_pair< f1, f2 >
#define FMT_NULL fmt_void

#define FMT_LIST1(f1)          FMT_CONS(f1,FMT_NULL)
#define FMT_LIST2(f1,f2)       FMT_CONS(f1, FMT_LIST1(f2))
#define FMT_LIST3(f1,f2,f3)    FMT_CONS(f1, FMT_LIST2(f2,f3))
#define FMT_LIST4(f1,f2,f3,f4) FMT_CONS(f1, FMT_LIST3(f2,f3,f4))

typedef apply_fmt<unsigned long, FMT_LIST3(fmt_hex, fmt_setw<8>, fmt_setfill<'0'>)> hexulong;
hexulong n;
n.data = 0xdead;
cout << n;

class A
{
  item_fmt<N> id(5);
  item_fmt<C> first_name(50);
}

my_vector<A> vecA;

std::cout << vecA.current.first_name;
vecA.current.id = 1234;

К>template<class Data, class Fmt>
К>struct apply_fmt
К>{
К>  Data data; // пока что обойдемся без операторов приведения типа, как в auto_value.
К>};
эээ... эт конечно хорошо, но во второй части уклон был сделан именно на динамические чтение/запись в буффер.
т.е. непосредственное "value_type m_value" в классе не присутствует... 


К>template<class Data, class Fmt>
К>ostream& operator<< (ostream& ost, apply_fmt<Data,Fmt> const& v)
К>{
К>  return ostream << Fmt() << v.data;
К>}
К>

OAB>class A
OAB>{
OAB>  item_fmt<N> id(5);
OAB>  item_fmt<C> first_name(50);
OAB>}

OAB>либо я паршиво описал что хочу (да я и сам вижу что паршиво ) либо вы не до конца вчитались...

STRINGIZEABLE_MEMBER(int, ALIGN(LEFT), FILL('0'), RADIX(OCT)) x;

STRINGIZE_MEMBERS(x,y,z);

STRINGIZEABLE_MEMBER(int, ALIGN(LEFT), FILL('0'), RADIX(OCT)) x;

STRINGIZE_MEMBERS(x,y,z);

template<int size, class format_style>
class item{}

item<1, C> i1;
item<2, C> i2;
item<3, C> i3;
item<4, C> i4;