I encounter this original blog about Stack Memory and Dangling Pointer problem in Zig language, then I asked myself, how about other system programming languages, like C language and Rust, do they have the same problem? This blog is a very short article comparing how those languages deal with this problem.
TLDR
C language obviously has Dangling Pointer problem too, you have to solve this problem manually. Meanwhile, Rust doesn't allow you to even compile the code, because it has a guard rail - its ownership system.
The C language implementation
Here is my C implementation of the dangling pointer problem demonstrated in the original blog:
#include <stdio.h>
#include <stdlib.h>
// declare User struct
struct User
{
int id;
};
// function that create an User struct in stack memory,
// then return it pointer, which cause the dangling pointer problem.
struct User *init(int id)
{
struct User user;
user.id = id;
return &user;
}
// the main function
int main()
{
struct User *user1 = init(100);
struct User *user2 = init(1000);
printf("user1.id = %d\n", user1->id);
printf("user2.id = %d\n", user2->id);
}
The output on my machine one time (the output is different everytime you run it):
user1.id = 1000
user2.id = 10862404
which show that user1
is inheriting the value of user2
and user2
value are pointing to some invalid memory region, cause its id
attribute to be nonsensical value.
C language solution
This is my C solution using malloc
function:
#include <stdio.h>
#include <stdlib.h>
// declare User struct
struct User
{
int id;
};
// function that create an User struct, but it ...
struct User *init(int id)
{
// ... use heap memory instead, using the `malloc` function
struct User * user;
user = (struct User *) malloc(sizeof(struct User));
user->id = id;
return user;
}
int main()
{
struct User *user1 = init(100);
struct User *user2 = init(1000);
printf("user1.id = %d\n", user1->id);
printf("user2.id = %d\n", user2->id);
// and remember to free the heap memory after used, each pointer,
// one and only one time.
free(user1);
free(user2);
}
Now the output is consistent:
user1.id = 100
user2.id = 1000
The problems with this solution are:
you have to manually free the memory after use,
you will get memory leak application if you forget to free some pointers
you also get security issue if you free the same pointer more than once, because you may cause the modification of unexpected memory locations.
The Rust implementation
Rust prevent programmer from shooting themself in their foot, the equivalent code doesn't event compile:
fn main() {
let user1 = User::init(100);
let user2 = User::init(1000);
println!("user1.id = {}", user1.id);
println!("user2.id = {}", user2.id);
}
struct User {
id: i32,
}
impl User {
fn init(id: i32) -> &User {
let u = User { id: id };
&u
}
}
The errors when you compile are:
|
13 | fn init(id: i32) -> &User {
| ^ expected named lifetime parameter
|
= help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime
|
13 | fn init(id: i32) -> &'static User {
| +++++++
For more information about this error, try `rustc --explain E0106`.
error: could not compile `hello-world` (bin "dangling_pointers") due to previous error
If you naively think that you can get away with this error just by following the compiler's suggestion of change (adding static
lifetime), you are wrong, because now there is new error with this modified code:
fn main() {
let user1 = User::init(100);
let user2 = User::init(1000);
println!("user1.id = {}", user1.id);
println!("user2.id = {}", user2.id);
}
struct User {
id: i32,
}
impl User {
fn init(id: i32) -> &'static User {
let u = User { id: id };
&u
}
}
The error now is:
|
15 | &u
| ^^ returns a reference to data owned by the current function
For more information about this error, try `rustc --explain E0515`.
error: could not compile `hello-world` (bin "dangling_pointers") due to previous errorp
Rust simply doesn't allow a function to return a reference to a data owned by that function itself. You have to move the ownership of this data back to the caller. For more details, please checkout this article about dangling references in "The Rust Programming Language" book.
Rust solution
So here is the solution in Rust:
fn main() {
let user1 = User::init(100);
let user2 = User::init(1000);
println!("user1.id = {}", user1.id);
println!("user2.id = {}", user2.id);
}
struct User {
id: i32,
}
impl User {
fn init(id: i32) -> User {
let u = User { id: id };
u
}
}
Ending
Dangling pointers is just one in many problems that make C a unsafe language to work with.
For modern system programming, I prefer Rust, and If I need more low-level control, I might choose Zig. Rust is like the new C++, and Zig is like the new C. I think they both have their own strength, and I want to see more open-source software written in both of these languages in future.
This article is limited only to my personal experience, there are probably more ways to prevent dangling pointers in C that I don't know yet. Please let me know if I'm wrong.
Happy coding,