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

如果问题有点模糊，让我们使用示例类

Paper

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

Paper** myFolder;

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

后来，在某个地方，它被n个指针填满：

Paper** myFolder;

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

当我们处理完

myFolder

后，我们需要在删除

纸张**

之前删除每张

纸张

：

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

甚至

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

---

其他信息：

myFolder

不是数组数组。它是一个指针数组。为什么？因为目标是利用多态性

Paper

可能是子类，因此

myFolder

是指针数组而不是对象数组

另外：当然，

std:：vector

是比使用原始指针更好的方法。这个问题是理论上的，只考虑新的C++语法。我不是在寻找关于如何重做此代码的建议。

您可以使用一些指针算法

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

但是，在使用现代C++的精神中，我根本不鼓励使用手动内存操作，并且用< /P>使用某些东西。 std:：vector 您可以使用一些指针算法

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

但是，在使用现代C++的精神中，我根本不鼓励使用手动内存操作，并且用< /P>使用某些东西。 std:：vector

---

应该避免使用原始指针

下面是一个使用

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

解决问题的示例

#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<Paper*> myFolder;

---

由于需要多态性，所以需要保留指向对象的指针。 您当前使用指向动态分配数组的指针

纸张**我的文件夹

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

std::vector<Paper*> myFolder;

---

for（Paper*p:myFolder）不正确，因为循环范围要求集合提供begin（）和end（）迭代器，而原始指针没有。for（Paper*p:myFolder）不正确，因为循环范围要求集合提供begin（）和end（）迭代器，而原始指针没有。我不得不说，与前面介绍的OP的正常循环相比，

std:：foreach

代码看起来更不可读，或者我应该说“更丑”。由于OP需要多态性，他需要std:：vector，甚至std:：vectorI必须说，

std:：foreach

代码看起来更不可读，或者我应该说“更丑”，由于OP需要多态性，他将需要std:：vector，甚至std:：vector这正是我要找的+简而言之，这正是我想要的+1为简洁起见。