Создайте класс Rectangle, который имеет функции для расчета площади и периметра прямоугольника

#include <iostream>
#include <fstream>
#include <string>
#include <cctype>
#include <cmath>
#include <vector>
#include <iomanip> 
///////////////////////////////////////////////////////////////////////////////////////////
constexpr double PI = 3.141592653589793;
constexpr int round_double = 100;           //100 - значит сравниваем до двух знаков после запятой (1000 до трех и т.д.)
///////////////////////////////////////////////////////////////////////////////////////////
//функция проверки ввода
double inputPositiveDoubleValue()
{
    std::string str;
    
    while(true)
    {
        bool onePoint = false;
        bool doubleValid = false;
        
        std::cin >> str;    
        std::cin.ignore(32767,'\n');
        
        for(const auto &elem : str)
        {
            if(isdigit(elem))
                doubleValid = true;     
            else if(elem == '.' && (!onePoint))
            {
                onePoint = true;
                doubleValid = true;
            }
            else
            {
                doubleValid = false;
                break;
            }
        }
        
        if(doubleValid)
            break;
        else
            std::cout << "\nInvalid input, try again: ";
    }
    
    return (str == ".") ? 0.0 : stod(str);
}
///////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
class Rectangle
{
    private:
        double m_width;         //ширина
        double m_length;        //длина
        
    public:
        Rectangle() : m_width(0.0), m_length(0.0)
        {
        }
        
        Rectangle(double width, double length)
        : m_width(width), m_length(length)
        {
        }
        
        double getSquare() const
        {
            return m_width * m_length;
        }
        
        double getPerimeter() const
        {
            return 2 * (m_width + m_length);
        }   
        
        friend std::ostream& operator << (std::ostream &out, const Rectangle &obj);
        friend std::istream& operator >> (std::istream &in, Rectangle &obj);
};
//----------------------------------------------------------------------------------------------------------------
std::ostream& operator << (std::ostream &out, const Rectangle &obj)
{
    out << "Rectangle -----------------------------"<< "\n";
    out << "Width:     "    << obj.m_width          << "\n";
    out << "Length:    "    << obj.m_length         << "\n";
    out << "Square:    "    << obj.getSquare()      << "\n";
    out << "Perimeter: "    << obj.getPerimeter()   << "\n";
    
    return out;
}
//----------------------------------------------------------------------------------------------------------------
std::istream& operator >> (std::istream &in, Rectangle &obj)
{
    std::cout << "Enter width: ";
    obj.m_width = inputPositiveDoubleValue();
    
    std::cout << "Enter length: ";
    obj.m_length = inputPositiveDoubleValue();
    
    return in;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
class Circle
{
    private:
        double m_radius;        //радиус
        
    public:
        Circle() : m_radius(0.0)
        {
        }
        
        Circle(double radius) : m_radius(radius)
        {
        }
        
        double getSquare() const
        {
            return PI * m_radius * m_radius;
        }
        
        double getPerimeter() const
        {
            return 2 * PI * m_radius;
        }   
        
        friend std::ostream& operator << (std::ostream &out, const Circle &obj);
        friend std::istream& operator >> (std::istream &in, Circle &obj);
};
//----------------------------------------------------------------------------------------------------------------
std::ostream& operator << (std::ostream &out, const Circle &obj)
{
    out << "Circle -----------------------------"   << "\n";
    out << "Radius:    "    << obj.m_radius         << "\n";
    out << "Square:    "    << obj.getSquare()      << "\n";
    out << "Perimeter: "    << obj.getPerimeter()   << "\n";
    
    return out;
}
//----------------------------------------------------------------------------------------------------------------
std::istream& operator >> (std::istream &in, Circle &obj)
{
    std::cout << "Enter radius: ";
    obj.m_radius = inputPositiveDoubleValue();
    
    return in;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
//возвращает true, если площадь прямоугольника меньше площади круга, иначе возвращает false
bool compareAreas (Rectangle *rectangle, Circle *circle)
{
    return std::lround(rectangle->getSquare() * round_double) < std::lround(circle->getSquare() * round_double);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//возвращает true, если периметр прямоугольника меньше периметра круга, иначе возвращает false
bool comparePerimeters (Rectangle *rectangle, Circle *circle)
{
    return std::lround(rectangle->getPerimeter() * round_double) < std::lround(circle->getPerimeter() * round_double);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::ifstream inf("Input.txt");
    char ch;
    double width;
    double length;
    double radius;
    std::vector<Rectangle> vec_rectangle;
    std::vector<Circle> vec_circle;
    
    if(!inf)
    {
        std::cerr << "The file could not be opened!\n";
        return 1;
    }
    
    while(inf >> ch)
    {   
        if(ch == 'r')
        {
            inf >> width;
            inf >> length;
            vec_rectangle.push_back({width, length});
        }
        else if(ch == 'c')
        {
            inf >> radius;
            vec_circle.push_back({radius});
        }
        else
        {
            std::cerr << "Undefined object!\n";
            return 1;
        }
    }   
    
    //сравниваем площадь второго прямоугольника и первого круга из файла
    std::cout << "Is the area of the second rectangle smaller \nthan the area of the first circle from the file data? Answer: ";
    std::cout << std::boolalpha << ((compareAreas(&vec_rectangle[1], &vec_circle[0])) ? "Yes." : "No.") << "\n\n";
    
    //выводим подробную информацию по объектам на экран
    for(const auto &obj : vec_rectangle)
    {
        std::cout << obj << "\n";
    }
    
    for(const auto &obj : vec_circle)
    {
        std::cout << obj << "\n";
    }
    
    return 0;
}