# Pointers in Go - When to use the ampersand and the asterisk?

Looking back, this might be a dumb question, but that’s what blog notes are for 🤣

## tl;dr

* `&`: Used as an **operator** to get the address of a variable
    
* `*` **in Type**: Used to **define the type** as a pointer (e.g., `*int`)
    
* `*` **in Expression**: Used as an **operator** to dereference
    

In short `*` does two things and `&` can only to that one thing.

## Example

Can be run here: [https://go.dev/play/p/XdA4\_qdt7lR](https://go.dev/play/p/XdA4_qdt7lR)

```go
package main

import "fmt"

func main() {
	value := 42 // The original data

	// --- 1. & gets the address ---
	address := &value
	fmt.Printf("1. & Action: get Address: %p\n", address)

	// --- 2. * defines the Pointer Type ---
	// 'p' is declared as the TYPE '*int' (a pointer type).
	var p *int = address
	fmt.Printf("2. Type Definition: 'p' is of TYPE %T\n", p)

	// --- 3. * dereferences ---
	// The '*' operator reads the value at the address stored in 'p'.
	retrievedValue := *p
	fmt.Printf("3. * Operator: Value retrieved via dereference: %d\n", retrievedValue)
}
```

## The struggle - Will the ampersand show up in type definition?

**NO, the ampersand will never be used in type definitions**, because it only does one thing, it gets the address of the variable. For type definitions we use `*`.

```go
// 1. * used for type definition
func updateScore(p *int) {
	*p = 99 // 2. * used for dereference and change the value at that address
}
```

## Good Reads

If `*p = 99` feels confusing, read this article: [https://dave.cheney.net/2017/04/26/understand-go-pointers-in-less-than-800-words-or-your-money-back](https://dave.cheney.net/2017/04/26/understand-go-pointers-in-less-than-800-words-or-your-money-back)