<\/p>\n
Updated July 2, 2026.<\/strong> Refreshed for Go 1.22+ and current SEO best practices.<\/p>\n<\/div>\n In this lesson we cover the Go pointers tutorial<\/strong> essentials \u2014 what pointers are, how to take addresses and dereference values, when to pass pointers to functions, and how pointers interact with structs and methods. If you completed Go Structs and Methods<\/a>, you already met pointer receivers on methods. Here we go deeper so you understand why<\/em> Go uses pointers and how to avoid common mistakes.<\/p>\n Prerequisites:<\/strong> Lessons 1\u20138 completed, Go 1.22 or newer installed. Estimated time:<\/strong> 40\u201350 minutes.<\/p>\n A pointer<\/strong> is a variable that stores the memory address<\/em> of another value \u2014 not the value itself. In Go, you declare a pointer type by placing Two operators work with pointers:<\/p>\n Unlike C, Go has no pointer arithmetic \u2014 you cannot add or subtract from a pointer to walk through memory. This design choice keeps Go memory-safe while still giving you direct control when you need it.<\/p>\n Go passes arguments by value<\/strong> by default. When you pass an integer or a struct to a function, the function receives a copy<\/em>. Changes inside the function do not affect the original unless you pass a pointer.<\/p>\n Use pointers when a function must modify the caller’s data, when copying a large struct would be expensive, or when you need to represent optional or shared state. For small values like integers and booleans, passing by value is often clearer and just as fast.<\/p>\n The built-in Both approaches produce a Dereferencing a Go’s type system does not prevent nil pointer dereferences at compile time. Defensive nil checks at API boundaries \u2014 especially in functions that accept pointers from callers \u2014 prevent crashes in production. Methods with pointer receivers can also be called on nil receivers in some cases (when the method does not dereference fields), but relying on that is rare.<\/p>\n When a method uses a pointer receiver<\/strong> Go automatically takes the address when you call a pointer-receiver method on a value ( Not everything needs an explicit pointer. Slices<\/strong> and maps<\/strong> are reference types \u2014 they internally hold a pointer to underlying data. Passing a slice to a function lets you modify elements without Understanding this distinction prevents over-using pointers. Modify slice elements<\/em> through the slice directly; use a pointer to the slice only when you need to reassign the slice header (length, capacity, or backing array). Maps behave similarly \u2014 you pass the map value, but it references shared underlying data.<\/p>\n Follow these guidelines when deciding between values and pointers in your Go code:<\/p>\n These rules align with the standard library. Types like You now understand Go pointers<\/strong> \u2014 addresses, dereferencing, nil safety, pointer receivers, and when to pass pointers versus values. In the next lesson we cover interfaces and error handling<\/strong> \u2014 Go’s approach to polymorphism and the idiomatic way to signal and handle failures.<\/p>\n Continue the series: Lesson 8 \u2013 Structs and Methods<\/a> \u00b7 Lesson 10 \u2013 Interfaces and Errors<\/a><\/p>\n What is a pointer in Go?<\/strong> When should I use pointer receivers?<\/strong> Can Go pointers cause memory leaks?<\/strong> <\/p>\n1. What Is a Pointer?<\/h4>\n
*<\/code> before the underlying type. The zero value of a pointer is nil<\/code>, meaning it points to nothing.<\/p>\n\n
&<\/code> (address-of) \u2014 returns the memory address of a variable<\/li>\n*<\/code> (dereference) \u2014 reads or writes the value at that address<\/li>\n<\/ul>\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\tx := 42\n\tp := &x \/\/ p is *int \u2014 address of x\n\n\tfmt.Println(\"value of x:\", x) \/\/ 42\n\tfmt.Println(\"address stored in p:\", p)\n\tfmt.Println(\"value through p:\", *p) \/\/ dereference \u2014 42\n\n\t*p = 100 \/\/ change x through the pointer\n\tfmt.Println(\"x after *p = 100:\", x) \/\/ 100\n}\n<\/code><\/pre>\n2. Pointers vs Values in Function Calls<\/h4>\n
package main\n\nimport \"fmt\"\n\nfunc incrementValue(n int) {\n\tn++ \/\/ only changes the local copy\n}\n\nfunc incrementPointer(n *int) {\n\t*n++ \/\/ changes the original variable\n}\n\nfunc main() {\n\tcount := 10\n\tincrementValue(count)\n\tfmt.Println(\"after incrementValue:\", count) \/\/ 10 \u2014 unchanged\n\n\tincrementPointer(&count)\n\tfmt.Println(\"after incrementPointer:\", count) \/\/ 11 \u2014 changed\n}\n<\/code><\/pre>\n3. Creating Pointers with new and Struct Literals<\/h4>\n
new(T)<\/code> allocates memory for type T<\/code>, zeroes it, and returns *T<\/code>. For structs, the more idiomatic approach is a struct literal with &<\/code>:<\/p>\npackage main\n\nimport \"fmt\"\n\ntype Book struct {\n\tTitle string\n\tAuthor string\n\tPages int\n}\n\nfunc main() {\n\t\/\/ new() \u2014 returns pointer to zero-valued Book\n\tb1 := new(Book)\n\tb1.Title = \"The Go Programming Language\"\n\tfmt.Println(b1.Title)\n\n\t\/\/ struct literal with & \u2014 preferred style\n\tb2 := &Book{\n\t\tTitle: \"Concurrency in Go\",\n\t\tAuthor: \"Katherine Cox-Buday\",\n\t\tPages: 250,\n\t}\n\tfmt.Printf(\"%+v\\n\", b2)\n}\n<\/code><\/pre>\n*Book<\/code>. The struct literal form is more readable because you can set fields at creation time. Constructor functions like NewBook(...)<\/code> that return *Book<\/code> are common in production code \u2014 you saw this pattern with NewAccount<\/code> in the Structs lesson.<\/p>\n4. Nil Pointers and Safety<\/h4>\n
nil<\/code> pointer causes a runtime panic<\/strong>. Always check whether a pointer is nil<\/code> before dereferencing when the pointer might not be initialized:<\/p>\npackage main\n\nimport \"fmt\"\n\ntype User struct {\n\tName string\n}\n\nfunc greet(u *User) {\n\tif u == nil {\n\t\tfmt.Println(\"no user provided\")\n\t\treturn\n\t}\n\tfmt.Println(\"Hello,\", u.Name)\n}\n\nfunc main() {\n\tvar u *User \/\/ nil pointer \u2014 zero value for *User\n\tgreet(u) \/\/ safe \u2014 handled\n\n\tu = &User{Name: \"Ada\"}\n\tgreet(u) \/\/ Hello, Ada\n}\n<\/code><\/pre>\n5. Pointer Receivers on Methods<\/h4>\n
(t *Type)<\/code>, it can modify the struct and avoids copying large values on each call. This is the pattern you need for mutating methods and for consistency when any method on a type modifies state:<\/p>\npackage main\n\nimport \"fmt\"\n\ntype Counter struct {\n\tcount int\n}\n\n\/\/ Value receiver \u2014 gets a copy; cannot change original\nfunc (c Counter) ValueReceiver() int {\n\treturn c.count\n}\n\n\/\/ Pointer receiver \u2014 can mutate the struct\nfunc (c *Counter) Increment() {\n\tc.count++\n}\n\nfunc (c *Counter) Current() int {\n\treturn c.count\n}\n\nfunc main() {\n\tc := Counter{}\n\tc.Increment()\n\tc.Increment()\n\tfmt.Println(c.Current()) \/\/ 2\n}\n<\/code><\/pre>\nc.Increment()<\/code> works even though c<\/code> is a value). The compiler inserts (&c).Increment()<\/code> behind the scenes. Choose pointer receivers when the method mutates the receiver or when the struct is large; use value receivers for small, immutable types.<\/p>\n6. Pointers, Slices, and Maps<\/h4>\n
*<\/code>:<\/p>\npackage main\n\nimport \"fmt\"\n\nfunc addTag(tags []string, tag string) {\n\ttags = append(tags, tag) \/\/ may not change caller's slice header\n}\n\nfunc addTagPointer(tags *[]string, tag string) {\n\t*tags = append(*tags, tag) \/\/ changes caller's slice\n}\n\nfunc main() {\n\ttags := []string{\"go\", \"tutorial\"}\n\taddTag(tags, \"pointers\")\n\tfmt.Println(tags) \/\/ [go tutorial] \u2014 unchanged\n\n\taddTagPointer(&tags, \"pointers\")\n\tfmt.Println(tags) \/\/ [go tutorial pointers]\n}\n<\/code><\/pre>\n7. When to Use Pointers \u2014 Practical Guidelines<\/h4>\n
\n
nil<\/code> represents “not present” (optional fields).<\/li>\ntime.Time<\/code> are structs passed by value because they are small and immutable. Types like bytes.Buffer<\/code> use pointer receivers because they accumulate mutable state.<\/p>\n8. Next Steps<\/h4>\n
Frequently Asked Questions<\/h4>\n
\nA pointer holds the memory address of a value. Use &<\/code> to get an address and *<\/code> to read or write through it. The zero value is nil<\/code>.<\/p>\n
\nUse pointer receivers when methods modify the struct, when the struct is large, or when you want consistency across all methods on a type. Value receivers work for small, immutable types.<\/p>\n
\nGo has garbage collection, so you do not manually free memory. However, holding pointers to large structures longer than needed can delay collection \u2014 design APIs to release references when done.<\/p>\n