In my code for numerical physics, I need to create an array of Derived objects using the `unique_ptr` with their type being the Base class. Normally, I would have:

```
// Header file of the Base class
class Particle{
public:
    Particle();             // some constructor
    virtual ~Particle();    // virtual destructor because of polymorphism
    virtual function();     // some random function for demonstration
};

// Header file of the Derived class
class Electron : public Particle{
public:
    Electron();
    // additional things, dynamic_cast<>s, whatever
};

```

Later in my code, to create an array of Derived objects with the Base type pointer, I would do

```
Particle* electrons = new Electron[count];

```

The advantage is that I am able to use the array in a really convenient way of `electrons[number].function()`, because the incremental value in `[]` is actually the address of the memory that points to the proper instance of the object `Electron` in the array. However, using raw pointers gets messy, so I decided to use the smart pointers.

Problem is with the definition of the Derived objects. I can do the following:

```
std::unique_ptr<Particle, std::default_delete<Particle[]>> electrons(new Electron[count]);

```

which creates the array of polymorphic Electrons and uses even the proper call of `delete[]`. The problem lies in the way of calling the specific objects of the array, as I have to do this:

```
electrons.get()[number].function();

```

and I don't like the `get()` part, not a little bit.

I could do the following:

```
std::unique_ptr<Particle[]> particles(new Particle[count]);

```

and yes, call the instances of `Particle` type in the array with the

```
particles[number].function();

```

and everything would be fine and dandy, except for the part that I am not using the specific details of the class `Electron`, therefore the code is useless.

And now for the funny part, let's do one more thing, shall we?

```
std::unique_ptr<Particle[]> electrons(new Electron[count]);

```

BOOM!

```
use of deleted function ‘std::unique_ptr<_Tp [], _Dp>::unique_ptr(_Up*) [with _Up = Electron; <template-
 parameter-2-2> = void; _Tp = Particle; _Dp = std::default_delete<Particle []>]’

```

What is going on?