[PaulDavisThe1st]

You opted to use features of std::vector that are documented to be unsafe (notably ::data()). This is the actual C++ translation of the opening code in TFA:

  #include <vector> 
  #include <iostream>

  int main() {
      std::vector<int> vec = {1, 2, 3};
      
      for (auto const & i : vec) {
          std::cout << i << std::endl;
      }
  }

It is possible to use C++ to write unsafe code! Amazing! Some people want a language where this is not possible! Great!

[steveklabnik]

> This is the actual C++ translation of the opening code in TFA:

No, it isn't: this is iterating over references, not moving. This is equivalent to

  fn main() {
      let x = vec![1, 2];

      for y in &x {
          println!("{}", y);
      }
      println!("{}", x.len());
  }

in Rust. Note the &, just like in your C++.

[PaulDavisThe1st]

The purpose of the first code example in TFA:

> This is straightforward: we create a vector containing the values [1, 2], then iterate over it and print each element, and then finally print out the length of the vector. This is the kind of code people write every day.

The C++ code I provided does essentially this (I omitted printing the length, since it is so trivial), and is "the kind of code people write every day".

The fact that Rust requires you to consider move semantics for such simple code is precisely one of the central points of the article.

[steveklabnik]

"C++ code that implements the problem, but in a different way" is not "the actual C++ translation of the opening code in TFA."

[PaulDavisThe1st]

The C++ code implements the intended goal, not the problem TFA is trying to illustrate.

Changing between:

    for (auto i : vec)

and

    for (auto & i : vec)

has essentially no bearing on what the author is trying to show. If they were focused on how move semantics are always important, they would not use an integer type.