Golang on Wanzi's Blog – Notes on life, tech, and DevOps.

Go Study Notes - Detailed Explanation of Pointers

wzdushu@gmail.com (wanzi) — Mon, 22 May 2023 18:22:42 +0800

What is a Pointer?

In the Go language, a pointer is a variable that stores the memory address of another variable. Therefore, a pointer variable points to the memory address of another variable, not the variable itself.

When declaring a pointer variable, you need to add * before the variable name, indicating that this is a pointer variable, for example:

`1`	`var p *int`

This indicates that a pointer named p has been declared, which points to an integer variable. The & operator can be used to get the address of a variable, for example:

1
2

x := 10
p := &x

This means getting the address of the variable x and assigning it to the pointer variable p.

When using a pointer to access a variable, you need to use the * operator, which is the dereference operator, for example:

1
2
3

x := 10
p := &x
fmt.Println(*p)

This means printing the value of the variable pointed to by the pointer variable p, which is the value of the variable x.

In addition to declaring pointer variables and obtaining the addresses of variables, you can also use the new function to create pointer variables. For example, creating a pointer to an integer variable:

`1`	`p := new(int)`

This will create a new integer variable, return its address, and then assign the address to the pointer variable p.

Pointers can also be used for function parameters and return values to share data between function calls.

When using pointers, be careful because if a pointer points to an invalid memory address, the program may crash or exhibit unpredictable behavior. Therefore, when using pointers, ensure that the memory address pointed to by the pointer is valid.

Use Cases for Pointers

Passing Parameters via Pointer Functions

Pointers can be used to pass parameters to functions. When a function needs to modify the value of an actual parameter, the address of the actual parameter can be passed as a formal parameter to the function, and the value of the actual parameter can be modified through the pointer. For example:

func modify(s *string) {
    *s = "hello, world"
}

func main() {
    s := "hello"
    modify(&s)
    fmt.Println(s) // Output: hello, world
}

Accessing Struct Fields via Pointers

Pointers can more conveniently access fields in a struct, especially when the struct is large, passing a pointer is more efficient than passing the entire struct. For example:

type Person struct {
    Name string
    Age  int
}

func main() {
    p := &Person{
        Name: "Alice",
        Age:  18,
    }
    p.Name = "Bob"
    fmt.Println(p) // Output: &{Bob 18}
}

Dynamically Allocating Memory via Pointers

Pointers can dynamically allocate memory at runtime, such as using the new() function to create a new variable and return its address. For example:

func main() {
    p := new(int)
    *p = 42
    fmt.Println(*p) // Output: 42
}

Passing Variadic Arguments

In Golang, you can use pointers to pass variadic arguments. This is because when using variadic arguments, what is passed is a slice (slice), and a slice is essentially a pointer to an array. This operation can avoid copying large amounts of data.

For example, consider the following function, which accepts variadic arguments and prints them out:

func printArgs(args ...int) {
    for _, arg := range args {
        fmt.Println(arg)
    }
}

Now, if you want to pass a slice as an argument to another function, you can use a pointer:

func printArgsPtr(args *[]int) {
    for _, arg := range *args {
        fmt.Println(arg)
    }
}

func main() {
    args := []int{1, 2, 3}
    printArgsPtr(&args)
}

In this example, we define a new function printArgsPtr that uses a pointer as a parameter to receive a slice. Inside the function, we use *args to dereference the pointer and get the actual slice, and then iterate over it to print each element. In the main function, we create a slice and pass its address to the printArgsPtr function.

It’s important to note that when using pointers to pass variadic arguments, if the slice is empty, you should not pass a nil pointer, but rather an empty slice. This is because in Golang, an empty slice and a nil pointer have different meanings, which I will explain later.

Besides the above aspects, pointers are also very useful in some specific scenarios, such as handling data structures, where pointers can more efficiently manipulate linked lists, trees, and other data structures. However, it’s important to note that overusing pointers can make code difficult to maintain, so they should be used with caution.

Common Nil Data Types

In the Go language, there are several nil data types, including:

Nil pointer (nil pointer): A pointer that points to a non-existent address, generally represented by nil.
Nil slice (nil slice): A slice with a length of 0, generally represented by nil.
Nil map (nil map): A map with a length of 0, generally represented by nil.
Nil interface (nil interface): An interface with both type and value as nil, generally represented by nil.
Nil channel (nil channel): A channel that has not been allocated storage space, generally represented by nil.

nil represents a null pointer, i.e., a pointer variable that does not point to any address, and can represent the zero value of pointer, interface, map, channel, and function types, but cannot be used to represent the zero value of other types such as int, float, bool, etc.

These nil data types are defined as the zero values of their respective types, where the zero values of pointers, slices, maps, interfaces, and channels are all nil, indicating that the default values of these types are nil, i.e., they do not point to any actual data. Therefore, when using these data types, they can be initialized to their zero values, or explicitly assigned to nil.

For example:

var s []int = nil // Define a nil slice
var p *int = nil  // Define a nil pointer
var m map[string]int = nil // Define a nil map
var i interface{} = nil // Define a nil interface
var c chan int = nil // Define a nil channel

Note the following points:

nil is not a keyword, but a predefined identifier. In Go, nil can be assigned to any type of pointer, slice, map, function, and channel variables.
Nil slices and nil maps need to be initialized before use, otherwise, a panic exception will occur.
Nil channels need to be initialized with the make function before they can be used.
Nil pointers can be used directly because their value is nil.
Nil interfaces can be used directly without initialization. Because a nil interface is essentially a variable of type interface{}, which can accept any type of value, including nil. So, when using a nil interface, if no explicit value is assigned, it is a nil interface and can be used directly.

Avoiding Nil Pointer Exceptions

When using pointer-type variables, perform a nil check to avoid nil pointer exceptions.

For example:

Integer Pointer Type

1
2

var p *int
fmt.Println(p == nil) // Outputs true

In the code, p is a variable of integer pointer type, and since it has not been initialized, its value is nil. You can check if it is a nil pointer by comparing p to nil.

Integer Slice Type

1
2

var s []int
fmt.Println(s == nil) // Outputs true

In the code, s is a variable of integer slice type, and since it has not been initialized, its value is nil. You can check if it is a nil slice by comparing s to nil.

Map Type

1
2

var m map[string]int
fmt.Println(m == nil) // Outputs true

In the code, m is a variable of map type, and since it has not been initialized, its value is nil. You can check if it is a nil map by comparing m to nil.

Function Type

1
2

var f func(int) int
fmt.Println(f == nil) // Outputs true

In the code, f is a variable of function type, and since it has not been initialized, its value is nil. You can check if it is a nil function by comparing f to nil.

Integer Channel Type

1
2

var ch chan int
fmt.Println(ch == nil) // Outputs true

In the code, ch is a variable of integer channel type, and since it has not been initialized, its value is nil. You can check if it is a nil channel by comparing ch to nil.

Finally, it is particularly important to note that empty arrays, empty slices, and empty maps can use the len() function to get their length, and the result will be 0. However, nil pointers, nil interfaces, and nil channels cannot use the len() function to get their length, otherwise, a runtime error will occur.

This is because, in Go, the len() function returns the length of a value, which is pre-defined and usually calculated by the compiler. The length of empty slices, empty arrays, and empty maps is 0 because they already have a block of memory, so the len() function can be used to get their length.

For nil interfaces and nil channels, which do not store data, their length is meaningless, so using the len() function will cause a runtime error. If you need to determine whether they are nil, you should use the nil value for the check.

Go Study Notes - Review of Go Fundamentals

wzdushu@gmail.com (wanzi) — Fri, 17 Mar 2023 18:22:42 +0800

I. Basic Knowledge

1. Basic Data Types

Value Types:

bool (1 byte)
byte (1 byte, alias of uint8)
rune (4 bytes, alias of int32, range -2^31 to 2^31)
int (32 or 64 bits, 4 or 8 bytes)
int8 (1 byte), int16 (2 bytes), int32 (4 bytes), int64 (8 bytes)
uint (32 or 64 bits, 4 or 8 bytes)
uint8 (1 byte), uint16 (2 bytes), uint32 (4 bytes), uint64 (8 bytes)
float32 (4 bytes), float64 (8 bytes)
string     // Sequence of fixed-length characters, underlying is a byte array
complex64, complex128 (default) // Complex number type
array   // Array (fixed length)
struct  // Structure

Reference Types (Pointer Types):

1
2
3

slice  // Slice, default value is nil
map    // Map, default value is nil
chan   // Channel, default value is nil

2. Encoding & Strings

Go’s default encoding is UTF-8.

Unicode: A global character encoding standard with variable-length encoding. Multiple implementations exist, such as UTF-8 and UTF-16. Character lengths range from 1 to 4 bytes. English characters typically occupy 1 byte; Chinese characters occupy 2 bytes. Each character corresponds to a hexadecimal number. Use utf8.RuneCountInString() to get the length of a Unicode string.
UTF-8: A variable-length character encoding, one implementation of Unicode. English characters take 1 byte, Chinese characters take 3 bytes, emojis take 4 bytes.

Go has two types of characters: byte and rune.

byte: Alias of uint8, commonly used for handling ASCII characters. Represents an ASCII string. Use []byte(s) to convert string s into a byte array.
rune: Alias of int32, equivalent to int32. Typically used to represent a Unicode code point, capable of handling any character. Use []rune(s) to convert string s into a Unicode rune array.

string: A sequence of fixed-length characters, internally implemented as a byte array. Strings are immutable. When strings contain only letters and digits, they can be converted to []byte or []rune. For multi-byte encoded characters like Chinese, conversion to []rune is required. The most universal method is []rune(s).

Single quotes: Used to denote byte or rune types. Default is rune. Content inside single quotes is an ASCII character. Use len() to get the length of an ASCII string.
Double quotes: Denote a string literal that supports escape sequences but cannot span multiple lines.
Backticks: Used to create raw string literals, supporting no escape sequences and allowing multiline content. Commonly used for writing multi-line messages, HTML, regular expressions, etc.

3. Built-in Functions

append  // Append elements to arrays or slices, returns modified array/slice
close   // Primarily used to close channels
delete  // Remove key-value pair from map
panic   // Stop normal goroutine execution (used with recover for error handling)
recover // Allows program-defined recovery from panic in goroutines
real    // Return real part of complex number (complex, real, imag for creating/manipulating complex numbers)
imag    // Return imaginary part of complex number
make    // Allocate memory, return the Type itself (only valid for slice, map, channel)
new     // Allocate memory, primarily for value types like int, struct, return pointer to type
cap     // Return maximum capacity of a type (only valid for slice and map)
copy    // Copy elements from one slice to another, return number of copied elements
len     // Get length (e.g., string, array, slice, map, channel)
print, println // Low-level print functions

II. Common Placeholders:

Placeholder  Description                            Example                     Output
%v         Default format of the value           Printf("%v", people)        {zhangsan}
%+v        Include field names when printing structs  Printf("%+v", people)    {Name:zhangsan}
%#v        Go syntax representation of the value   Printf("#v", people)      main.Human{Name:"zhangsan"}
%T         Go syntax representation of the type    Printf("%T", people)      main.Human
%%         Literal percent sign, not a value placeholder  Printf("%%")          %
%t         Boolean placeholder (true or false)     Printf("%t", true)        true
%c         Character placeholder, corresponding Unicode code point  Printf("%c", 0x4E2D)  中
%d         Integer placeholder, decimal representation  Printf("%d", 0x12)       18
%s         String placeholder (string type or []byte)  Printf("%s", []byte("Go语言"))  Go语言
%p         Pointer placeholder, hexadecimal with prefix 0x  Printf("%p", &people)     0x4f57f0

III. Arrays, Slices, and Maps

1. Arrays

var array_variable_name [number_of_elements]type

Array length must be a constant; once defined, it cannot change. Elements within the array can be modified.

`1`	`var a [5]int`

Declares an array of length 5 with type int.

a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}
b := a[3:6]
// 8 8
fmt.Println(len(a), cap(a))
// Value: [3 4 5], Length: 3, Capacity: 5
fmt.Printf("Value: %d, Length: %d, Capacity: %d", b, len(b), cap(b))

2. Slices

A flexible, variable-length sequence of elements of the same type. Slices are built on top of arrays and support automatic resizing. Slices are reference types, internally containing address, length (len), and capacity (cap).

Syntax: var slice_variable_name []type

var a []string // Declares a slice of length 0, type string
var a []string{} // Declares a slice of length 0, type string, initialized

var myslice = []string{"Beijing", "Shanghai", "Shenzhen"}

for i := 0; i < len(myslice); i++ {
   fmt.Println("for loop:", myslice[i])
}

3. Maps

An unordered data structure based on key-value pairs. In Go, maps are reference types and must be initialized using make before use.

Syntax: map[key_type]value_type

Maps have a default initial value of nil. Memory must be allocated using the make() function. Note: cap does not apply to maps—cap returns the allocated space size of a slice/array. To get the map’s capacity, use len().

userInfo := map[string]string{
   "username": "xiaoli",
   "password": "1234556",
}
for k, v := range userInfo {
   fmt.Println(k, v, len(userInfo))
}

IV. Pointers

In Go, reference types require declaration and memory allocation; otherwise, values cannot be stored. For value types, memory is automatically allocated during declaration.

Pointer address: &a
Pointer dereference: *&a
Pointer type: &a → *int
& gets address, * dereferences to value

new: Allocates memory for a type and returns a pointer. Useful for instantiating structs, returning the pointer address of the struct.
make: Only used for creating memory for chan, map, and slice. Returns the actual type, not a pointer.

V. Structs

Go does not have classes or class inheritance. Instead, it uses structs combined with interfaces to achieve higher extensibility and flexibility compared to traditional object-oriented programming.

1. Ways to Instantiate Structs

Direct assignment (var), new, and key-value initialization.

package main

import "fmt"

// Define a struct
type member struct {
	name string
	city string
	age  int
}

func main() {
	var p1 member // Direct assignment instantiation
	p1.name = "Xiaoming"
	p1.city = "Beijing"
	p1.age = 32

	var p2 = new(member) // Instantiation using new
	p2.name = "Xiaoli"
	p2.city = "Shanghai"
	p2.age = 20

	p3 := &member{
		name: "Xiao Zhang",
		city: "Shenzhen",
		age:  18,
	} // Key-value initialization
	fmt.Printf("p1=%v \n", p1) // Output value
	fmt.Printf("p1=%+v \n", p1) // Output struct with field names
	fmt.Printf("p2=%#v \n", p2) // Output struct fields with Go syntax
	fmt.Printf("p3=%#v \n", p3)
}

Output:

p1={Xiaoming Beijing 32}
p1={name:Xiaoming city:Beijing age:32}
p2=&main.member{name:"Xiaoli", city:"Shanghai", age:20}
p3=&main.member{name:"Xiao Zhang", city:"Shenzhen", age:18}

2. Struct Methods and Receivers

In Go, methods are functions associated with a specific type, called the receiver. The receiver concept is similar to this or self in other languages.

Syntax:

1
2

func (receiver_variable receiver_type) method_name(parameter_list) (return_values) {
}

package main

import "fmt"

// Define a struct
type Person struct {
   name string
   age  int
   city string
}

// Value receiver
func (p Person) printInfo() {
   fmt.Printf("Name: %s, Age: %d, City: %s\n", p.name, p.age, p.city)
}

// Pointer receiver
func (p *Person) setInfo(name string, age int, city string) {
   p.name = name
   p.age = age
   p.city = city
}

func main() {
   // Instantiate struct
   p1 := Person{
      name: "Xiaoming",
      age:  15,
      city: "Tianjin",
   }
   p1.printInfo() // Name: Xiaoming, Age: 15, City: Tianjin
   p1.setInfo("Tiantian", 18, "Beijing")
   p1.printInfo() // Name: Tiantian, Age: 18, City: Beijing
}