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