#include <iostream>
#include <memory>
#include <vector>
#include <algorithm>
using namespace std;
 
 
// Header file of the Base class
class Particle{
	int a; 
public:
    Particle() {}            // some constructor
    virtual ~Particle() { cout << "Particle dies"<<endl; }    // virtual destructor because of polymorphism
    virtual void function() { cout <<"Bing"<<endl; }     // some random function for demonstration
};
 
// Header file of the Derived class
class Electron : public Particle{
	int b; 
public:
    Electron() {}
    ~Electron() { cout << "Electron dies"<<endl; }
    void function() override { cout <<"Bang"<<endl; }     // some random function for demonstration
 
    // additional things, dynamic_cast<>s, whatever
};
 
int main() {
	int count=3; 
 
	// If want to create arrays the old way
	cout << "Allocating non polymorphic arrays, for the record"<<endl;  
	{
	  std::unique_ptr<Particle, std::default_delete<Particle[]>> particle(new Particle[count]);
	  std::unique_ptr<Electron, std::default_delete<Electron[]>> electrons(new Electron[count]);
	}
 
	// alternative approach
	cout <<endl<<endl<<"Alternative approach:"<<endl; 
	vector<Electron>myelectrons(count);  // object store
	vector<Particle*>ve(count, nullptr); // polymorphic adaptor
	transform(myelectrons.begin(), myelectrons.end(), ve.begin(), [](Particle&e){return &e;} );
	for (auto x: ve)
	   x->function(); 
 
	return 0;
}

I2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8bWVtb3J5PgojaW5jbHVkZSA8dmVjdG9yPgojaW5jbHVkZSA8YWxnb3JpdGhtPgp1c2luZyBuYW1lc3BhY2Ugc3RkOwoKCi8vIEhlYWRlciBmaWxlIG9mIHRoZSBCYXNlIGNsYXNzCmNsYXNzIFBhcnRpY2xlewoJaW50IGE7IApwdWJsaWM6CiAgICBQYXJ0aWNsZSgpIHt9ICAgICAgICAgICAgLy8gc29tZSBjb25zdHJ1Y3RvcgogICAgdmlydHVhbCB+UGFydGljbGUoKSB7IGNvdXQgPDwgIlBhcnRpY2xlIGRpZXMiPDxlbmRsOyB9ICAgIC8vIHZpcnR1YWwgZGVzdHJ1Y3RvciBiZWNhdXNlIG9mIHBvbHltb3JwaGlzbQogICAgdmlydHVhbCB2b2lkIGZ1bmN0aW9uKCkgeyBjb3V0IDw8IkJpbmciPDxlbmRsOyB9ICAgICAvLyBzb21lIHJhbmRvbSBmdW5jdGlvbiBmb3IgZGVtb25zdHJhdGlvbgp9OwoKLy8gSGVhZGVyIGZpbGUgb2YgdGhlIERlcml2ZWQgY2xhc3MKY2xhc3MgRWxlY3Ryb24gOiBwdWJsaWMgUGFydGljbGV7CglpbnQgYjsgCnB1YmxpYzoKICAgIEVsZWN0cm9uKCkge30KICAgIH5FbGVjdHJvbigpIHsgY291dCA8PCAiRWxlY3Ryb24gZGllcyI8PGVuZGw7IH0KICAgIHZvaWQgZnVuY3Rpb24oKSBvdmVycmlkZSB7IGNvdXQgPDwiQmFuZyI8PGVuZGw7IH0gICAgIC8vIHNvbWUgcmFuZG9tIGZ1bmN0aW9uIGZvciBkZW1vbnN0cmF0aW9uCiAgICAKICAgIC8vIGFkZGl0aW9uYWwgdGhpbmdzLCBkeW5hbWljX2Nhc3Q8PnMsIHdoYXRldmVyCn07CgppbnQgbWFpbigpIHsKCWludCBjb3VudD0zOyAKCQoJLy8gSWYgd2FudCB0byBjcmVhdGUgYXJyYXlzIHRoZSBvbGQgd2F5Cgljb3V0IDw8ICJBbGxvY2F0aW5nIG5vbiBwb2x5bW9ycGhpYyBhcnJheXMsIGZvciB0aGUgcmVjb3JkIjw8ZW5kbDsgIAoJewoJICBzdGQ6OnVuaXF1ZV9wdHI8UGFydGljbGUsIHN0ZDo6ZGVmYXVsdF9kZWxldGU8UGFydGljbGVbXT4+IHBhcnRpY2xlKG5ldyBQYXJ0aWNsZVtjb3VudF0pOwoJICBzdGQ6OnVuaXF1ZV9wdHI8RWxlY3Ryb24sIHN0ZDo6ZGVmYXVsdF9kZWxldGU8RWxlY3Ryb25bXT4+IGVsZWN0cm9ucyhuZXcgRWxlY3Ryb25bY291bnRdKTsKCX0KCQoJLy8gYWx0ZXJuYXRpdmUgYXBwcm9hY2gKCWNvdXQgPDxlbmRsPDxlbmRsPDwiQWx0ZXJuYXRpdmUgYXBwcm9hY2g6Ijw8ZW5kbDsgCgl2ZWN0b3I8RWxlY3Ryb24+bXllbGVjdHJvbnMoY291bnQpOyAgLy8gb2JqZWN0IHN0b3JlCgl2ZWN0b3I8UGFydGljbGUqPnZlKGNvdW50LCBudWxscHRyKTsgLy8gcG9seW1vcnBoaWMgYWRhcHRvcgoJdHJhbnNmb3JtKG15ZWxlY3Ryb25zLmJlZ2luKCksIG15ZWxlY3Ryb25zLmVuZCgpLCB2ZS5iZWdpbigpLCBbXShQYXJ0aWNsZSZlKXtyZXR1cm4gJmU7fSApOwoJZm9yIChhdXRvIHg6IHZlKQoJICAgeC0+ZnVuY3Rpb24oKTsgCgkKCXJldHVybiAwOwp9