Studying code

#pragma once
#include <iostream>
#include <string>
#include <string.h>
#include <stdlib.h>
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{
        friend double operator +(Car& c1, Car& c2); //дружественная оператор, всё равно не даёт доступа к приватным атрибутам
        //задание именно в том, чтобы использовать friend для получения доступа к приватному атрибуту cost
    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;
        }
        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(); //функция ввода параметров, ещё не определена
        };

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
    //я пытался использовать set, но всё равно не получилось
    marka = newCar.marka;
    power = newCar.power;
    cost = newCar.cost;
    displacement = newCar.displacement;

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


double operator + (Car& c1, Car& c2)
{ return (c1.cost+c2.cost); } //ошибка: оператор не может получить доступа к private атрибуту

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

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

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

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

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

const char* car_name = "Toyota";
const int car_power = 140;
const float car_price = 16.1;
const int car_displacement = 1800;
const char* truck_name = "Scania";
const int truck_power = 640;
const float truck_price = 28.1;
const int truck_displacement = 3000;
const float capacity = 2.0;

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);
        //delete new_car; //не помогает
    }
    group.Print();
    group[0].Print(); //из-за неопределённости оператора присваивания выводятся странные символы - случайные значения
    double price = group.GetCar(0);
    std::cout << price << endl;
    //double sum = group.GetCar(1)+group.GetCar(2);
    //cout << sum << endl;
return 0;
}