//car.h
#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{
    public:
        friend float operator+(const Car& c1, const Car& c2);
    private:
        const char* marka; //марка авто
        int power; //мощность двигателя в кВт
        float cost; //стоимость в тыс. $
        int displacement; //объём двигателя
    public:
        Car& operator= (const Car& newCar);
        operator float () {
        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;
        }
        int getPower() const { //метод чтения поля мощность
            return power;
        }
        float getCost() const { //метод чтения поля стоимость
            return cost;
        }
        int getDis() const { //метод чтения поля объём двигателя
            return displacement;
        }
        ~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 Input(); //функция ввода параметров, ещё не определена
        };

//car.cpp
#include <iostream>
#include "car.h"

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

void Car::Input(){ //функция ввода параметров
        char *marka_ = new char[16];
        std::cout << "Input mark: "; //введите марку авто
        std::cin >> marka_;
        setMarka(marka_);

        do{
        std::cout << "Input power (kW): "; //введите мощность авто в кВт
        std::cin >> power;
        } while(setPower(power)); //мощность не может быть неположительной

        do{
        std::cout << "Input cost (thousand $): "; //введите стоимости авто в тыс. $
        std::cin >> cost;
        } while(setCost(cost)); //стоимость не может быть неположительной

        do{
        std::cout << "Input displacement (cm3): "; //введите объём двигателя в см3
        std::cin >> displacement;
        } while(setDis(displacement)); //объём двигателся не может быть неположительным
        delete marka_;
    };

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


float operator +(const Car& c1, const Car& c2) {
    return (c1.cost+c2.cost);
}


//group.h
#include "car.h" //подключение заголовочного файла

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);
        }
        operator double (){
        int summ = 0;
        for(int i = 0; i < size; i++){
        //summ += array[i].getCost();
        summ += array.at(i).getCost();
        }
        return summ/size;
        }
        int Size();
        void Print();
};


//group.cpp
#include <iostream>
#include "group.h"

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


//main.cpp
#pragma once
#include "group.h" //подключение заголовочного файла

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;
    }
    //group.Print();
    //group[0].Print();
    //Car test = group[0];
    //test.Print();
    //double price = group.GetCar(0);
    //std::cout << price << endl;
    float sum = group.GetCar(1)+group.GetCar(2);
    cout << sum << endl;
    system("pause");
return 0;
}