#pragma once
#include <iostream>
#include <string>
#include <string.h>
#include <stdlib.h>
#include <vector>
using namespace std;

namespace{
const char* def_marka = "Renault";
const int def_power = 150;
float const def_price = 15.15;
const int def_displacement = 1830;
}

class Car{
    private:
        const char* marka; //марка авто
        int power; //мощность двигателя в кВт
        float cost; //стоимость в тыс. $
        int displacement; //объём двигателя
    public:
        Car& operator= (const Car& newCar);
        operator double () {
        return this->cost;
    }
        void setMarka(const char* m);
        //следующие методы записи возвращают false, чтобы прервать цикл ввода
        bool setPower(int pw); //метод записи мощности
        bool setCost(float p); //метод записи стоимости
        bool setDis(int dis); //метод записи объём двигателя
        std::string getMarka() const { //метод чтения поля марка
            return marka;
        }
        ~Car();
        Car(const char* m = def_marka, int pw = def_power, float p = def_price, int dis = def_displacement);
        //Car(const char* m, int pw, float p, int dis);
        void Print() const;

void Car::setMarka(const char* m){ //метод записи марки
            marka = m;
        }

bool Car::setPower(int pw){ //метод записи мощности
            if (pw > 0 ){
            power = pw;
            return false;
            }
            else{
                return true;
            }
        }

bool Car::setCost(float p){ //метод записи стоимости
            if (p > 0 ){
            cost = p;
            return false;
            }
            else{
                return true;
            }
        }

bool Car::setDis(int dis){ //метод записи объём двигателя
            if (dis > 0 ){
            displacement = dis;
            return false;
            }
            else{
                return true;
            }
        }

Car::~Car(){
std::cout << "Destructor called for Car of mark " << getMarka() << std::endl;
}

void Car::Print() const{ //вывод параметров на экран
            cout << "Marka is " << getMarka() << endl;
            cout << "Price equals " << getCost() << " thousand $" << endl;
            cout << "Power equals " << getPower() << " kW" << endl;
            cout << "Displacement equals " << getDis() << " cm3" << endl;
        }

Car::Car(const char* m, int pw, float p, int dis){
        marka = m;
        power = pw;
        cost = p;
        displacement = dis;
}

Car& Car::operator= (const Car& newCar)
{
    // do the copy
    //setMarka(new_car.marka);
    //setPower(new_car.power);
    //setCost(new_car.cost);
    //setDis(new_car.displacement);
    marka = newCar.marka;
    power = newCar.power;
    cost = newCar.cost;
    displacement = newCar.displacement;

    // return the existing object so we can chain this operator
    return *this;
}

class Group{
    public:
        int size;
        //Car* array;
        vector <Car> array;
    public:
        //void PutCar(int i, Car& trans);
        void PutCar(Car& trans);
        Car& GetCar(int i){
            //return array[i];
            return array.at(i);
        }
        ~Group();
    public:
        Group(int size){ //конструктор по умолчанию
            size = size;
            //array = new Car[size];
            //std::vector<Car>array;
            //array = vector<Car> array;
        };
        Car& Group::operator[](int i){
            //return array[i];
            return array.at(i);
        }
        int Size();
        void Print();
};

int Group::Size(){
    return size;
};

void Group::Print(){
    for (int i = 0; i<size; i++){
        //Car one = array.at(i);
        //array[i].Print();
        //one.Print();
        array.at(1).Print();
    }
    //array[0].Print();
};

//void Group::PutCar(int i, Car& trans){
void Group::PutCar(Car& trans){
            //array[i] = trans;
            array.push_back(trans);
            //std::vector<Car> arr;
        }

Group::~Group(){
    //delete array;
    array.clear();
    std::cout << "Destructor called for Group of size " << Size() << std::endl;
}

int main(){
    //Car* new_car = new Car();
    char marks[3][5] = {"Audi","BMW","Ford"};
    int powers[3] = {100,110,120};
    float costs[3] = {16.5,18,19.2};
    int displaces[3] = {1800,1900,1980};
    Group group(3);
    for (auto i = 0; i < 3; i++){
        Car new_car(marks[i],powers[i],costs[i],displaces[i]);
        //Car new_car(marks[i],powers[i],costs[i],displaces[i]);
        //Car *new_car = new Car(marks[i],powers[i],costs[i],displaces[i]);
        //group.PutCar(i,new_car);
        group.PutCar(new_car);
        //delete new_car;
    }
    system("pause");
return 0;
}