Skip to main content

Pointer

Introduction

This document explains the use of pointers in Wave. Wave is a language that supports low-level system programming and provides pointers to allow explicit memory address manipulation. A pointer is a variable that points to the memory address of a specific type, allowing direct access and modification of values.


Pointer Declaration

In Wave, pointers are declared using the ptr<type> format. For example, an integer pointer can be declared as follows:

var p: ptr<i32>;

This declaration creates a pointer p that points to a value of type i32.


Pointer Initialization

Pointers can be initialized with the address of a variable using the & operator:

var a: i32 = 10;
var p: ptr<i32> = &a;

Here, &a refers to the memory address of variable a, and p becomes the pointer to that address.


Pointer Dereferencing

Use the deref keyword to read or modify the value pointed to by a pointer. This is called dereferencing:

var a: i32 = 10;
var p: ptr<i32> = &a;

println("{}", deref p); // Outputs 10

deref p = 20;
println("{}", a); // Outputs 20

NULL Pointer

In Wave, a null pointer is expressed using the null keyword. Pointer variables can be initialized to null, indicating they do not point to any valid memory:

var p: ptr<i32> = null;

Dereferencing a null pointer will result in a compiler error.


Multiple Pointers

Wave supports multiple pointers. Pointers can be nested in multiple levels and used as follows:

var x: i32 = 1;
var p1: ptr<i32> = &x;
var p2: ptr<ptr<i32>> = &p1;
var p3: ptr<ptr<ptr<i32>>> = &p2;

println("{}", deref p1); // 1
println("{}", deref deref p2); // 1
println("{}", deref deref deref p3); // 1

Arrays and Pointers

Pointers can point to either array elements or the entire array.

Pointer to Array Elements

var a: i32 = 10;
var b: i32 = 20;
var arr: array<ptr<i32>, 2> = [&a, &b];

println("deref arr[0] = {}, deref arr[1] = {}", deref arr[0], deref arr[1]); // 10, 20

Pointer to Entire Array

var arr: ptr<array<i32, 3>> = &[1, 2, 3];
println("{}", arr); // Outputs memory address

Safety and Ownership

Wave introduces an ownership and lifetime system similar to Rust, aiming to ensure memory safety during pointer use. It thoroughly checks for issues such as invalid pointer dereferencing, double freeing, and dangling pointers.

fun main() {
let x: i32 = 42;
let p: ptr<i32> = &x;

println("x = {}", deref p);

deref p = 99;
println("x = {}", x);
}

Output:

x = 42
x = 99

Conclusion

Pointers are one of the key features in Wave enabling high-performance low-level programming. They are very useful for system development that requires direct memory control, native libraries, hardware control, etc., and thanks to Wave's safe compiler structure, it can effectively prevent risks that may arise during pointer use.