Don't write Rust like it's Java - eviltoast
  • Solemarc@lemmy.world
    link
    fedilink
    arrow-up
    2
    arrow-down
    2
    ·
    1 year ago

    If you want inheritance you can add structs as parameters of other structs. This will also allow them to use impl functions for that struct.

    As far as I understand it Arc<> is just the Async version of RC<>.

    I’m not entirely sure about Box<> and a lot of its API’s are still unstable but I believe it’s primarily used as an owner for unsafe things.

    • nous@programming.dev
      link
      fedilink
      English
      arrow-up
      4
      ·
      edit-2
      1 year ago

      As far as I understand it Arc<> is just the Async version of RC<>.

      Not quite right. Arc is the atomic RC, aka the one that is thread safe and can thus can be sent to other threads. Rc is single threaded only. async is agnostic of threading and there exists runtimes that are both multithreaded and single threaded.

      Although tokio, the most common async runtime, is multi threaded and so tasks you create need to be multi-threaded safe thus you likely need to use Arc for most things in tokio. But that is due to the multithreaded nature of tokio, not the fact it is async.

      I’m not entirely sure about Box<> and a lot of its API’s are still unstable but I believe it’s primarily used as an owner for unsafe things.

      Box is the single ownership heap allocated datastucture of rust. It is a core type that is used for a lot of things. It is not just for unsafe things and mostly safe things are put in a Boxes. It is basically used whenever you want something on the heap rather than the stack At least when the type in question is not already heap based (like Strings, Vec, Arcs etc).

      It is used a lot for trait objects (when the type is only known at runtime, not compile time, aka Box&lt;dyn Trait>/&amp;dyn Trait) when you need ownership of the object (aka reference trait objects are not suitable). Or when you have a large type that needs to be moved around a lot and you don’t want expensive stack copies when a cheap copy of a pointer to some heap data will do instead. Or you have a type that is not Sized (aka the size is not known at compile time and needs to be tracked at runtime) but need it to be owned (such as a slice, trait objects etc).

    • sleep_deprived@lemmy.world
      link
      fedilink
      arrow-up
      3
      ·
      1 year ago

      Box is (basically) just the way to have memory on the heap. Here’s a direct comparison of how to do heap memory in C/++ and in rust:

      int* intOnHeap = (int*)malloc(sizeof(int));
      *intOnHeap = 0;
      MyClass* classOnHeap = new MyClass();
      
      let intOnHeap: Box = Box::new(0);
      let structOnHeap: Box = Box::new(MyStruct::default());
      

      There can be a bit more to it with custom allocators etc. but that’s the only way most people will use boxes. So Box basically just means “a T is allocated somewhere and we need to free that memory when this value is dropped”.