Question

如果问题有点模糊，请使用示例类Paper。

假设我有一个动态分配的指针数组：

Paper** myFolder;

以后，在某个地方，它充满了 n 指针：

myFolder = new Paper* [n];
//trimmed - make each pointer in myFolder point to something

当我们完成myFolder后，我们需要在删除Paper之前删除每个Paper**：

for(int i = 0; i < n; i++)
    delete myfolder[i];

我的问题：该代码并非非常“非常好”。现在，C ++ 11及更高版本适用于每个循环。如何删除动态分配的指针数组与＆＃34; for-each＆＃34;句法？以下显然在语法上是不正确的：

for(Paper* p: myFolder)
    delete p;

甚至

for each (Paper* p in myFolder)
    delete p;

其他信息： myFolder不是数组数组。它是一个指针数组。为什么？因为目标是利用多态性。 Paper可能是子类，因此myFolder是一个指针数组而不是一个对象数组。

另外：当然std::vector比使用原始指针更好。 这个问题是理论上的，只涉及新的C ++语法。我没有寻求有关如何重做此代码的建议。

Answer 1

您可以将std::for_each与一些指针算法一起使用。

std::for_each(myFolder, myFolder + n, [](Paper* p){ delete[] p; })

然而，在使用现代C ++的精神下，我会劝阻使用手动内存操作并使用RAII

的内容

std::vector<std::vector<Paper>>

Answer 2

如果你想要多态，你需要保持指向你的对象的指针。您当前使用指向动态分配的数组的指针

纸张** myFolder;

无需手动控制阵列的分配，可以轻松使用

std::vector<Paper*> myFolder;

破坏文件夹的时候，非常漂亮：

for(auto paper : myFolder) 
    delete paper;

Answer 3

应该避免使用原始指针。

以下是使用std::vector解决问题的示例。

#include <vector>

class Paper {
};

class Folder {
    // A folder contains a vector of papers.
    std::vector<Paper> m_papers;

public:
    // Method to add a paper to the folder. Use Move semantics for performance.
    void AddPaper(Paper && aPaper) {
        m_papers.push_back(std::move(aPaper));
    }

    // A read-only getter.
    const std::vector<Paper> & Papers() const { return m_papers; }
};

int main()
{
    std::vector<Folder> folders;  // All your folders.
    Folder aFolder;   // Create a folder.
    aFolder.AddPaper(Paper());  // Add paper to the folder.
    folders.push_back(aFolder);  // Add a folder.

    for (const auto & f : folders) {
        for (const auto & p : f.Papers()) {
            // Read each paper here.
        }
    }
}

使用std::vector时，可以使用ranged for循环访问每个元素：

for (const auto & f : folders)

如何使用for-each循环来美化析构函数？

3 个答案: