std::locale所有权问题：栈分配time_facet为何触发析构错误？

Great question! The root of the difference lies in how std::locale handles ownership of the facets you pass to it. Let's break this down step by step:

Core Rule: std::locale Takes Ownership of Facet Pointers #

When you create a new std::locale using the constructor signature:

std::locale(const std::locale& base, Facet* facet);

the resulting locale object takes full ownership of the facet pointer you provide. That means when the locale is destroyed (which happens when your std::stringstream is destroyed, since it holds the locale internally), it will automatically call delete on that facet pointer to clean it up.

Why the First Snippet Crashes #

Let's look at your first code:

boost::posix_time::time_facet facet("%Y-%m-%dT%H:%M:%f");
std::stringstream ss;
ss.imbue(std::locale(ss.getloc(), &facet));

Here, facet is a stack-allocated local variable. You pass its address to the std::locale constructor, which takes ownership of that pointer. When ss is destroyed, the internal locale tries to run delete &facet—but you can't use delete on a stack-allocated object! This triggers undefined behavior (usually a crash or memory corruption) because you're trying to free memory that wasn't allocated with new.

Why the Second Snippet Works #

Your second code fixes this by following the ownership rule correctly:

std::stringstream ss;
ss.imbue(std::locale(ss.getloc(), new boost::posix_time::time_facet("%Y-%m-%dT%H:%M:%f")));

Here, you allocate the time_facet on the heap using new. The std::locale takes ownership of this heap-allocated pointer, and when the locale is destroyed, it safely calls delete on the pointer—exactly the right way to clean up heap-allocated memory. This matches the expected behavior, so the code runs without issues.

What the Standard Says #

The C++ standard explicitly states that when you add a facet to a locale via this constructor, the locale assumes ownership of the facet. The facet must be dynamically allocated (with new), because the locale will use delete to destroy it. Stack-allocated or static facets are invalid here, as they violate the ownership contract.

A Quick Note on Alternatives #

If you ever want to use a facet without giving ownership to the locale, you'd need to use a different approach (like making the facet a static object and ensuring it outlives the locale), but this is rarely recommended. The standard pattern for custom facets with std::locale is to allocate them with new and let the locale handle destruction.

内容的提问来源于stack exchange，提问作者voltento