为什么C++的SEH不提供finally

因为C++支持一种更棒的方法："resource acquisition is initialization"技术。基本思想是使用局部对象代理资源，局部变量在析构时将会自动释放资源。用这种方式，这样程序开发人员将不会遗忘资源的释放

// wrap a raw C file handle and put the resource acquisition and release
// in the C++ type's constructor and destructor, respectively
class File_handle {
FILE* p;
public:
File_handle(const char* n, const char* a)
{ p = fopen(n,a); if (p==0) throw Open_error(errno); }
File_handle(FILE* pp)
{ p = pp; if (p==0) throw Open_error(errno); }
~File_handle() { fclose(p); }
operator FILE*() { return p; }   // if desired
// ...
};
// use File_handle: uses vastly outnumber the above code
void f(const char* fn)
{
File_handle f(fn,"rw"); // open fn for reading and writing
// use file through f
} // automatically destroy f here, calls fclose automatically with no extra effort
// (even if there's an exception, so this is exception-safe by construction)

在一个系统中，最糟糕的方式是我们需要为每一个资源设计一个"resource handle"类。然而，我们不是必须用一个"finally"来处理资源。在一个现实的系统中，资源的处理代码远远超过了各种资源的数量，因此，使用“resource
acquisition is initialization”技术来处理比使用"finally"结构更加简练。

Because C++ supports an alternative that is almost always better: The “resource acquisition is initialization” technique. The basic idea is to represent a resource by a local object, so
that the local object’s destructor will release the resource. That way, the programmer cannot forget to release the resource. For example:

// wrap a raw C file handle and put the resource acquisition and release

// in the C++ type's constructor and destructor, respectively

class File_handle {

FILE* p;

public:

File_handle(const char* n, const char* a)

{ p = fopen(n,a); if (p==0) throw Open_error(errno); }

File_handle(FILE* pp)

{ p = pp; if (p==0) throw Open_error(errno); }

~File_handle() { fclose(p); }

operator FILE*() { return p; }   // if desired

// ...

};

// use File_handle: uses vastly outnumber the above code

void f(const char* fn)

{

File_handle f(fn,"rw"); // open fn for reading and writing

// use file through f

} // automatically destroy f here, calls fclose automatically with no extra effort

// (even if there's an exception, so this is exception-safe by construction)

In a system, in the worst case we need a “resource handle” class for each resource. However, we don’t have to have a “finally” clause for each acquisition of a resource. In realistic systems,
there are far more resource acquisitions than kinds of resources, so the “resource acquisition is initialization” technique leads to less code than use of a “finally” construct.

Also, have a look at the examples of resource management in Appendix
E of TC++PL3e.
https://isocpp.org/wiki/faq/exceptions#finally