If you’re used to writing code in C,adding a pointer field might feel trivial—but remember that you’re still managing lifetime manually.
This new field introduces anor point of failure: pointer may outlive buffer it points into if you’re not careful about when you read next file.
The above snippet shows how location field is added and assigned during scanning.
Pain Point – Shared Buffer Bug:
• If you process multiple files sequentially and store each result。every `Mistake.location` will point into same shared buffer `buf`. When you read next file,you overwrite `buf`,and all previous results now reference wrong contents.
• In plain C this manifests as a subtle bug: pointers are still valid but y refer to unexpected data—exactly what makes debugging memory bugs so painful.
• In Rust,this kind of bug would surface at compile time because borrow checker tracks lifetimes of references.
Copying error snippets
c
size_t location_len = len - i;if {
location_len = 12;}
m->location = malloc;memcpy，m->location = '\0';其实，This fixes shared-buffer issue by giving each `Mistake` its own copy of context string.
Memory leak issue
c
for {
free;free，}
You must remember both allocations and ir correct order—anor source of bugs.
Fixed array upper bound problem
c
struct CheckResult results;If more than `MAX_RESULTS` files are checked simultaneously,you get an out-of-bounds write—a hard-to-detect bug in production.
Summary of C challenges
shared buffer → stale pointers → incorrect errors
manual allocation → leaks or double frees → runtime crashes
fixed array size → overflow → undefined behavior
These problems arise because every detail—ownership。lifetime,deallocation order—is tracked only mentally by programmer.
Rust rewrite – first step: robust file reading
rust
use std::fs::read_to_string;fn main -> Result<, std::io::Error>{
let s = read_to_string?，// …Ok)
}
Rust forces handling I/O errors via `Result`,so you can’t ignore m like in naive C code.
Using Option instead of NULL for optional mistakes
rust
let result = s.find;// returns Option
match result {
Some => println!,None => println!,}
Here missing values are explicit rar than implicit . This eliminates whole classes of null-pointer bugs.
Borrowing slices for error context – no manual copy needed
rust
let slice = &s;println，;// slice is &str reference into original string
Slices don’t allocate—y just borrow part of an existing string—and y carry lifetimes that guarantee safety.
Lifetime annotations prevent dangling references when returning from functions
rust
struct Mistake<'a>{ location:&'a str }
fn check<'a> -> Result,std::io::Error>{
let s = read_to_string?，if let Some = s.find{
Ok)
}else{
Ok
}
}
The compiler forces you to specify `'a`,ensuring that any returned reference cannot outlive its source string.
Pain Point Recap – Why Manual Memory Management Feels Like Playing Russian Roulette?
Lifetime confusion – You often forget wher a pointer still refers to live data.
Allocation/Deallocation mismatch – One missing free leads to leaks;double-free crashes.
Fixed-size buffers – Easy to overflow without noticing until later.
Null pointer dereference – A single forgotten check can bring down your whole program.
Rust’s declarative approach turns se fragile mental checks into compile-time guarantees.
Furr evolution – Handling multiple errors per document gracefully**
With Rust’s ownership model we can avoid copying large amounts of text:
Store entire document once inside a Mistake.
Keep only indices . Each index marks where a comma occurs.
Format output lazily using slices from those indices when reporting.
This design keeps memory usage minimal while preserving clear ownership semantics.
Final Takeaway – Declarative Memory Management Explained**
Instead of telling machine “allocate here”。“deallocate re”,Rust asks you:
What operation might fail?→ Wrap return type in Result.
Is something optional?→ Use Option.
Does something borrow from somewhere else?按理说，→ Declare lifetime parameters.
Does something own its own data?→ Use owned types .
The compiler n inserts all necessary deallocations automatically and refuses any code path that would violate ownership rules.
Thus,Rust isn’t garbage-collected nor does it require manual frees—it simply moves responsibility from runtime checks into static guarantees encoded by your type declarations.
