Классы со сложными атрибутами

// Начало мантры
#include <iostream>
#include <cstdlib>
using namespace std;
// Конец мантры

//_____________________________________________________
class MWeight{
   int kg; // килограммы
   int gr; // граммы
public:
   MWeight();
// Получить вес риса в клавиатуры
   void getWeight();
// Оператор сложения
// Складываем вес двух мешков
   MWeight operator+(const MWeight& a);
// Прибавляем в мешок граммы
   MWeight operator+(int a);
// печать
   void print();
// получаем разницу между весом двух мешков.
// В "нашем мешке" вес всегда больше
   MWeight operator-(const MWeight& a);
// Деление веса мешка на целое число
   MWeight operator/(int n);
// Умножение веса мешка на целое число
   MWeight operator*(int n);
// Оператор сравнения. Если два мешка равны, возвращает 1,
// если нет - 0
   int operator==(const MWeight& a);
// Оператор сравнения. Если два мешка не равны, возвращает 1,
// если равны - 0
   int operator!=(const MWeight& a);  
};
//________________________________________________________
// Класс Карусель.
// Позволяет меняться мешками,
// можно получить вес первого и второго мешка
// можно положить новый вес в эти мешки
class RoundRobin{
   MWeight person[5]; // 5 человек с рисом
public:
// Конструктор по-умолчанию
   RoundRobin();
// получить вес для всех
   void getW();
// Поменяться мешками: первый - второму, пятый - первому
   void turnRight();
// получить вес первого мешка
   MWeight getFirst();
//  получить вес второго мешка
   MWeight getSecond();
// поместить вес в первый мешок
   void putFirst(MWeight a);
// поместить вес во второй мешок
   void putSecond(MWeight a);
// проверка, все ли мешки одинакового веса
   int isEqual();
// печать
  void print();
};

//________Реализция класса MWeight_________
// конструктор "по-умолчанию" - пустой мешок
MWeight::MWeight(){
 kg = 0;
 gr = 0;
};

// получить вес с клавиатуры
void MWeight::getWeight(){
  cin>>kg>>gr;
  kg+= gr/1000;
  gr %= 1000;
};

MWeight MWeight::operator+(const MWeight& a){
     MWeight tmp;
     int pt;
     pt = kg * 1000 + gr + a.kg * 1000 + a.gr;
     tmp.kg = pt /1000;
     tmp.gr = pt % 1000;
     
     return tmp;
};

MWeight MWeight::operator+(int n){
     MWeight tmp; 
     tmp.gr =  kg*1000 + gr  + n ;
     tmp.kg = tmp.gr / 1000;
     tmp.gr = tmp.gr % 1000;     
     return tmp;
};

MWeight MWeight::operator-(const MWeight& a){
     MWeight tmp; 
     tmp.gr =  kg*1000 + gr  - a.kg*1000 - a.gr ;
     tmp.kg = tmp.gr / 1000;
     tmp.gr = tmp.gr % 1000;     
     return tmp;
};

MWeight MWeight::operator/(int n){
      MWeight tmp; 
      int ost;
      ost = kg%n;
      tmp.kg = kg / n;
      tmp.gr = (gr + ost*1000)/n; 
 
     return tmp;
};
MWeight MWeight::operator*(int n){
      MWeight tmp; 
      int pr;
      pr = gr * n;
      tmp.gr = pr % 1000;
      tmp.kg = kg * n + pr /1000; 
 
     return tmp;
};
void MWeight::print(){
   cout<<kg<<"kg "<<gr<<"gr ";
};

int MWeight::operator==(const MWeight& a){
  if (kg != a.kg && gr != a.gr)
        return 0;
   return 1; 
};

// Оператор сравнения. Если два мешка не равны, возвращает 1,
// если равны - 0
int MWeight::operator!=(const MWeight& a){
   if (kg != a.kg || gr != a.gr)
        return 1;
   return 0; 
};
//__________Реализация класса RoundRobin_________________

// Конструктор по-умолчанию
RoundRobin::RoundRobin(){
// Здесь код уже не нужен
// но функцию с пустыми скобками написать нужно
};

// получить вес для всех мешков
void RoundRobin::getW(){
// здесь написать код

};

// Поменяться мешками: первый - второму, пятый - первому
void RoundRobin::turnRight(){
   MWeight last,next;
// написать в тетради таблицу со всеми значениями i
// и проверить какие номера индексов получаются
// проверить какие получаются значения для last  и next
// для каждого значения i
   last = person[0];
  for(int i = 0; i < 5; i ++){
      next = person[(i + 1) % 5];
      person[(i + 1) % 5] = last;
      last = next;
  }
};

// получить вес первого мешка
MWeight RoundRobin::getFirst(){
 // здесь написать код
};

//  получить вес второго мешка
MWeight RoundRobin::getSecond(){
// здесь написать код
};
// поместить вес в первый мешок
void RoundRobin::putFirst(MWeight a){
 // здесь написать код
};
// поместить вес во второй мешок
void RoundRobin::putSecond(MWeight a){
 // здесь написать код
};

// проверка, все ли мешки одинакового веса
int RoundRobin::isEqual(){
 // здесь написать код
 
// Если хотя бы два мешка разного веса, 
// завершаем функцию и возвращаем 0
// оператор != для мешков определен в классе MWeight

// Раз дошли до конца цикла, все мешки одинаковые
 
};
// печать
void RoundRobin::print(){
// здесь написать код
};  

int main(){
// Проверка функций: 
 MWeight seller,a,b,c;
 a.getWeight();
 b.getWeight();
 c = a + b;
 c.print();
 c = a - b;
 c.print();
 c = a * 3;
 c.print();
 c = b / 2;
 c.print();
// операторы == и != тоже проверяем 
 if(a == b)
   cout<<"равны"<<endl;
 if(a != b)
   cout<<" не равны"<<endl; 
// Проверка функций круга (карусели)   
 RoundRobin rr; // все люди, вставшие в круг
// получили рис (все в кругу) 
 rr.getW();
 rr.print(); 
// Проверка у всех ли одинаковое количество риса 
 cout<<"eq="<<rr.isEqual()<<endl;
// Получили рис первого
   a=rr.getFirst();
   a.print();
// Получили рис второго    
    b=rr.getSecond();
    b.print();
    c = (a + b)/2;
    cout<<"c:";
    c.print();
// Проверили поворот    
    rr.turnRight();
// Положили рис первому
    rr.putFirst(c);
// Положили рис второму    
    rr.putSecond(c);
    rr.print();
}