0

我有两个类，它们本质上是看起来像这样的字符串类。第一个类包含一个字符串作为成员，第二个类还包含一个字符串以及一个用于“MenuItem”类的指针数组以及一个跟踪器。

const int MAX_NO_OF_ITEMS = 10;

    class Menu; // forward declaration

    class MenuItem {
        char* Menuitem;
        //member functions
        MenuItem(); 
        ...
        ~MenuItem();
        friend Menu; 
    };

    class Menu {
    private:
        char* m_Title;
        MenuItem* m_MenuItems[MAX_NO_OF_ITEMS];
        int m_menuTracker;
     ... //other functions not shown
    }

我希望能够将一个 Menu 对象深度复制到另一个 Menu 对象，但我这样做的方式似乎确实是在复制“m_MenuItems”时它是一个浅拷贝。我确定“m_Title”成员正在被深度复制，因为我正在为它创建一个“新”字符*，但是当我尝试将源“m_MenuItems”复制到目标时出现问题，因为它们最终共享相同的记忆。这会导致问题，因为当调用解构函数时，它会在同一个对象上调用两次，导致我的程序崩溃。

这是我的副本和分配代码：

    Menu& Menu::operator=(const Menu& src) {

        if (this != &src && src.m_Title != nullptr) {
            delete[] m_Title;
            m_Title = nullptr;
           
            m_Title = new char[strlen(src.m_Title) + 1];
            strcpy(m_Title, src.m_Title);
            
            //if current object has menuItems, then delete to make room for src. 
            for (int i = 0; i < m_menuTracker; i++) {
                delete m_MenuItems[i];
                this->m_MenuItems[i] = nullptr;
            }

下面这个for循环是我的问题出现的地方......

            if (src.m_MenuItems[0] != nullptr) {
                for (int i = 0; i < src.m_menuTracker; i++) {
                    m_MenuItems[i] = src.m_MenuItems[i];
                }
        
                this->m_menuTracker = src.m_menuTracker;
            }
            else
                this->m_menuTracker = 0;
        }
        else {
            this->setEmpty();
        }
        
        return *this;
    }

我应该如何为目标“m_MenuItems”分配一个新的内存块？

4

0 回答 0