std::vector<std::string> v;
    v.push_back("Hello");
    for (auto&& s: v) {
        v.clear();
        std::cout << s; // use after free in modern C++
    }

There is no reasonable way for a compiler to precisely check for use after free in C++ short of changing the language, and this can be easily proven.

Technically, that's a iterator invalidation and those are indeed hard to keep track of. There are runtime libraries that keep track of pointer-invalidation for you however.

In any case, a std::vector<shared_ptr<std::string> > would actually avoid the issue in this particular case.

Use after free... is more about use of raw pointers IMO. I wouldn't describe that code to be a "use after free" at all. In most languages, you are simply not allowed to change the container at all. Iterator invalidation is a hard issue in any language.

Iterator invalidation does not result in remote code execution in other languages. Regardless of what you call it (and you are in the minority by not considering that code UAF) the result is the same when combined with vtables and attacker-influenced heaps: arbitrary code execution.

shared_ptr is also not memory safe when combined with references, which you need to use to call methods on the shared_ptr'd object or to pass those objects to most functions.

Tecnically that's reference invalidation and no pure library is going to help you. You need compiler/runtime help (i.e. static analysis or some sort of sanitizer).