{"id":112738,"date":"2026-09-28T07:00:00","date_gmt":"2026-09-28T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=112738"},"modified":"2026-09-28T20:11:26","modified_gmt":"2026-09-29T03:11:26","slug":"20260928-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20260928-00\/?p=112738\/","title":{"rendered":"C++ reminder: Function-local static variables are initialized only once, even if it looks like they get initialized multiple times"},"content":{"rendered":"

When you write a static variable inside a function, it is initialized only once, specifically at the first time that execution reaches the variable’s declaration<\/a>, If execution reaches the variable again in the future, no initialization occurs. It just retains its old value.<\/p>\n

Some time ago, I noted an attempt to fix a lifetime issue by making a variable static.<\/p>\n

The original code used this header from an external widget library:<\/p>\n

\/\/ widget.h\r\nstruct WidgetController\r\n{\r\n    virtual WidgetKind GetKind() = 0;\r\n    virtual WidgetFlags GetFlags() = 0;\r\n    virtual void OnOpening() = 0;\r\n    \u27e6 and so on \u27e7\r\n};\r\n\r\nstd::shared_ptr<Widget>\r\n    MakeWidget(std::shared_ptr<WidgetController> const& controller);\r\n<\/pre>\n
The idea is that you give it a Widget\u00adController<\/code> object that the widget consults at various times, allowing you to customize the widget behavior.<\/p>\n
The application code called it like this:<\/p>\n
\/\/ The basic Widget controller provides information but\r\n\/\/ does not override any default behaviors.\r\n\r\nstruct BasicWidgetInfo\r\n{\r\n    WidgetKind kind;\r\n    WidgetFlags flags;\r\n    \u27e6 and so on \u27e7\r\n};\r\n\r\nstruct BasicWidgetController : WidgetController\r\n{\r\n    BasicWidgetController(BasicWidgetInfo const& info) :\r\n        m_info(info) {}\r\n\r\n    WidgetKind GetKind() override { return m_info.kind; }\r\n    WidgetFlags GetFlags() override { return m_info.flags; }\r\n\r\n    \/\/ Do not customize any dynamic actions.\r\n    void OnOpening() override { }\r\n    \u27e6 and so on \u27e7\r\n\r\nprivate:\r\n    BasicWidgetInfo const& m_info;\r\n}\r\n\r\nstruct Gadget\r\n{\r\n    std::shared_ptr<Widget> m_widget;\r\n\r\n    void CreateWidget(GadgetFlags flags)\r\n    {\r\n        BasicWidgetInfo info = {\r\n            WidgetKind::Vanilla,\r\n            WidgetFlags::Openable |\r\n            (flags & GadgetFlags::ClosableWidget ?\r\n                WidgetFlags::Closable : WidgetFlags::None)\r\n        };\r\n\r\n        auto controller = std::make_shared<BasicWidgetController>(info);\r\n\r\n        m_widget = MakeWidget(controller);\r\n    }\r\n\r\n    \u27e6 other gadget stuff \u27e7\r\n};\r\n<\/pre>\n
The catch is that the Widget\u00adOptions<\/code> constructor takes a reference to a Gadget\u00adOptions<\/code> and saves the reference. Later, when the widget asks the controller for the flags, the controller will look up the answer in the BasicWidgetInfo<\/code> structure, but that BasicWidgetInfo<\/code> had already destructed when Create\u00adCustom\u00adWidget<\/code> returned, so it returns garbage (or possibly even crashes).<\/p>\n
This is a use-after-free bug.<\/p>\n
To solve this problem, they made the info<\/code> static. Static objects continue to exist even after the function returns.<\/p>\n
    void CreateWidget(GadgetFlags flags)\r\n    {\r\n        static<\/span> BasicWidgetInfo info = {\r\n            WidgetKind::Vanilla,\r\n            WidgetFlags::Openable |\r\n            (flags & GadgetFlags::ClosableWidget ?\r\n                WidgetFlags::Closable : WidgetFlags::None)\r\n        };\r\n\r\n        auto controller = std::make_shared<BasicWidgetController>(info);\r\n\r\n        m_widget = MakeWidget(controller);\r\n    }\r\n<\/pre>\n
Now the program doesn’t crash. Yay!<\/p>\n
However, there is a catch: If two Gadgets both try to create a widget, all of them will have the same options as the first one, because function-local static variables are shared among all instances of a class and are initialized only the first time execution reaches the variable. Whatever flags were passed when you called it the first time get locked into the info<\/code>, and it doesn’t matter what flags you pass subsequent times because info<\/code> has already been initialized; it’s not going to initialize again.<\/p>\n
If you want it to initialize each time, then you have to modify it each time.<\/p>\n
    void CreateWidget(GadgetFlags flags)\r\n    {\r\n        static BasicWidgetInfo info;<\/span>\r\n        info = {                    <\/span>\r\n            WidgetKind::Vanilla,\r\n            WidgetFlags::Openable |\r\n            (flags & GadgetFlags::ClosableWidget ?\r\n                WidgetFlags::Closable : WidgetFlags::None)\r\n        };\r\n\r\n        auto controller = std::make_shared<BasicWidgetController>(info);\r\n\r\n        m_widget = MakeWidget(controller);\r\n    }\r\n<\/pre>\n
This time, we set the values as a step separate from construction, which means that it executes each time, and the info<\/code> gets updated with the most recent flags.<\/p>\n
Of course, this is still a problem if two Gadgets create Widgets with overlapping lifetime, because the two Basic\u00adWidget\u00adController<\/code>s are sharing the same info<\/code>. At the second call to Create\u00adWidget<\/code>, its updates to info<\/code> secretly alter the values being used by the first one.<\/p>\n
Plus, of course, if Create\u00adWidget<\/code> is called by two threads simultaneously, you have a data race on the writes to the info<\/code> variable, and then the results will be unpredictable.<\/p>\n
The underlying problem is that the Basic\u00adWidget\u00adController<\/code> wants to extend the lifetime of its info<\/code>, but a reference gives you no way to do it, so it has to rely on the kindness of strangers.<\/p>\n
One idea would be to put the info<\/code> somewhere else, so that its lifetime can be extended some other way. Maybe you put it in the Gadget<\/code>:<\/p>\n
struct Gadget\r\n{\r\n    std::shared_ptr<Widget> m_widget;\r\n    BasicWidgetInfo m_info;<\/span>\r\n\r\n    void CreateWidget(GadgetFlags flags)\r\n    {\r\n        m_info = {<\/span>\r\n            WidgetKind::Vanilla,\r\n            WidgetFlags::Openable |\r\n            (flags & GadgetFlags::ClosableWidget ?\r\n                WidgetFlags::Closable : WidgetFlags::None)\r\n        };\r\n\r\n        auto controller = std::make_shared<BasicWidgetController>(m_info<\/span>);\r\n\r\n        m_widget = MakeWidget(controller);\r\n    }\r\n\r\n    \u27e6 other gadget stuff \u27e7\r\n};\r\n<\/pre>\n
Now your job is to make sure that the m_info<\/code> is not destructed before the last shared pointer to the Basic\u00adWidget\u00adController<\/code>. This is tricky, since you don’t really know when the last shared pointer to the Basic\u00adWidget\u00adController<\/code> will be destructed, although you might have some heuristics given that its lifetime is probably tied to the Widget<\/code>.<\/p>\n
Is there a way to hook into the destruction of the final shared_ptr<\/code>?<\/p>\n
Yes, and in fact we already used that feature without realizing it.<\/p>\n
You can use an aliasing shared pointer that points at a Basic\u00adWidget\u00adController<\/code> but whose lifetime controls both a Basic\u00adWidget\u00adController<\/code> and its associated Basic\u00adWidget\u00adInfo<\/code>.<\/p>\n
struct BasicWidgetControllerWithInfo\r\n{\r\n    BasicWidgetControllerWithInfo(BasicWidgetInfo const& info) :\r\n        m_info(info),\r\n        m_controller(m_info) {}\r\n\r\n    \/\/ The m_info must come before the m_controller because the\r\n    \/\/ m_controller initializer depends on the m_info.\r\n    BasicWidgetInfo m_info;\r\n    BasicWidgetController m_controller;\r\n};\r\n\r\n    void CreateWidget(GadgetFlags flags)\r\n    {\r\n        BasicWidgetInfo info = {\r\n            WidgetKind::Vanilla,\r\n            WidgetFlags::Openable |\r\n            (flags & GadgetFlags::ClosableWidget ?\r\n                WidgetFlags::Closable : WidgetFlags::None)\r\n        };\r\n\r\n        auto controllerAndInfo = std::make_shared<BasicWidgetControllerWithInfo(info);\r\n\r\n        auto controller = std::shared_ptr<BasicWidgetController>(<\/span>\r\n            controllerAndInfo, &controllerAndInfo->m_controller);<\/span>\r\n\r\n        m_widget = MakeWidget(controller);\r\n    }\r\n\r\n    \u27e6 other gadget stuff \u27e7\r\n};\r\n<\/pre>\n
We use an aliasing constructor with a pointer to the controller, but telling it to control the lifetime of the Basic\u00adWidget\u00adController\u00adWith\u00adInfo<\/code>.<\/p>\n
Of course, all of this is a problem of the application’s own creation. They should just fix the Basic\u00adWidget\u00adController<\/code> to copy<\/i> the Basic\u00adWidget\u00adInfo<\/code> instead of taking a reference.<\/p>\n
struct BasicWidgetController : WidgetController\r\n{\r\n    BasicWidgetController(BasicWidgetInfo const& info) :\r\n        m_info(info) {}\r\n\r\n    WidgetKind GetKind() override { return m_info.kind; }\r\n    WidgetFlags GetFlags() override { return m_info.flags; }\r\n\r\n    \/\/ Do not customize any dynamic actions.\r\n    void OnOpening() override { }\r\n    \u27e6 and so on \u27e7\r\n\r\nprivate:\r\n    BasicWidgetInfo \/* const&<\/span> *\/<\/span> m_info;\r\n}\r\n<\/pre>\n
Now the original code works again.<\/p>\n
    void CreateWidget(GadgetFlags flags)\r\n    {\r\n        BasicWidgetInfo info = {\r\n            WidgetKind::Vanilla,\r\n            WidgetFlags::Openable |\r\n            (flags & GadgetFlags::ClosableWidget ?\r\n                WidgetFlags::Closable : WidgetFlags::None)\r\n        };\r\n\r\n        auto controller = std::make_shared<BasicWidgetController>(info);\r\n\r\n        m_widget = MakeWidget(controller);\r\n    }\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
Only on first execution.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-112738","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Only on first execution.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/112738","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=112738"}],"version-history":[{"count":1,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/112738\/revisions"}],"predecessor-version":[{"id":112739,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/112738\/revisions\/112739"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=112738"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=112738"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=112738"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}