5 ms·

I like writing C++ code, and I like using SAL annotations to try to improve safety. I try to remember to be const correct as best as I can. Is Rust something I

• _flux 3y ago
  I think you will appreciate that moving objects actually invalidates the original bindings and the compiler checks for this quite effectively. Though there is some learning curve..
  • shortrounddev 3y ago
    So the equivalent of std::move will also make sure to "null" the original object at the same time?
    • VWWHFSfQ 3y ago
      It's not just a matter of "null"ing the reference. The program just won't compile at all if you try to use that reference again
      • dataflow 3y ago
        Surely there's more to it than this? Otherwise you can just set up bugprone-use-after-move checks in C++ and call it a day.
        • dmkolobov 3y ago
          The difference is that your C++ checks are executed at runtime. Rust's borrow-checker rules ensure this occurs at compile-time, before you ever run any code.
          • dataflow 3y ago
            The check I mentioned is a compile time check. I'm not referring to ASAN.
        • masklinn 3y ago
          Well yes for starters this is not an optional check and it’s not on just “bug-prone” moves it’s on all for them. Then it also has a borrow checker so if you refer to the content of an other object the langage ensures the (non-owning) pointer does not outlive the pointee, at compile-time. Though this concept is lexical so it’s quite restrictive. And then it encodes some forms of thread-safety in the langage directly. It also removes things like nullable pointers.
        • duped 3y ago
          The "more to it" is that the use-after-move checks aren't bugprone in Rust, you cannot use a value after it has been moved in safe code (additionally, when you call a function, values are moved and not copied, and when you capture a value in a closure, it is either by unique mutable reference, immutable reference, or moved and therefore safe*). Essentially all the stuff that makes std::move questionable "just works" in Rust. It doesn't even exist, values are moved by default and clones must be explicit (equivalent of a copy constructor for non-trivially copyable types). The other giant advantage is that use-after-free doesn't exist in safe Rust, since you can't have a reference to a value outlive the value. * It is also a compile error for a closure that captures a value by reference to outlive the value.
          • dataflow 3y ago
            > the use-after-move checks aren't bugprone in Rust I can't tell if one if us is confused here or if this is just confusing wording, but the check I referred to is not bug-prone. The pattern of using something after it's been moved from is bug-prone (even though it'd work fine for things like integers, in either language), and it's checking for that bug-prone pattern, hence the name.
            • db48x 3y ago
              In Rust it’s not bug–prone. The compiler knows which types are moved and which are copied, and if you write code that uses something after it was moved you get a compile–time error.
    • _flux 3y ago
      In practical terms the original variable or field will be out of scope after the move (well not really, but that's how effective the checking is).
      • eska 3y ago
        It’s a heuristic. And it doesn’t catch when your move isn’t really a move. And writing move constructors is difficult busywork.
        • masklinn 3y ago
          Your comment is really confusing, none of that is true for Rust.
          • eska 3y ago
            Because it was about C++
• SturgeonsLaw 3y ago
  Try it and see :) I didn't find the syntax very ergonomic but then I'm the kinda guy that likes Python because it's so loose
• bfrog 3y ago
  Maybe! If you hate writing cmake/make/vcpkg/conan bs, and want to be able to git clone and build (almost) any project, without installing anything beyond rust+cargo... rust will be nice to use. If you hate the idea of class hierarchies to try and describe behavior and would prefer to attach behavior to any type through traits... rust will be nice to use. If you like the idea of having generics checking on said traits at compile time with sensible messages rather than the duck typed macros also termed templates with their horrendous error messages... rust will be nice to use If you like the idea that the compiler verifies for you at compile time the concept of ownership while giving out references, ensuring 1 mutable reference and 0 immutable references, or N immutable references are allowed, while also ensuring the variable being referenced lives longer or as long as the references... rust will be nice to use If you love spending time debugging invalid references/pointers, races, and more then rust isn't going to nice to use.
  • nyanpasu64 3y ago
    If you don't like the idea that the compiler will fight against you if you try to create multiple simultaneous interchangeable mutable references on a single thread, even when it's the right thing to do in a case, you might struggle with Rust for problems that require that (intrusive linked lists, emulators with multiple interacting objects, etc.).
    • pkolaczk 3y ago
      You can always tell it to shut up by using pointers and unsafe.
    • calo_star 3y ago
      What would be the particular difficulty with intrusive linked lists?
  • pjmlp 3y ago
    concepts are a thing now, compile time execution keeps getting better, and stuff like clang tidy help where C++ fails short. While C++ will never be as safe as Rust, mastering it is still a must in many domains, including contributing to Rust's compiler backends.