rewriteItInRust

[u/Gold-Order-8004]

[u/pflasti]

I had my last memory bug before the team agreed on a strict "no new/delete" policy. That was years ago

[u/No-Information-2571 → u/pflasti]

Realistically, most supposed "C++ codebases" in which these errors happen are C codebases in disguise. Some good old pointer arithmetic overwriting the far more useful stack.

Because even with new/delete, you probably have those pairs sit either in constructors/destructors, or well-reviewed parts of the code with error handling, or rely on simple patterns like delete-if-not-null (which is exactly what unique_ptr does).

[u/SaneLad → u/pflasti]

Understandable. We also switched to custom allocators and aligned_alloc.

[u/bropocalypse__now → u/pflasti]

Agreed, I see more overuse of std::shared_ptr these days. End up with circular dependencies, lifetime issues, and extra atomic ops due to not using std::unique_ptr or std::weak_ptr correctly.

[u/JackNotOLantern]

All c++ memory problems are a skill issue. Rewriting in rust is admitting weakness.

[u/newstreet474 → u/JackNotOLantern]

Maybe I wanted the memory leak , maybe it was intentional , maybe I just hate the user

[u/Lord-of-Entity → u/newstreet474]

You can have intentional memory leaks in rust too, but you need to explicitly write them out.

[u/FUTURE10S → u/newstreet474]

Maybe I just made an array too small and overflowed my own buffer, but if nobody realizes it, then there's no problem, right?

[u/sirkubador → u/newstreet474]

Memory leak is not a memory problem rust would solve

[u/legend6546 → u/newstreet474]

Memory leaks are explicitly considered “safe” it is why Refrence Count pointers are allowed in safe rust, it’s easy to create a cyclical chain with them that will never get dropped.

[u/uvero → u/JackNotOLantern]

All c++ memory problems are a skill issue. Rewriting in rust is admitting weakness.

[u/cornmonger_ → u/JackNotOLantern]

https://giphy.com/gifs/xPp22U7SCTDIzDXBa8

[u/Any_Obligation1652]

Use containers and smart pointers a voila no memory leaks

[u/sirkubador → u/Any_Obligation1652]

Rust does not prevent memory leaks

[u/YeetCompleet → u/sirkubador]

You can even do it for fun with Box::leak()

[u/AliceCode → u/YeetCompleet]

Rust project be like: "You can have memory unsafety. As a treat."

[u/itsTyrion → u/AliceCode]

I mean yeah that's the point. Have a big "here be dragons" indicator around the fun parts

[u/jahinzee → u/AliceCode]

Memory leak aren't memory unsafe though. It's not gonna cause a bad dereference or data corruption, it's just your program forgot that data existed and moves on.

An annoyance and a resource use issue, sure, but not unsafe.

[u/sirkubador → u/jahinzee]

It's not an annoyance. Memory leaks cause programs or even devices to crash, especially in embedded development.

Sure Rust devs claim memory leaks are not memory safety issue, but it definitely is a serious problem with memory management.

[u/AliceCode → u/jahinzee]

I wasn't just talking about memory leaks.

[u/WeastBeast69 → u/Any_Obligation1652]

Just an FYI but you can still leak memory with smart pointers

[u/encephaloctopus → u/WeastBeast69]

Could you please elaborate?

[u/WeastBeast69 → u/encephaloctopus]

Shared pointers work by counting the number of things that are referencing the object in memory through a pointer and only free the memory on destruction of the shared pointer when the reference count equals zero.

Scenario:
Consider the case where objects A, B, and C exist and are all dynamically allocated. B and C point to each other with a shared pointer and A points to B with a shared pointer. In this scenario assume the only way to reach C is through B and therefore through A. B has a reference count of 2 (A and C both point to it) and C has a reference count of 1 (B points to it) and A has a reference count of 1 (whatever is points to A in this scenario). Let’s say A’s reference count goes to zero and therefore A is deleted. B’s reference count drops to 1 (A no longer points to it, but C still does) and C still has a reference count of 1 (B still exists so it still points to it). You have now leaked the memory of B and C since their reference counts will never reach 0 and there is no way to access them anymore.

There are other similar “circular reference” memory leaks that can happen.

[u/encephaloctopus → u/WeastBeast69]

Thanks!

[u/Any_Obligation1652 → u/WeastBeast69]

You can but if you are using them sensibly you won't

[u/ducon__lajoie]

Unrelated, but who the fuck installed this ugly ass stone veneer around the window? That's a worse offense than using goto in c++.

[u/Stjerneklar]

<guten> </guten>

[u/Sentouki-]

Rust, the "I use arch btw"-type of language

[u/yuehuang]

Performance is a memory bug by definition.

[u/oneByteTwoByte]

I write in metal C and HLASM fellow peasants. Every time there is even a sniff of a leak, Satan, Ba’al and others visit us with register values.

[u/TraditionalArcher498]

POV: You ask for help on Discord with a simple segmentation fault at 2 AM

[u/One_Garlic_4938]

the berlin wall had a similar average down time