Ошибка при создании и заполнении динамического массива указателей на объекты

subset = new CARD * [size] {nullptr};

void fill(DECK& deck)

deck[i] = NULL; // убираем указатель т.е. убираем карту из колоды!

~DECK() 
    {
        for (int i = 0; i < 52; i++) delete deck[i];
 
        //delete this;
    }

#include <iostream>
#include <cstdlib>
#include <ctime>
 
using namespace std;
 
enum Fvalues { EMPTY = 0, TWO = 2, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE };
enum Suits { NOSUIT = 0, HEARTS = 3, DIAMONDS, CLAWS, SPADES };
 
// CARD CLASS
class CARD
{
private:
    Fvalues fval;
    Suits suit;
public:
    CARD() : fval(EMPTY), suit(NOSUIT) // no-arg c-tor
    {}
 
    CARD(Fvalues fv, Suits st) : fval(fv), suit(st) // 2-arg c-tor
    {}
 
    CARD(int fv, int st) : fval(static_cast<Fvalues>(fv)), suit(static_cast<Suits>(st))
    {}
 
    void display() const;
 
    void setFval(const int fv) {
        fval = static_cast<Fvalues>(fv);
    }
    void setSuit(const int st) {
        suit = static_cast<Suits>(st);
    }
    Fvalues getFval() const {
        return fval;
    }
    Suits getSuit() const {
        return suit;
    }
};
 
void CARD::display() const {
    if (fval == 0 && suit == 0) {
        cout << static_cast<char>(254) 
            << " " << static_cast<char>(254) << endl;
    } // если пустое значение ДОСТОИНСТВА и МАСТИ для вновь созданной карты выводим 2 квадратика!!!
 
    if (fval >= 2 && fval <= 9) 
        cout << fval; // выводим достоинство карты
    else
        switch (fval) {
        case 10: { 
            cout << "T";
            break;
        }
        case 11: {
            cout << "J";
            break;
        }
        case 12: {
            cout << "Q";
            break;
        }
        case 13: {
            cout << "K";
            break;
        }
        case 14: {
            cout << "A";
            break;
        }
        default: {
            cout << "Unknown face value!\n";
            break;
        }
    } // выводим достоинство карты
 
 
    if (suit >= 3 && suit <= 6)
        cout << static_cast<char>(suit) << endl; // выводим масть карты
    else 
        cout << "Unknown suit!\n";
}
 
//  DECK CLASS
class DECK
{
private:
    CARD* deck = nullptr;
    unsigned short SIZE;
public:
    DECK() {
        SIZE = 52;
        deck = new CARD[SIZE];
        initDesk();
    }
 
    ~DECK() {
        if (deck != nullptr) {
            delete[] deck;
            deck = nullptr;
        }
    }
    void initDesk() {
        int it = 0;
        for (int su = 3; su <= 6; su++) {
            for (int fv = 2; fv <= 14; fv++) {
                deck[it].setSuit(su);
                deck[it++].setFval(fv);
            }
        }
    }
    void display() const {
        for (int i = 0; i < SIZE; i++) {
            if (deck[i].getSuit() == 0 && deck[i].getFval() == 0)
                cout << "__\n";
            else {
                deck[i].display();
            }
            if ((i % 13) == 12) cout << endl; // ???
        }
    }
    void Swap(int ind1, int ind2) {
        CARD* temp = new CARD;
        temp->setSuit(deck[ind1].getSuit());
        temp->setFval(deck[ind1].getFval());
        deck[ind1].setSuit(deck[ind2].getSuit());
        deck[ind1].setFval(deck[ind2].getFval());
        deck[ind2].setSuit(temp->getSuit());
        deck[ind2].setFval(temp->getFval());
        delete temp;
    }
    void Shuffle() {
        int ind1, ind2;
        ind1 = ind2 = 0;
        srand(static_cast<unsigned int>(time(0))); // seed random numbers with time
        for (int j = 0; j <= 300; j++) {
            ind1 = rand() % SIZE;
            ind2 = rand() % SIZE;
            Swap(ind1, ind2);
            if (ind1 == ind2)
                j--;
        }
    }
    void drawCrd(CARD * ptr, int it) {
        if (it >= 0 && it < SIZE) {
            ptr[it].setSuit(deck[it].getSuit());
            ptr[it].setFval(deck[it].getFval());
            deck[it].setSuit(0);
            deck[it].setFval(0);
        }
        else
            cout << "Out of DECK index!\n";
    }
};
 
// SUBSET CLASS
class SUBSET {
private:
    CARD* subset = nullptr;
    unsigned short SIZE;
public:
    SUBSET() : SIZE(0), subset(nullptr) {}
 
    SUBSET(const unsigned short sz) : SIZE(sz) {
        subset = new CARD[SIZE];
    }
    ~SUBSET() {
        if (subset != nullptr) {
            delete[] subset;
            subset = nullptr;
        }
    }
 
    void fillSubset(DECK& deck) {
        for (int i = 0; i < SIZE; i++) {
            deck.drawCrd(subset, i);
        }
    }
 
    void display() const {
        if (subset != nullptr) {
            for (int i = 0; i < SIZE; i++) {
                subset[i].display();
            }
            cout << endl;
        }
    };
};
 
int main() {
    DECK d1;
    d1.display();
    cout << endl;
    d1.Shuffle();
    d1.display();
    cout << endl;
 
    SUBSET sub1(6);
    sub1.fillSubset(d1);
    sub1.display();
    cout << endl;
    d1.display();
    cout << endl;
 
    return 0;
}

   for (int i = 0; i < 52; i++) delete deck[i];
   deck=nullptr;

   delete[] deck;
   deck=nullptr;

#include <iostream>
#include <ctime>
#include <cassert>
#include <vector>
#include <optional>
 
using std::cout;
using std::endl;
 
enum class Fvalues { EMPTY = 0, TWO = 2, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE };
enum class Suits { NOSUIT = 0, HEARTS = 3, DIAMONDS, CLAWS, SPADES };
 
class CARD
{
public:
    Fvalues fval{};
    Suits suit{};
    
public:
    bool isNull()const
    {
        return fval == Fvalues::EMPTY && suit == Suits::NOSUIT;
    }
    
    void display() const
    {
        if (isNull())
        {
            cout << static_cast<char>(254) 
                << " " << static_cast<char>(254) << endl;
        }
     
        // выводим достоинство карты
        switch (fval)
        {
            default: {cout << "Unknown face value!\n";}break;
            case Fvalues::TWO  :{cout << "2";}break;
            case Fvalues::THREE:{cout << "3";}break;
            case Fvalues::FOUR :{cout << "4";}break;
            case Fvalues::FIVE :{cout << "5";}break;
            case Fvalues::SIX  :{cout << "6";}break;
            case Fvalues::SEVEN:{cout << "7";}break;
            case Fvalues::EIGHT:{cout << "8";}break;
            case Fvalues::NINE :{cout << "9";}break;
            case Fvalues::TEN  :{cout << "T";}break;
            case Fvalues::JACK :{cout << "J";}break;
            case Fvalues::QUEEN:{cout << "Q";}break;
            case Fvalues::KING :{cout << "K";}break;
            case Fvalues::ACE  :{cout << "A";}break;
        }
 
        // выводим масть карты
        switch (suit)
        {
            default: {cout << "Unknown suit!\n";}break;
            case Suits::HEARTS  :{cout << "3";}break;
            case Suits::DIAMONDS:{cout << "4";}break;
            case Suits::CLAWS   :{cout << "5";}break;
            case Suits::SPADES  :{cout << "6";}break;
        }
    }
};
 
class DECK
{
public:
    std::vector<CARD> deck;
 
    DECK(bool init_default)
    {
        if(init_default)
        {
            deck.reserve(52);
            for(auto su:{Suits::HEARTS,Suits::DIAMONDS, Suits::CLAWS, Suits::SPADES })
            {
                for (auto fv:{  Fvalues::TWO,Fvalues::THREE,Fvalues::FOUR,Fvalues::FIVE,
                                Fvalues::SIX,Fvalues::SEVEN,Fvalues::EIGHT,Fvalues::NINE,
                                Fvalues::TEN,Fvalues::JACK,Fvalues::QUEEN,Fvalues::KING,Fvalues::ACE})
                {
                    deck.push_back({fv,su});
                }
            }
        }
    }
 
    void display() const
    {
        for (const auto& card:deck)
        {
            if (card.isNull())
            {
                cout << "__\n";
            }
            else
            {
                card.display();
            }
        }
    }
    
    void Swap(const size_t ind1, const size_t ind2)
    {
        assert(ind1<deck.size());
        assert(ind2<deck.size());
        std::swap(deck[ind1],deck[ind2]);
    }
    void Shuffle() {
        int ind1{}, ind2{};
        srand(static_cast<unsigned int>(time({})));
        for (size_t j = 0; j <= 300;)
        {
            ind1 = rand() % deck.size();
            ind2 = rand() % deck.size();
            if (ind1 == ind2)
            {
                continue;
            }
 
            Swap(ind1, ind2);
            j++;
        }
    }
    
    std::optional<CARD> drawCrd(const size_t index)
    {
        std::optional<CARD> card;
        
        if (index<deck.size())
        {
            card=deck[index];
            deck.erase(deck.begin()+index);
        }
        return card;
    }
};
 
class SUBSET:public DECK
{
public:
    SUBSET():DECK(false)
    {
    }
 
    void fillSubset(DECK& src_deck,const size_t N)
    {
        deck.reserve(N);
        deck.clear();
        for (size_t i = 0; i < N && i< src_deck.deck.size(); i++)
        {
            auto card=src_deck.drawCrd(i);
            if(!card)break;
            deck.push_back(*card);
        }
    }
 
    void display() const
    {
        if(deck.size())
        {
            for (const auto& card:deck)
            {
                card.display();
            }
            cout << endl;
        }
    };
};
 
int main()
{
    DECK d1{true};
    d1.display();
    cout << endl;
    
    d1.Shuffle();
    d1.display();
    cout << endl;
 
    SUBSET sub1;
    sub1.fillSubset(d1,6);
    sub1.display();
    cout << endl;
    
    d1.display();
    cout << endl;
 
    return 0;
}

 for (int i = 0; i < 52; i++) delete deck[i];
   delete[] deck;