Массив указателей на объекты наследуемых классов

class Particle {
protected:
    double x, y;
    double vx, vy;
    double radius;
public:
    Particle() : Particle(0, 0, 0, 0, 0) {}
    Particle(double ax, double ay, double avx, double avy, double aradius)
         : x(ax), y(ay), vx(avx), vy(avy), radius(aradius) {}
    virtual ~Particle() {}
    
    //virtual void Collision() = 0;
 
    void Move(time) {
        x += vx * time;
        y += vy * time;
    };
 
};
 
class System {
private:
    // unsigned time;
    // std::vector<Particle*> particles;
    Particle* particles;
    unsigned size;
    unsigned elems;
    static const unsigned defaultSize;
public:
    System() : System(defaultSize) {}
    System(unsigned asize) : elems(0) {
        if(asize < defaultSize)
            asize = defaultSize;
        size = asize;
        particles = new (Particle*)[size] {};
    }
    System(const System& obj) {
        size = obj.size;
        elems = obj.elems;
        particles = new (Particle*)[size] {};
        for( ; particles != NULL ; particles++)
            (*particles) = obj.*particles;
    }
    ~System() { delete[] particles; }
 
    //void add();
    //void delet();
};
const unsigned System::defaultSize = 8;

vector<Parttcles*> parttcles ;
//some fill
parttcles [i]->Collision();

// std::vector<Particle*> particles;

class System {
private:
    int* ptr;
    unsigned size;
    unsigned elems;
    static const unsigned defaultSize;
public:
    System() : System(defaultSize) {};   
    System(unsigned asize) : elems(0) {
        if(asize < defaultSize)
            asize = defaultSize;
        size = asize;
        ptr = new (int*)[size] {};
    }
******
};

class System {
private:
    Particle** particles;
    unsigned size;
    unsigned elems;
    static const unsigned defaultSize;
public:
    System() : System(defaultSize) {}
    System(unsigned asize) : elems(asize) {
        if(asize < defaultSize)
            asize = defaultSize;
        size = asize;
        particles = new Particle*[size+1];
 
        for (unsigned i = 0 ; i < size; i++) {
            particles[i] = new Particle();
        }
        particles[size+1] = NULL;
    }
    System(const System& obj) {
        size = obj.size;
        elems = obj.elems;
        particles = new Particle*[size+1];
 
        for (unsigned i = 0; i < size+1; i++) 
            particles[i] = obj.particles[i];       
    }
    ~System() { delete[] particles; 
};
const unsigned System::defaultSize = 8;

System(const System& obj) {
    size = obj.size;
    elems = obj.elems;
    particles = new Particle * [size];
 
    for (unsigned i = 0; i < size; i++)
        particles[i] = new Particle(obj.particles[i]);
}

~System()
{
    for (unsigned i = 0; i < size; i++)
        delete particles[i];
 
    delete[] particles;
}

~System()
{
    for (unsigned i = 0; i < size; i++)
        delete particles[i];
 
    delete[] particles;
}

#include <iostream>
#include <vector>
#include <memory>
#include <initializer_list>
 
using namespace std;
 
struct Particle
{
virtual void name()=0;
virtual ~Particle(){}
};
 
struct Positron :public Particle
{
    void name(){cout<<"Positron\n";}
};
 
struct Electron :public Particle
{
    void name(){cout<<"Electron\n";}
};
 
struct HiggsBoson :public Particle
{
    void name(){cout<<"HiggsBoson\n";}
};
 
struct Hihix :public Particle
{
    void name(){cout<<"Hihix\n";}
};
 
 
template<typename T>
std::vector<T> vector_from(std::initializer_list<T> il)
{
  std::vector<T> result;
  result.reserve(il.size());
  for (auto& e : il)
    result.push_back(std::move(const_cast<T&>(e)));
  return result;
}
 
class SystemParticles
{
 public:
    SystemParticles(std::initializer_list<unique_ptr<Particle>>& ilist)
    :particles(vector_from(ilist))
    {
 
    }
    void allNames()
    {
        for(const auto &prtcl:particles)prtcl->name();
    }
private:
vector<unique_ptr<Particle>> particles;
};
 
int main()
{
std::initializer_list<unique_ptr<Particle>> ilist=
{
    unique_ptr<Particle>(new Positron),
    unique_ptr<Particle>(new Electron),
    unique_ptr<Particle>(new HiggsBoson),
    unique_ptr<Particle>(new Electron),
    unique_ptr<Particle>(new Hihix),
    unique_ptr<Particle>(new Positron)
};
SystemParticles systemParticles(ilist);
systemParticles.allNames();
return 0;
}

class System {
private:
    std::vector<std::unique_ptr<Particle>> particles;
public:
    System(const std::initializer_list<std::unique_ptr<Particle>>& alist) {
        particles.reserve(alist.size());
        for (auto& elem : alist) {
            particles.push_back(std::move(const_cast<std::unique_ptr<Particle>&>(elem)));
        }
    }
 
    void allNames() {
        for (const auto& prtcl : particles) prtcl->Name();
    }
};

int main() {
        std::initializer_list<std::unique_ptr<Particle>> particlesList {
        std::unique_ptr<Particle>(new lightParticle),
        std::unique_ptr<Particle>(new heavyParticle),
    };
 
    System obj(particlesList);
    obj.allNames();
 
    return 0;
}

    void allNames() {
        for (const auto& prtcl : particles) prtcl->Name();
    }

vector<unique_ptr<Particle>> particles;

(*it)->Name();

        auto begin{ &particles[0] };
        auto end{ begin + particles.size()};
        for (auto ptr = begin; ptr < end; ++ptr) {
            (*ptr)->Name();
        }

for (auto& elem : alist) {