Преобразовать массив

//Создать класс «вектор» для описания одномерного массива и произвести с ним следующие
//операции: Преобразовать массив X, расположив вначале его отрицательные, а затем
//неотрицательные элементы, сохранив при этом в группе отрицательных элементов их
//исходный относительный порядок, а в группе неотрицательных элементов изменив его на
//обратный. Определить, как при этом изменилось положение минимального по модулю
//элемента массива X. Буферный массив не использовать.
 
#include <iostream>
 
class Vector
{
      private:
              int *vec;
              int size;
      public:
             Vector();
             Vector(int mas[], int n);
             ~Vector();
             
             friend std::ostream & operator<<(std::ostream & os, const Vector & b);
             Vector & operator>(int n);
};
Vector::Vector()  
 {                 
      size = 1;
      vec = new int[1];
      vec[0]=0;
 }
         
 Vector::Vector(int mas[],const int n)
 {
      size = n;
      vec = new int[n];
      for(int i=0; i<n; i++)
      vec[i]=mas[i];
 }
            
 Vector::~Vector() 
 {
          delete [] vec;      
 }
 
 std::ostream & operator<<(std::ostream & os, const Vector & b)
 {  
 
 void Transform(int *a, int n)
{
   int flag, i, buf, r = n;
   do
   {
      flag = 0;
      for (i = 1; i < r; i++)
         if (a[i-1] >= 0 && a[i] < 0)
         {
             buf = a[i-1]; a[i-1] = a[i]; a[i] = buf;
             flag = 1;
         }
      r--;
   }while (flag);
}
            
    system("pause");
    
    return 0;
 
}

#include <iostream>
#include <fstream>
 
using namespace std;
 
class Vector
{
private:
        int* mass; 
        int SIZE; 
 
        int min_el; 
        int indx_1; 
        int indx_2; 
 
        int abs(int n) 
        {
            if(n<0) 
                return n*-1;
            return n;
        }
public:
        Vector(int _SIZE)
        {
            if(_SIZE < 1)
            {
                cout << "Incorrect!";
            }
            else
            {
                SIZE = _SIZE; 
                mass = new int[SIZE];
                min_el = 99999;
                indx_1 = 0;
                indx_2 = 0;
            }
        }
        ~Vector() 
        {
            delete[] mass;
        }
 
        int get_size() 
        {
            return SIZE;
        }
        int read_from_file(char* name_of_file) 
        {
            ifstream file(name_of_file); 
 
            if(!file.is_open()) 
                return -1;
 
            int i=0;
            while(!file.eof() && i<SIZE) 
            {
                file >> mass[i++];
            }
 
            file.close(); 
            return 0;
        }
                int write_into_file(char* name_of_file) 
        {
            ofstream file(name_of_file,ios_base::app);
 
            if(!file.is_open())
                return -1;
 
            int i=0;
            while(i<SIZE) 
            {
                file << mass[i++] << " ";
            }
            file << endl;
 
            file.close(); 
            return 0;
        }
        int operator[](int n) 
        {
            if(n>=0 && n<SIZE) 
                            
                return mass[n];
            return 0;
        }
        
        void task_1() 
        {
            int* buffer = new int[SIZE]; 
            int i,j=0;
 
            for(i=0;i<SIZE;i++) 
            {
                if(mass[i]<0){
                    buffer[j] = mass[i];
                    j++;
                }
            }
            for(i=0,j=SIZE-1;i<SIZE;i++) 
            {
                if(mass[i]>=0)
                    buffer[j--] = mass[i];
            }
 
            for(i=0;i<SIZE;i++) 
            {
                mass[i] = buffer[i];
            }
        }
        void task_2_1() 
        {
            for(int i=0;i<SIZE;i++)
            {
                if(abs(mass[i]) < abs(min_el)) 
                            
                {
                    min_el = mass[i];
                    indx_1 = i;
                }
            }
        }
                void task_2_2() 
        {
            int i=0;
            while(i<SIZE)
            {
                if(mass[i] == min_el) 
                {
                    indx_2 = i;
                    break;
                }
                i++;
            }
        }
        int task_3(Vector _obj) 
        {
            Vector obj(_obj.get_size());
            obj = _obj;
 
            int i,j;
 
            if(obj.get_size()!=SIZE)
                return -1;
 
            for(i=0,j=SIZE-1;i<SIZE;i++,j--) 
            {
                mass[i] = obj[i] * obj[j];
            }
            return 0;
        }
        int set_mass(int inx,int num) 
        {
            if(inx<0 && inx>=SIZE)
            {
                mass[inx] = num;
                return 0;
            }
            return -1;
        }
        int get_min_el(){return min_el;} 
        int get_indx_1(){return indx_1;} 
        int get_indx_2(){return indx_2;} 
};
 
int main()
{
    char input[50] = "input.txt"; 
    char output[50] = "output.txt"; 
 
    Vector obj1(5); 
    obj1.read_from_file(input); 
 
    obj1.task_2_1(); 
    obj1.task_1(); 
    obj1.task_2_2();
 
     ofstream file("output.txt"); 
    if(!file.is_open()) return -1;
 
    file << "Task 1: "; file.close();  
    obj1.write_into_file(output);
 
    Vector obj2(obj1.get_size()); 
    obj2.task_3(obj1);
 
 
    file.open("output.txt",ios_base::app);
    if(!file.is_open()) return -1;
 
    file << "Task 2: Element: " << obj1.get_min_el() << "  index 1: " << obj1.get_indx_1() 
    << "  index 2: " << obj1.get_indx_2() << endl;
     
    file << "Task 3: "; 
    file.close();
    obj2.write_into_file(output);
 
    return 0;
}