Утечка памяти

#pragma once
namespace sdds
{
    struct Fruit
    {
        char m_name[31]; // the name of the fruit
        double m_qty;        // quantity in kilograms
    };
 
    class Basket {
        static int num; // 
        Fruit *m_fruit;
        int m_cnt;
        double m_price;
 
    public:
        Basket();
        Basket(Fruit*, int, double);
        void setPrice(double price);
        void safeEmptyStateBasket();
        Basket(const Basket &);
        Basket& operator=(const Basket&);
        ~Basket();
        Basket& operator+=(const Fruit);
        friend std::ostream & operator<<(std::ostream& os, const Basket& b);
        operator bool() const;
    };
 
}

#include <iostream>
#include "Basket.h"
using namespace std;
 
namespace sdds {
    int Basket::num = 0;
 
    void Basket::safeEmptyStateBasket() {
        m_fruit = nullptr;
        m_cnt = 0;
        m_price = 0.0;
    }
 
    Basket::Basket() {
        num++;
        cout << "<<<<Created new object>>>> " << num << endl;
        safeEmptyStateBasket();
 
    }
 
    Basket::Basket(Fruit* fruit, int cnt, double price)
    {
        num++;
        cout << "<<<<Created new object>>>> " << num << endl;
        if (fruit != nullptr && cnt > 0)
        {
            m_fruit = new Fruit[cnt];
            for (int i = 0; i < cnt; i++)
                m_fruit[i] = fruit[i];
            m_cnt = cnt;
            m_price = price;
        }
 
        else
            safeEmptyStateBasket();
    }
 
    void Basket::setPrice(double price) {
        m_price = price;
    }
 
    Basket::Basket(const Basket &st)
    {
        num++;
        cout << "<<<<Created new object>>>> " << num << endl;
        if (st.m_fruit != nullptr && st.m_cnt > 0)
        {
            //delete[] m_fruit;
            m_cnt = st.m_cnt;
            m_fruit = new Fruit[m_cnt];
            for (int i = 0; i < m_cnt; i++)
                m_fruit[i] = st.m_fruit[i];
            m_price = st.m_price;
        }
 
        else
            safeEmptyStateBasket();
    }
 
    Basket& Basket::operator=(const Basket& st) {
        
        if (st.m_fruit != nullptr && st.m_cnt > 0)
        {
            delete[] m_fruit;
            m_cnt = st.m_cnt;
            m_fruit = new Fruit[m_cnt];
            for (int i = 0; i < m_cnt; i++)
                m_fruit[i] = st.m_fruit[i];
            m_price = st.m_price;
        }
 
        else
            safeEmptyStateBasket();
 
        return *this;
    }
 
    Basket::~Basket() {
        cout << "<<<<Delete object>>>> " << num << endl;
        num--;
        delete[]m_fruit;
    }
 
    Basket& Basket::operator+=(const Fruit st) {
 
        Fruit* temp = new Fruit[m_cnt + 1];
        for (int i = 0; i < m_cnt; i++)
            temp[i] = m_fruit[i];
        temp[m_cnt] = st;
        m_cnt++;
 
        Fruit* tmp = m_fruit;
        m_fruit = temp;
        temp = tmp;
 
        delete[] temp;
        return *this;
    }
 
    std::ostream & operator<<(std::ostream& os, const Basket& b)
    {
        if (b.m_fruit == nullptr)
            os << "The basket is empty!\n";
        else
        {
            os << "Basket Content:\n";
            os.setf(ios::fixed);
            os.precision(2);
            os << fixed;
            for (int i = 0; i < b.m_cnt; i++)
                os << "\t" << b.m_fruit[i].m_name << ": "<< b.m_fruit[i].m_qty << "kg\n";
            os << "Price: " << b.m_price << endl;
        }
        return os;
    }
 
    Basket::operator bool() const
    {
        if (m_cnt > 0)
            return true;
        return false;
    }
}

#define __CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#define DEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)
#define new DEBUG_NEW
 
#include<iostream>
#include<cstring>
#include"Basket.h"
#include"Basket.h" //intentional
 
using namespace std;
using namespace sdds;
 
void printHeader(const char* title)
{
    char oldFill = cout.fill('-');
    cout.width(40);
    cout << "" << endl;
 
    cout << "|> " << title << endl;
 
    cout.fill('-');
    cout.width(40);
    cout << "" << endl;
    cout.fill(oldFill);
}
 
int main()
{
    sdds::Fruit fruits[]{
        { "apple",  0.65 },
        { "banana", 1.25 },
        { "pear",   0.50 },
        { "mango",  0.75 },
        { "plum",   2.00 },
    };
 
    {
        printHeader("T1: Default Constructor");
 
        Basket aBasket;
        cout << aBasket;
 
        // conversion to bool operator
        if (aBasket)
            cout << "Test failed: the basket should be empty!\n";
        else
            cout << "Test succeeded: operator said the basket is empty!\n";
 
        cout << endl;
    }
 
    {
        printHeader("T2: Custom Constructor");
 
        Basket aBasket(fruits, 2, 6.99);
        cout << aBasket;
 
        // conversion to bool operator
        if (aBasket)
            cout << "Test succeeded: operator said the basket has content!\n";
        else
            cout << "Test failed: the basket should NOT be empty!\n";
 
        cout << endl;
    }
 
    {
        printHeader("T3: += operator");
 
        Basket aBasket;
        aBasket += fruits[2];
        (aBasket += fruits[0]) += fruits[4];
        aBasket.setPrice(12.234);
 
        cout << aBasket;
        cout << endl;
    }
 
    {
        printHeader("T4: Copy Constructor");
 
        Basket b1;
        Basket b2(b1);
 
        cout << "Basket #1 -> " << b1;
        cout << "Basket #2 -> " << b2;
 
        b1 += fruits[3];
        b1.setPrice(3.50);
 
        Basket b3(b1);
        cout << "Basket #3 -> " << b3;
        cout << endl;
    }
 
    {
        printHeader("T5: Copy Assignment");
 
        Basket b1, b2, b3(fruits, 5, 19.95);
 
        b1 = b2;
        cout << "Basket #1 -> " << b1;
        cout << "Basket #2 -> " << b2;
 
        b1 = b3;
        cout << "Basket #1 -> " << b1;
 
        b3 = b2;
        cout << "Basket #3 -> " << b3; 
    }
 
    system("pause");
    _CrtDumpMemoryLeaks();
    return 0;
}

b3 = b2;

Basket& Basket::operator=(const Basket& st) {
        
        if (st.m_fruit != nullptr && st.m_cnt > 0)
        {
            if (this == &st)
                return *this;
            delete[] m_fruit;
            m_cnt = st.m_cnt;
            m_fruit = new Fruit[m_cnt];
            for (int i = 0; i < m_cnt; i++)
                m_fruit[i] = st.m_fruit[i];
            m_price = st.m_price;
        }
 
        else
        {
            delete[] m_fruit;
            safeEmptyStateBasket();
        }
 
        return *this;
    }

Basket& Basket::operator=(const Basket& st) 
{
    if (this != &st)
        Basket(st).swap(*this);
    return *this;
}

    delete[] m_fruit ;
        m_fruit = temp;
        return *this;