1. Take one of those most popular basic types provided by the C++ stdlib, std::vector<T> a growable array type and compare the analogous Rust type Vec<T>
std::vector<T> has a reserve method, but it's actually not equivalent to Vec::reserve instead it's equivalent to Vec::reserve_exact and there is no analogue for Vec::reserve provided, as a result without re-implementing the amortized exponential growth trick yourself you can't achieve similar performance benefits. The reserve vs reserve_exact distinction allows programmers who know something to help the type perform well.
2. The Guaranteed Niche Optimization. If Rust's compiler can see why type T doesn't need all possible bit patterns for its memory layout, then Rust guarantees that sum types consisting of a single value plus type T are optimised to the same size as T. C++ can approximate this using specialization for library types such as std::optional (but it typically doesn't) however it cannot provide the guarantee and in practice doesn't deliver the resulting performance.
Rust's &T has such a niche (the "null" pointer value), so do (Unix) OwnedFd and (Windows) OwnedSocket and the non-zero integers like NonZeroU32. Thus all of these types have the guaranteed optimisation when used in your own types and such sum types can be used exactly like "sentinel" values in C except that they're type safe so you'll write fewer bugs.
There are a lot of these leaks in the C++ language and standard library, and they add up. If you want to counteract them your C++ development gets slower and more expensive which wasn't a problem when there was no alternative, but now there is.