[int_19h]

In Rust, the de facto standard advice for such cases seems to be, "just use indices into an array instead of references".

While this is sometimes done in C++ as well for various reasons, it's certainly not the default pattern there. If you have two things that need to point to each other, you just do that.

[empath75]

> While this is sometimes done in C++ as well for various reasons, it's certainly not the default pattern there. If you have two things that need to point to each other, you just do that.

And then you have to handle all the subtle memory bugs that you've introduced by doing that.

[int_19h]

I'm not arguing that there isn't a gain here, but GP's original assertion was that

> While programming in Rust, I've never thought to myself, "man, this would be so much easier to express in C++".

This is a concrete example of something that is much easier to express in C++. And, sure, you do pay the tax for that (although I will also dispute the notion that it is impossible to write C++ without memory bugs; it's just hard).

[LinXitoW]

I guess this is a semantics argument, but I assume they mean to express the same thing with same (or reasonably same) security guarantees. After all, the security and "bug freeness" is part of what they are expressing. If you attempt to create something reasonably similar to Rust, you do suddenly need a lot of complex checking code and maybe tests for things that were trivial in Rust (because the compiler does the tests for you).

[simonask]

Is it really easy to express if the straightforward way is buggy and error-prone?

People think C++ is expressive because they think they are allowed to do a lot of things that they aren't, in fact, allowed to do in C++.