262
Me, after carefully reading Rust's ownership and borrow checker rules (lemmy.world)
submitted 9 months ago by to c/programmer_humor@programming.dev
17 comments fedilink hide all child comments
 
you are viewing a single comment's thread
view the rest of the comments
[–] 34 points 9 months ago (6 children)

That's how the C++ code should have looked all the time. And the amount of people that get surprised and complain about this is just more evidence that nobody should write C++. Ever.

  • permalink
  • fedilink
  • source
  • hideshow 6 child comments
    •
  • [–] 13 points 9 months ago (5 children)

    Exactly, C++ is what came to my mind when I saw this. Some people don't put references??

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 5 child comments
    •
  • [–] 13 points 9 months ago (4 children)

    I guess, if you come from garbage-collected languages, you might be used to not needing the ampersands, because everything is automatically a reference in those...

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 4 child comments
    •
  • [–] 6 points 9 months ago (3 children)

    Yeah this is how it was for me when I first started C++, I was use to any object beyond a simple 3D vector to always be passed by reference

    And then I read a C++ book my uncle gave me during a flight and realized that there isn't any syntax for passing a parameter by copy, so obviously that'd have to be the default behavior and I've been passing by reference ever since

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 3 child comments
    •
  • [–] 6 points 9 months ago (2 children)

    Oh wow, what the hell. I'm not actually familiar with C++ (just with Rust which gets similar reactions with the ampersands), but that's insane that it just copies shit by default. I guess, it comes from a time when people mostly passed primitive data types around the place. But yeah, you won't even notice that you're copying everything, if it just does it automatically.

    And by the way, Rust did come up with a third meaning for passing non-references: It transfers the ownership of the object, meaning no copy is made and instead, the object is not anymore allowed to be used in the scope that passed it on.
    That's true, except for data types which implement the Copy trait/interface, which is implemented mostly for primitive data types, which do then get treated like C++ apparently treats everything.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •