class vector (sub operation)

friend istream& operator >> (istream& is, Vector& v)
        {                                   
       for(size_t i = 0; i < v.size; i++)
       {
        cout << "Input vect[" << i << "]:\t";
        is >> v.vect[i];
       }
       return is;
    }
    friend ostream& operator << (ostream& os, const Vector& v)
        {                                   
         os << "Vector:   (";
         for(size_t i = 0; i < v.size; i++)
         {
            os << v.vect[i];
            if(i == v.size - 1)
            os << ")\n";
           else
            os << ", ";
         }
        return os;
    }    size_t GetSize() const;

#include <stdio.h>
#include <conio.h>
#include <iostream.h>
class vect {
public:
   vect(int=0,int=0,int=0,int=0,int=0);   
   vect operator*(const vect &); 
   vect operator*(const int &); 
   void print() const;
   private:
   int a,b,c,d,e;
};
vect::vect(int a1,int b1,int c1,int d1,int e1)
{
   a = a1;
   b = b1;
   c = c1;
   d = d1;
   e = e1;
}
vect vect::operator*(const vect &operand2)
{
   vect proizv;
   proizv.a = a * operand2.a;
   proizv.b = b * operand2.b;
   proizv.c = c * operand2.c;
   proizv.d = d * operand2.d;
   proizv.e = e * operand2.e;
   return proizv;
}
vect vect::operator*(const int &operand2)
{
   vect proizv;
   proizv.a = a * operand2;
   proizv.b = b * operand2;
   proizv.c = c * operand2;
   proizv.d = d * operand2;
   proizv.e = e * operand2;
   return proizv;
}
void vect::print() const
{
   cout<<'('<<a<<", "<<b<<", "<<c<<", "<<d<<", "<<e<<')';
}
int main(int argc, char* argv[])
{
   vect x(5,6,7,8,9),y(4,3,2,1,7);
   vect z;
   cout<<"\n Vector 1:";
   x.print();
   cout<<"\n Vector 2:";
   y.print();
   z = x * y;
   cout<<"\n Vector*Vector:   ";
   z.print();
   getch();
   return 0;
}

namespace Exercise
{
    class Vector
    {
    public:
               Vector( void )
                   : m_begin(),
                     m_end()
               {
               }
 
               Vector( double _dXFirst,  double _dYFirst,
                       double _dXSecond, double _dYSecond )
                   : m_begin(_dXFirst , _dYFirst ),
                     m_end  (_dXSecond, _dYSecond)
               {
               }
 
               Vector( const std::pair<double, double>& _begin,
                       const std::pair<double, double>& _end   )
                   : m_begin(_begin),
                     m_end  (_end)
               {
               }
 
               std::pair<double, double> GetBegin( void ) const
               {
                   return m_begin;
               }
                
               std::pair<double, double> GetEnd( void ) const
               {
                   return m_end;
               }
 
               void SetBegin ( double _dX, double _dY)
               {
                   m_begin = std::make_pair(_dX, _dY);
               }
 
               void SetBegin (const std::pair<double, double>& _begin)
               {
                   m_begin = _begin;
               }
 
               void SetEnd ( double _dX, double _dY)
               {
                   m_end = std::make_pair(_dX, _dY);
               }
 
               void SetEnd (const std::pair<double, double>& _end)
               {
                   m_end = _end;
               }
 
               double X( void ) const
               {
                   return m_end.first - m_begin.first;
               }
 
               double Y( void ) const
               {
                   return m_end.second - m_begin.second;
               }
 
               std::string ToString ( void ) const
               {
                   std::ostringstream sResult;
 
                   sResult << "((" << m_begin.first << ", " << m_begin.second << "), (" << m_end.first << ", " << m_end.second << "))";
 
                   return sResult.str();
               }
 
    private:
        std::pair<double, double> m_begin;
        std::pair<double, double> m_end;
    };
 
    template <class _Stream>
    _Stream& operator >> (_Stream& _strm, Vector& _vector)
    {
        double dX = 0, 
               dY = 0;
 
        _strm >> dX >> dY;
        _vector.SetBegin(dX, dY);
 
        _strm >> dX >> dY;
        _vector.SetEnd(dX, dY);
 
        return _strm;
    }
 
    template <class _Stream>
    _Stream& operator << (_Stream& _strm, const Vector& _vector)
    {
        _strm << _vector.ToString();
        return _strm;
    }
 
    double operator * (const Vector& _right, const Vector& _left)
    {
        double dResult = _right.X()*_left.X() + _right.Y() * _left.Y();
 
        return dResult;
    }
}