SFML destructor issues with deleting array - c++

Question

I've been working on my spaceInvaders clone and I'm now trying to finish of the project with cleaning the memory leaks.
Currently I'm trying to delete an array of 11 aliensobjects created in a constructor, however whilst doing so the program breaks (crashes) at the destructor of AlienRow.
I've tried the following things:
Created nullpointers in constructor and deleted with this:
for (int i = 0; i < 11; i++)
{
if (alienRow[i] != nullptr)
{
delete alienRow[i];
}
delete *alienRow;
as well as:
delete [] alienRow;
Any pointers to why this issue occurs?
#include "AlienRow.h"
AlienRow::AlienRow(float x, float y, int type){
for (int i = 0; i < 11; i++)
{
alienRow[i] = nullptr;
}
if (type == 1){
for (int i = 0; i < 11; i++)
{
alienRow[i] = new Alien(x, y, "Alien1.png");
x = x + 70;
}
}
if (type == 2){
for (int i = 0; i < 11; i++)
{
alienRow[i] = new Alien(x, y, "Alien2.png");
x = x + 70;
}
}
if (type == 3){
for (int i = 0; i < 11; i++)
{
alienRow[i] = new Alien(x, y, "Alien3.png");
x = x + 70;
}
}
}
AlienRow::~AlienRow(){
/*for (int i = 0; i < 11; i++)
{
if (alienRow[i] != nullptr)
{
delete alienRow[i];
}
delete *alienRow;
}*/
delete [] alienRow;
}
void AlienRow::draw(RenderTarget& target, RenderStates states)const{
for (int i = 0; i < 11; i++)
{
target.draw(*alienRow[i]);
}
}
Alien* AlienRow::getAlienRowA(int nr)const{
return alienRow[nr];
}
bool AlienRow::getAlienMove(float x, float y){
for (int i = 0; i < 11; i++)
{
if (alienRow[i]->moveAlien(x, y) == true)
return true;
}
return false;
}
#pragma once
#include "Alien.h"
#include <iostream>
class AlienRow :public sf::Drawable {
private:
Alien* alienRow[11];
float alienVelocity;
public:
Alien* getAlienRowA(int nr)const;
virtual void draw(RenderTarget& target, RenderStates states)const;
bool getAlienMove(float x, float y);
AlienRow(float x, float y, int type);
~AlienRow();
};
Alien:
#include "Alien.h"
#include <iostream>
Alien::Alien(float x, float y, std::string alien){
alienTexture.loadFromFile(alien);
alienSprite.setTexture(alienTexture);
alienSprite.setPosition(x, y);
alienSprite.setScale(sf::Vector2f(0.7f, 0.7f));
}
Alien::~Alien(){
}
void Alien::draw(RenderTarget& target, RenderStates states)const{
target.draw(alienSprite);
}
void Alien::update(float dt){
}
Sprite Alien::getAlienSprite()const{
return alienSprite;
}
void Alien::moveDeadSprite(){
alienSprite.setPosition(alienSprite.getPosition().x, alienSprite.getPosition().y - 700);
}
bool Alien::moveAlien(float x, float y){
alienSprite.move(x, y);
if (alienSprite.getPosition().y > 540){
return true;
}
return false;
}
#pragma once
#include "Entity.h"
class Alien:public Entity{
private:
Sprite alienSprite;
Texture alienTexture;
float velocity;
public:
Sprite getAlienSprite()const;
void moveDeadSprite();
bool moveAlien(float x, float y);
virtual void draw(RenderTarget& target, RenderStates states)const;
virtual void update(float dt);
Alien(float x, float y, std::string alien);
virtual ~Alien();
};
AlienSwarm
#include "AlienSwarm.h"
AlienSwarm::AlienSwarm(float y){
aRow[0] = new AlienRow(0,y,3);
y = y + 50;
aRow[1] = new AlienRow(0,y,2);
y = y + 50;
aRow[2] = new AlienRow(0, y,3);
y = y + 50;
aRow[3] = new AlienRow(0, y,2);
y = y + 50;
aRow[4] = new AlienRow(0, y,1);
y = y + 50;
}
AlienSwarm::~AlienSwarm(){
for (int i = 0; i < 5; i++)
{
delete aRow[i];
}
}
void AlienSwarm::draw(RenderTarget& target, RenderStates states)const{
for (int i = 0; i < 5; i++){
target.draw(*aRow[i]);
}
}
AlienRow* AlienSwarm::getAlienSwarmA(int nr)const{
return aRow[nr];
}
void AlienSwarm::update(){
}
bool AlienSwarm::getAlienMoveRow(){
for (int i = 0; i < 5; i++)
{
if (aRow[i]->getAlienMove(0, 0.5f) == true)
return true;
}
return false;
}
#pragma once
#include "AlienRow.h"
class AlienSwarm:public Drawable{
private:
AlienRow* aRow[5];
float y;
public:
AlienRow* getAlienSwarmA(int nr)const;
bool getAlienMoveRow();
virtual void draw(RenderTarget& target, RenderStates states)const;
virtual void update();
AlienSwarm(float y);
virtual ~AlienSwarm();
};

Answer 1

Match your new calls to your delete calls.
delete *alienRow;
There is no matching new for this. You effectively delete the first element of your array 12 times. Remove this line.
delete [] alienRow;
You array is not created using new. Remove this line as well.

Answer 2

Use smart pointers and (unique_ptr or shared_ptr) and you do not have to delete them.