Создать класс "Кот" с полями "Возраст" и "Вес"

#include<iostream>
#include<cstdlib>
using namespace std;
 
class Cat {
    private :
        double weight ; int age;
    public :
        double read(int aw, int num, int o);
        void write(int n);
        double eq(Cat);
}; 
 
int main()
{
    int x;
    int res;
    int i;
    int num;
    int j;
    
    cout<<"Enter number of cat`s:";
    
    cin>>num;
    Cat c[num];
    
    cout<<"Enter the Cat`s properties:"<<endl;
    
    for(i=0,j=1;i<num;i++,j++){
        cout<<"Enter weight and age "<<j<<" Cat>>"<<endl;
        c[i].read(j,num,0);
    }
    
    cout<<"Now the Cat`s properties are:"<<endl;
    
    for(i=0,j=1;i<num;i++,j++){
        c[i].write(j);
    }
    
    cout<<"\nThe result of the compresion properties:"<<endl;
    
    //?????
    
    system("pause");
    return 0;
}
double Cat :: read (int aw ,int num, int x){
    cin>>weight>>age;
    return (weight&&age);
}
void Cat :: write (int n){
    cout<<"\nWeight of "<<n<<" cat is>"<<weight<<endl<<"The age of "<<n<<" cat is>"<<age;
    cout<<endl;
}
double Cat :: eq (Cat){
    
}

friend int eqW (Cat* c,int n);
friend int eqAge (Cat* c,int n);

// возвращает номер кота с максимальным весом
int eqW (Cat* c,int n)
{
    int t=0;
    for(int i=1;i<n;i++)
      if(c[t].weight<c[i].weight)
        t=i;
    return t;
}
// возвращает номер самого старого кота
int eqAge (Cat* c,int n)
{
    int t=0;
    for(int i=1;i<n;i++)
      if(c[t].age<c[i].age)
        t=i;
    return t;
}

// =======================================================================
// =======================================================================
 
#include <random>
#include <chrono>
 
namespace detail_random {
    std::default_random_engine& rnd_()
    {
        static std::default_random_engine gen(
            static_cast<unsigned>(
                std::chrono::system_clock::now().time_since_epoch().count()
             )
        );
        return gen;
    }
}//detail_random
 
int random(const int a, const int b)
{
    std::uniform_int_distribution<int> distribution(a, b);
    return distribution( detail_random::rnd_() );
}
 
double random(const double a, const double b)
{
    std::uniform_real_distribution<double> distribution(a, b);
    return distribution( detail_random::rnd_() );
}
 
// =======================================================================
// =======================================================================
 
#include <cassert>
#include <iostream>
 
void clear_input()
{
    std::wcin.clear(),
    std::wcin.ignore(std::numeric_limits<std::streamsize>::max(), L'\n');
    assert(std::wcin);
}
 
template<typename Data, class Checker> 
void input(const wchar_t* msg, const wchar_t* help, const Checker& checker, Data& dst)
{
    for (;;)
    {
        assert(std::wcout);
        assert(std::wcin);
 
        std::wcout << msg; 
        std::wcin  >> dst;
 
        if (!std::wcin || !checker(dst) )
            std::wcout << L"\nошибка: " << help,
            clear_input();
        else 
            break; 
    }
}
 
template<typename Data > 
void input(const wchar_t* msg, const wchar_t* help, Data& dst)
{ 
    const auto lambda = [](const Data&) { return true; };
    input(msg, help, lambda, dst);
}
 
// =======================================================================
// =======================================================================
 
 
class Cat 
{
    double weight; size_t age;
public :
    Cat(const double w = 0.0, const size_t a = 0)
        :weight(w)
        ,age(a)
    {}
    
    void randomize()
    {
        weight = random(0.5, 5.5);
        age    = random(1, 15);
    }
    
    void input()
    {
        ::input(L"введите вес кота: ", 
            L"введите дробное положительное число",
            [](const double v) { return v>=0; },
            weight
        );
        std::cout <<std::endl;
 
        ::input(L"введите возвраст кота: ",
            L"введите  натуральное число",
            age
        );
        std::cout <<std::endl;
    }
    
    void output_by_age()const 
        { std::wcout << L"возвраст "<< age << L", вес " << weight; }
    
    void output_by_weight()const 
        { std::wcout << L"вес " << weight << L", возвраст "<< age; }
 
 
    bool by_age(const Cat& c)const 
        { return c.age > age; }
 
    bool by_weight(const Cat& c)const 
        { return c.weight > weight; }
    
            
}; 
 
 
 
// =======================================================================
// =======================================================================
 
#include <vector>
#include <algorithm>
 
 
// --- закомментируйте этот дефайн, 
// что бы вводить данные о котах вручную
#define dRANDOMIZE
 
int main()
{
    setlocale(LC_ALL, "");
    
#ifndef dRANDOMIZE    
    size_t count = 0;
    input(L"введите количество котиков: ",
          L"введите положительное число",
          count
    );
    std::cout << std::endl;
    
    std::vector<Cat> cats;
    for(size_t n=0; n<count; ++n)
        cats.emplace_back(),
        cats.back().input();
#else
    const size_t count = random(0,100);
    
    std::vector<Cat> cats;
    for(size_t n=0; n<count; ++n)
        cats.emplace_back(),
        cats.back().randomize();
#endif
    
    std::wcout << L"================== коты ===================\n";
    for(const auto& c: cats)
        c.output_by_age(),
        std::cout<<std::endl;
        
    
    std::wcout << L"  -----> сортируем котов по весу:\n";
    std::vector<Cat> by_weight(cats);
    std::sort(
        by_weight.begin(), 
        by_weight.end(), 
        [](const Cat& l, const Cat& r){ return l.by_weight(r); }
    );
    for(const auto& c: by_weight)
        c.output_by_weight(),
        std::cout<<std::endl;
 
    std::wcout << L"  -----> сортируем котов по возврасту:\n";
    std::vector<Cat> by_age(cats);
    std::sort(
        by_age.begin(), 
        by_age.end(), 
        [](const Cat& l, const Cat& r){ return l.by_age(r); }
    );
    for(const auto& c: by_age)
        c.output_by_age(),
        std::cout<<std::endl;
}