Common postfix representations of pointer/reference operations

A few more examples.

Pascal

program pointer_example; var i : Integer; ip : ^Integer; (* Pointer to integer; ^ is prefix *) begin i := 0; (* Neither ISO 7185 Standard Pascal nor ISO 10206 Extended Pascal describe a way to get a pointer to a variable, but this is a common extension. See comments below. *) ip := @i; (* Get a pointer to an integer; @ is prefix *) ip^ := ip^ xor 1; (* Dereference is a postfix operator. *) (* Also note that ^ is not used for any other purpose. *) end. 

Fortran

program pointerExample implicit none integer, pointer :: p1 ! p1 is a pointer to integer integer, target :: t1 ! t1 is an integer target ! You can only take the address of a variable that has the "target" ! attribute. Fortran has very strict aliasing rules, and this signals ! that the variable may be aliased. ! ! This is kind of the opposite of the (now deprecated) "register" ! keyword in C, which is a signal that you cannot take the address ! of it, and it will never be the alias of another variable. t1 = 1 p1=>t1 ! p1 points to t1 p1 = 2 ! Fortran has no pointer arithmetic, so there ! is no need for special "dereference" syntax. end program pointerExample 

BLISS

! BLISS is unusual in that the name of a variable denotes ! a pointer to it. If this sounds weird to you, consider that in ! C, the name of an array denotes a pointer to its first member. ! ! Note that BLISS only really has one "type": the machine word. MODULE POINTERS (MAIN = CTRL) = BEGIN FORWARD ROUTINE TEST; ROUTINE TEST = BEGIN LOCAL X, Y; ! This assigns 1 to the variable X. X = 1; ! This assigns the address of the variable X to the ! variable Y, with no explicit "reference" operator. Y = X; ! If you want to assign the value in X to the variable Y, ! you need to explicitly dereference X. X = .Y; ! Dereference on the lhs means assigning through a pointer. ! Store 2 in the memory location stored in Y. .Y = 2; END; ELUDOM 

This is almost certainly why the -> operator exists in C and C++, since a->b is merely syntactic sugar for (*a).b*.

C++ doesn't have an equivalent postfix for overloaded subscript or call, but you could easily create something like a->[index] in your own language. You could also allow the operator to be chained for more layers of indirection (so (**a).b == a->->b), although that may be pushing it.

Alternatively, you could make dereferencing itself postfix. The main downsides are deviation from the norm and potentially slightly more difficulty parsing (a* and a& look like the beginning of a multiplication and bitwise AND respectively, though a*., a&,, a&), a*;, and probably all other valid syntax using dereference are obviously not operations).

* ...except for this special case where a C++ class provides 2 semantically different overloads, but that kind of garbage is like #define true false

Rust has a postfix syntax for acquiring shared and mutable references ─ it's nothing special, though. You just call the .borrow() or .borrow_mut() method, as long as the Borrow or BorrowMut trait is in scope, respectively.

Example (playground link):

struct Foo; fn accepts_shared_ref(_x: &Foo) {} fn accepts_mut_ref(_x: &mut Foo) {} fn main() { use std::borrow::{Borrow, BorrowMut}; let mut x = Foo; accepts_shared_ref(x.borrow()); accepts_mut_ref(x.borrow_mut()); } 

For dereferencing, there are also the .deref() and .deref_mut() methods, but these don't have a blanket implementation for every type because that would violate the language's ownership model.

Pascal uses postfix ↑ or ^ for dereference.

As I understand it, standard Pascal doesn't have an address operator (you can only form pointers to dynamically allocated objects). However some implementations provide this as an extension, using prefix @.

Confusingly, ISO Pascal apparently allows @ as an alternative token for ↑, on an implementation-defined basis. If so then postfix @ would also be a dereference.