If you redefine C++ so that it looks like Java / C# (i.e. runs on a virtual machine, with a JIT and probably some requirements for memory safety), then yes, you can do these things with C++.
But the people who advocate C++ wouldn't recognize that language as a C++, because all the overhead of a JIT runtime violates the "only pay for what you need" dictum.
(E.g. consider the uptake of Managed C++, C++/CLI, etc.; which effectively are what you describe.)
I think you may be confused.
You don't have to redefine anything at a language level to make this work. It will just work.
The features Java redefined were mainly for security reasons, and pointer safety, not because it made it possible to run with a JIT
As a proof, you can JIT C/C++ with LLVM right now if you wanted to.
It's not a great JIT because it has no adaptive compilation heuristics, etc, but it works just fine.
C/C++ very specifically leave most of the execution environment undefined. They do not require anything that makes JIT'ing require language level changes. Your JIT may be unsafe (IE crash as easily as a regular C/C++ program), or otherwise require basically native access (IE not really viable for sandboxing in a browser), but it would work fine
Things like Managed C++/etc required language changes because they wanted it to interoperate with a common intermediate language and runtime.
There are things that you can do in C++ that you can't do in CLR (again, because the CLR chose safety/etc over other considerations), and vice versa (IE garbage collection at a language level), so managed C++ required language changes to support this.
I'm not confused (thank you very much for your diagnosis though - that's a grand way to gratuitously insult people). I didn't say redefining things at the language level; I meant redefining at the programming environment level.
You can compile standard C++ with C++/CLI just fine, and have it run on a fine managed platform. "IJW" was the slogan: It Just Works. Still didn't go anywhere.
(The CLR did not choose safety over other considerations. It has a safe subset, but it is not like the JVM; it has unsafe operations too. When you write IL for it, you are not even required to use GC memory; you can manipulate things at the level of untyped blobs of data if needs be.)
But the people who advocate C++ wouldn't recognize that language as a C++, because all the overhead of a JIT runtime violates the "only pay for what you need" dictum.
(E.g. consider the uptake of Managed C++, C++/CLI, etc.; which effectively are what you describe.)