cats, C++ (gcc) - rextester

Language: Layout:

// =======================================================================
// =======================================================================

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

Show compiler warnings [ + ] Compiler args [ - ] Show input
Compilation time: 1.02 sec, absolute running time: 0.13 sec, cpu time: 0 sec, memory peak: 3 Mb, absolute service time: 1,16 sec