baseAbstract& result = marr.get_value(0);

 baseAbstract& result = marr.get_value(0);
for(int i = 1; i < size; i++)
{
      result = marr.get_value(i);
      result.showInfo();
      result.doWork();
      //............
      //...............
}

void resultProc(baseAbstract& result)
{
      result.showInfo();
      result.doWork();
      //............
      //...............
}

for(int i = 1; i < size; i++)
{
     resultProc(marr.get_value(i))
}

class CombatVehicle
{
private:
    std::string  type;
    std::string  model;
protected:
    struct minMax
    {
        double min;
        double max;
    };
    double  health;
    double  last_damage;
    double  last_defence;

public:
    CombatVehicle();
    CombatVehicle(std::string type, std::string model, double health);
    virtual ~CombatVehicle(); 
    bool IsDestroyed() const{ return health <= 0; };
    void ShowShortInfo() const { std::cout << "  " << type << " :  " << model << std::endl; };
    virtual void ShowInfo(int X, int Y, HANDLE handle);
    virtual double Attack() const = 0;
    virtual void   Defense(double damage) = 0;
    std::string getType()const { return type;}
};

lass Tank : public CombatVehicle
{
private:
    double recharge_time;
    double shot_acuracy;
    double armor_thickness;
    static constexpr  minMax rtime     { 1.5 , 2 };
    static constexpr  minMax acuracy   { 2,3 };
    static constexpr  minMax thickness { 30,50 };
    static constexpr  minMax thealth   { 1500,2000 };
    static constexpr const char*  models[5] { "M1A1 Abrams","Leopard","T-64BM Oplot","Merkava","Leclerc" };
public:
    Tank();
    Tank(std::string type, std::string model, double health, double recharge_time,double shot_acuracy,double armor_thickness);
    void   ShowInfo(int X, int Y,HANDLE handle) ;
    double Attack() const { return (100 * shot_acuracy) / recharge_time; }
    void   Defense(double damage); 
};

class Troops
{
private:
    enum class VehicleType
    {
        Tank = 1,
        ArmoredCar,
        AirDefenseVehicle
    };

    static const size_t max_count              = 10;
    static const size_t min_count              = 5;
    
    std::string name;
    int vehicles_count;
    CombatVehicle** troops;
public:
    Troops();
    ~Troops();
    Troops(std::string name,int vehicles_count);
    bool isVechicleExist() { return vehicles_count > 0; }
    void show(int X, int Y, HANDLE handle) const;
    CombatVehicle& getVehicle() { return *troops[vehicles_count - 1]; };
    void dellCurentVehicle();
    void v_show(int index,int prnt_index,int X, int Y, HANDLE handle) const;
};

class Battle
{
private:
    Troops troops1;
    Troops troops2;
    int pause = 500;
    bool rаund(CombatVehicle& veh1, CombatVehicle& veh2, HANDLE handle);
    bool isDestroyed(CombatVehicle& veh, HANDLE handle , bool swich);
    HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
public:
    Battle(std::string tr1name, std::string tr2name,int trvCount, int tr2vCount = 0);
    void battleStart();
};

• IsDestroyed () – перевіряє чи машина знищена (true/false) відповідно до рівня health
• ShowInfo () – відображає всю актуальну інформацію
• Attack () = 0 – виконує атаку (повертається кількість нанесеного урону)
• Defense (damage) = 0 – виконує оборону від атаки, приймаючи нанесений урон
Для проведення раунда створити окрему функцію Round (bm1, bm2)

class Myclass : public baseAbstract {}
class MyClassArr
{
    public:
        MyClassArr(int size):size(size)
        {
            arr = new MyClass*[size]{}; // тут потрібно виділяти пам'ять не під похідні елементи класу, а базові (baseAbstract)
        }

arr = new MyClass*[size]{};

for(int i = 0;i < size;i++) delete arr[i];

delete [] arr

delete [] arr[i];
delete arr[i]

#include <iostream>
using namespace std;

class Base { /* ... */ };
class Derived_1 : public Base { /* ... */ };
class Derived_2 : public Base { /* ... */ };
class Derived_3 : public Base { /* ... */ };
class Array
{
public:
    ~Array()
    {
        /* ... */
        for (size_t i = 0; i < s; ++i)
            if (p[i])
                delete[] p[i], p[i] = nullptr;
        /* ... */
        delete[] p;
    }
    Array(size_t siz) : s(siz) {
        p = new Base *[s];
    }
    void setBase(Base *pb, size_t id) { p[id] = pb; }
    Base *getBase(size_t id) { return p[id]; }

private:
    Base **p = nullptr;
    size_t s;
};
int main()
{
    Array a1(2);
    Base *b1 = new Derived_1[4]{};
    Base *b2 = new Derived_3[7]{};
    a1.setBase(b2, 0);
    a1.setBase(b1, 1);
    
    // Видалення b1, b2 виконає ~Array    
    
    Array a2(3);
    a2.setBase(new Derived_1[5]{}, 0);
    a2.setBase(new Derived_3[3]{}, 2);
    a2.setBase(new Derived_2[1]{}, 1);

    // Видалення об'єктів Base виконується вручну
    delete[] a2.getBase(2), a2.setBase(nullptr, 2);
    delete[] a2.getBase(0), a2.setBase(nullptr, 0);
    delete[] a2.getBase(1), a2.setBase(nullptr, 1);

    return 0;
}