struct point
{
   int x,y;
   point() {}
   point(int x_, int y_) : x(x_), y(y_) {}
};

> struct point
> {
>    int x,y;
>    point() {}
>    point(int x_, int y_) : x(x_), y(y_) {}
> };
>

struct point
{
    int x,y;
};

inline
point make_point(int x_, int y_) { point pt = { x_, y_}; return pt; }

ПК>struct point
ПК>{
ПК>    int x,y;
ПК>};

ПК>inline
ПК>point make_point(int x_, int y_) { point pt = { x_, y_}; return pt; }

ПК>И стандарт будет счастлив, и твоя совесть спокойна

struct point
{
    int x,y;
    static point make(int x_, int y_) { point pt = { x_, y_}; return pt; }
};

struct point
{
    int x,y;
    point clone(int x_, int y_) { point pt; memcpy(pt, this, sizeof(pt)); return pt; }
};

struct Point
 {
  int x,y;
 };
 
struct SetPoint : Point
 {
  SetPoint() : Point() {}
  
  SetPoint(int x_,int y_)
   {
    x=x_;
    y=y_;
   }
 };

/* main() */ 

int main()
 {
  Point p=SetPoint();
  Point q=SetPoint(1,2);
 
  return 0;
 }

struct point
{
   int x, y;
};

...
point pt = {0, 0};

///////////////////////////////////////////////////////////////////////////////////////
////// Move traits
///////////////////////////////////////////////////////////////////////////////////////
//General fall-back implementation of move using copy-constructors.
template<class T> struct safe_move_traits
{
    static void destroy_range(T* _first, T* _last)
    {
        for (T* f=_first; f!=_last; f++)
            f->~T();
    }

    static void move(T* _first, T* _last, void *_dest)
    {
        copy(_first,_last,_dest);
        destroy_range(_first,_last);
    }

    static void copy(const T* _first, const T* _last, void *_dest)
    {
        T* tdest = static_cast<T*>(_dest);
        std::uninitialized_copy(_first,_last,_dest);
    }
};

//Fast memmove-backed mover
template<class T> struct memmove_traits
{
    enum{bitwise_moveable=1};

    static void destroy_range(T* _first, T* _last)
    {
        for (T* f=_first; f!=_last; f++)
            f->~T();
    }

    static void move(T* _first, T* _last, void *_dest)
    {
        copy(_first,_last,_dest);
        destroy_range(_first,_last);
    }

    static void copy(const T* _first, const T* _last, void *_dest)
    {
        memmove(_dest,_first,(_last-_first)*sizeof(T));
    }
};

///////////////////////////////////////////////////////////////////////////////////////
////// Automatic moveфв selectors
///////////////////////////////////////////////////////////////////////////////////////

template <class T> struct fast_move_flag
{
    enum{can_move=0};
};

#define ENABLE_BITWISE_MOVE(clazz) template<> struct 
fast_move_flag<clazz>{enum{can_move=1};};

//All non-classes or types with fast_move_flag!=0 can be moved using 
memmove.
template <class T> struct move_traits:
    public boost::mpl::if_c<boost::is_class<T>::value == 0 || 
fast_move_flag<T>::can_move,
        memmove_traits<T>, safe_move_traits<T>
    >::type
{
};

struct point
{
   char cmd;
   int x,y;
};

C>//Fast memmove-backed mover
C>template<class T> struct memmove_traits
C>{
C>    enum{bitwise_moveable=1};

C>    static void destroy_range(T* _first, T* _last)
C>    {
C>        for (T* f=_first; f!=_last; f++)
            f->~T();
C>    }
C>    . . .

АШ>struct point
АШ>{
АШ>   int x, y;
АШ>};

АШ>...
АШ>point pt = {0, 0};
АШ>

        // TEMPLATE FUNCTION copy
template<class _II, class _OI> inline
    _OI copy(_II _F, _II _L, _OI _X)
    {for (; _F != _L; ++_X, ++_F)
        *_X = *_F;
    return (_X); }

MS>Хочу конструктор! Ыыыыыыаааааа!!! (размазывая слезы и сопли)

...
template<typename T, typename P1, typename P2>
T pod_initializer(P1 p1, P2 p2)
{
     T tmp = {p1, p2};
     return tmp; 
}

struct point 
{
    int x, y;
};

class cpoint
{
    point pt;
public:
    cpoint(int x, int y) : pt(pod_initializer<point>(x, y))
    {
    }
    operator point& ()
    {
        return pt;
    }
    operator point const & () const
    {
        return pt;
    }
    point* operator &()
    {
        return &pt;
    }
    point const * operator &() const
    {
        return &pt;
    }
};

void foo(point const &pt)
{
    std::cout << pt.x << ", " << pt.y << std::endl;
}

void foo(point const *ptr)
{
    std::cout << ptr->x << ", " << ptr->y << std::endl;
}

int main()
{
    std::cout << sizeof(point) << sizeof(cpoint);
    cpoint pt1(100, 200);
    cpoint pt2(300, 200);
    foo(&pt1);
    foo(&pt2);
}

    struct point { int x,y; };
    char array[100];
    point p[4];
    std::copy((point*)(array+1), (point*)(array+1+sizeof(p)), p);

#include <algorithm>

struct point { int x,y; };

void main()
{
    char array[100];
    point p[4];
    std::copy((point*)(array+1), (point*)(array+1+sizeof(p)), p);
}

rndusexwally:~>CC buserror.cpp
cc-3563 CC: WARNING File = buserror.cpp, Line = 5
  return type of function "main" must be "int"

  void main()
       ^

rndusexwally:~>./a.out
Bus error (core dumped)
rndusexwally:~>

char a[5] = {0}; 
int i = *(int*)(a + 1);

    struct point { int x,y; };
    char *array=(char*)malloc(100)
    point p[4];
    std::copy(&p[0], &p[0]+4, array);

typedef bcn::vector_builder<Obj> obj_vector_builder;
typedef bcn::fast_vector<Obj> obj_vector;

obj_vector method()
{
    obj_vector_builder b;
    b.insert(10,Obj(...));
    b.push_back(Obj());
    ...

    return b.yield();
}

struct v
{
    char a;
    int  b;
    char c;
    int  d;
    char e;
    int  f;
    char g;
    int  h;
};

MS>struct v
MS>{
MS>    char a;
MS>    int  b;
MS>    char c;
MS>    int  d;
MS>    char e;
MS>    int  f;
MS>    char g;
MS>    int  h;
MS>};
MS>

Nonstatic data members of a (non-union) class declared without an intervening access-specifier are allocated so that later members have higher addresses within a class object. The order of allocation of nonstatic data members separated by an access-specifier is unspecified (11.1). Implementation alignment requirements might cause two adjacent members not to be allocated immediately after each other; so might requirements for space for managing virtual functions (10.3) and virtual base classes (10.1).

>> struct v
>> {
>>     char a;
>>     int  b;
>>     char c;
>>     int  d;
>>     char e;
>>     int  f;
>>     char g;
>>     int  h;
>> };
>>

char a[5] = {0}; 
int i = *(int*)(a + 1);

    //This union is used to ensure that COW storage elements will be 
properly aligned.
    template<class AllocatorT> union cow_storage_element
    {
        typedef boost::detail::atomic_count counter_type;
        typedef typename AllocatorT::value_type value_type;

        typename boost::type_with_alignment<
            (boost::alignment_of<counter_type>::value > 
boost::alignment_of<value_type>::value)
            ? boost::alignment_of<counter_type>::value
            : boost::alignment_of<value_type>::value
            >::type a;
        char counter_[sizeof(counter_type)];
        char data_[sizeof(value_type)];
    };

cow_storage_element *data=allocate(...);
new(&(data->counter_[0])) boost::detail::atomic_count(1);
...
new(&(data[1].data_[0])) value_type(...);

#ifdef _WIN32
//Non-aligned types can be safely used on win32.
template<class T> size_t alignment_of()
{
    return 1;
}
#else
//General fallback implementation.
template<class T> size_t alignment_of()
{
    return sizeof(T);
}
#endif

...

char a[5+(alignment_of(int)+1)/2]; //This array will have enough space 
for properly aligned int.
int i=*(int*)(a+a%alignment_of(int)); //Get properly aligned integer.

union
{
    char a[5];
    int i;
};

> надо писать примерно так (опять код из моей библиотеки ):

int main()
{
     size_t const align = 0x1000;
     size_t const buf_size = 8;

     char buf[buf_size + align - 1];
     char* aligned_buf = buf + align - 1 - (((uint_ptr_t)buf + align - 1) % align);

     printf("%x %x\n", buf, aligned_buf);
}

mov eax,[esi]