正如许多人所说，解决方案是使用c++ 11的特性来避免最终阻塞。其中一个特性是unique_ptr。

以下是Mephane使用RAII模式编写的答案。

#include <vector>
#include <memory>
#include <list>
using namespace std;

class Foo
{
 ...
};

void DoStuff(vector<string> input)
{
    list<unique_ptr<Foo> > myList;

    for (int i = 0; i < input.size(); ++i)
    {
      myList.push_back(unique_ptr<Foo>(new Foo(input[i])));
    }

    DoSomeStuff(myList);
}

这里有更多关于在c++标准库容器中使用unique_ptr的介绍

不，c++不支持'finally'块。原因是c++支持RAII:“资源获取是初始化”——对于一个真正有用的概念来说，这是一个糟糕的名字。

其思想是，对象的析构函数负责释放资源。当对象具有自动存储持续时间时，当创建对象的块退出时，对象的析构函数将被调用——即使该块在出现异常时退出。以下是Bjarne Stroustrup对这个话题的解释。

RAII的一个常见用途是锁定互斥量:

// A class with implements RAII
class lock
{
    mutex &m_;

public:
    lock(mutex &m)
      : m_(m)
    {
        m.acquire();
    }
    ~lock()
    {
        m_.release();
    }
};

// A class which uses 'mutex' and 'lock' objects
class foo
{
    mutex mutex_; // mutex for locking 'foo' object
public:
    void bar()
    {
        lock scopeLock(mutex_); // lock object.

        foobar(); // an operation which may throw an exception

        // scopeLock will be destructed even if an exception
        // occurs, which will release the mutex and allow
        // other functions to lock the object and run.
    }
};

RAII also simplifies using objects as members of other classes. When the owning class' is destructed, the resource managed by the RAII class gets released because the destructor for the RAII-managed class gets called as a result. This means that when you use RAII for all members in a class that manage resources, you can get away with using a very simple, maybe even the default, destructor for the owner class since it doesn't need to manually manage its member resource lifetimes. (Thanks to Mike B for pointing this out.)

For those familliar with C# or VB.NET, you may recognize that RAII is similar to .NET deterministic destruction using IDisposable and 'using' statements. Indeed, the two methods are very similar. The main difference is that RAII will deterministically release any type of resource -- including memory. When implementing IDisposable in .NET (even the .NET language C++/CLI), resources will be deterministically released except for memory. In .NET, memory is not deterministically released; memory is only released during garbage collection cycles.

†有些人认为“破坏是资源放弃”是RAII习语更准确的名称。

总之，微软Visual c++确实支持try，它在MFC应用中一直被用作捕获严重异常的方法，否则会导致崩溃。例如;

int CMyApp::Run() 
{
    __try
    {
        int i = CWinApp::Run();
        m_Exitok = MAGIC_EXIT_NO;
        return i;
    }
    __finally
    {
        if (m_Exitok != MAGIC_EXIT_NO)
            FaultHandler();
    }
}

在过去，我用它来做一些事情，比如在退出之前保存打开文件的备份。不过，某些JIT调试设置会破坏这种机制。

编辑

如果你不中断/继续/返回等等，你可以添加一个捕获到任何未知的异常，并把always代码放在它后面。这也是当您不需要重新抛出异常的时候。

try{
   // something that might throw exception
} catch( ... ){
   // what to do with uknown exception
}

//final code to be called always,
//don't forget that it might throw some exception too
doSomeCleanUp(); 

那么问题是什么呢?

通常，在其他编程语言中，finally通常无论如何都运行(通常是指不管任何返回、中断、继续等等)，除了某种系统exit()——这在每种编程语言中有很大不同——例如，PHP和Java只是在那一刻退出，但Python无论如何都执行finally，然后退出。

但是我上面描述的代码并不是这样工作的 =>下面的代码只输出一些错误!：

#include <stdio.h>
#include <iostream>
#include <string>

std::string test() {
    try{
       // something that might throw exception
       throw "exceptiooon!";

       return "fine";
    } catch( ... ){
       return "something wrong!";
    }
    
    return "finally";
}

int main(void) {
    
    std::cout << test();
    
    
    return 0;
}

不一定，但你可以在一定程度上模仿他们，例如:

int * array = new int[10000000];
try {
  // Some code that can throw exceptions
  // ...
  throw std::exception();
  // ...
} catch (...) {
  // The finally-block (if an exception is thrown)
  delete[] array;
  // re-throw the exception.
  throw; 
}
// The finally-block (if no exception was thrown)
delete[] array;

注意，final -block本身可能在原始异常被重新抛出之前抛出一个异常，从而丢弃原始异常。这与Java final -block中的行为完全相同。同样，你不能在try&catch块中使用return。

I also think that RIIA is not a fully useful replacement for exception handling and having a finally. BTW, I also think RIIA is a bad name all around. I call these types of classes 'janitors' and use them a LOT. 95% of the time they are neither initializing nor acquiring resources, they are applying some change on a scoped basis, or taking something already set up and making sure it's destroyed. This being the official pattern name obsessed internet I get abused for even suggesting my name might be better.

我只是认为不合理的做法是，要求某些特殊列表的每一个复杂设置都必须编写一个类来包含它，以避免在清理过程中出现问题时需要捕获多个异常类型时的复杂性。这将导致大量的临时类，否则这些类是不必要的。

是的，对于专为管理特定资源而设计的类，或者专为处理一组类似资源而设计的泛型类，这是没问题的。但是，即使所有涉及的东西都有这样的包装器，清理的协调也可能不仅仅是简单的反序析构函数调用。

我认为c++有一个final。我的意思是，天哪，在过去的几十年里，它被粘上了这么多零碎的东西，似乎奇怪的是，人们突然对一些东西变得保守起来，比如最终，它可能非常有用，可能不像其他一些已经添加的东西那么复杂(尽管这只是我的猜测)。