How Do Go's `fmt.Printf` and Pointer Types Interact, and Why Do They Produce Different Outputs for Different Pointer Types?

Evaluating Differences in Go Pointers

In Go, pointers are essential for working with variables. However, understanding the nuances between different pointer types can be challenging. This article explores a specific scenario that showcases the distinctions between pointers and how they affect the output when using the default formatting in the fmt package.

The Code in Question

The following code snippet demonstrates the issue:

type Test struct {
    Test string
}

var Models = map[string]interface{}{
    "test": newTest(),
}

func main() {
    test1 := Test{}
    fmt.Println("Test 1: ")
    fmt.Printf("%v", test1)
    fmt.Println()
    fmt.Println("Test 1 as pointer: ")
    fmt.Printf("%v", &test1)
    fmt.Println()
    test2 := Models["test"]
    fmt.Println("Test 2: ")
    fmt.Printf("%v", test2)
    fmt.Println()
    fmt.Println("Test 2 as pointer: ")
    fmt.Printf("%v", &test2)
}

func newTest() Test {
    var model Test
    return model
}

The Issue

When executing the code, you'll notice a difference in the output when printing test2 versus test1 as a pointer. The output for test1 as a pointer is an empty string, while the output for test2 as a pointer is a hexadecimal representation of the address.

Explanation

The fmt.Printf function uses the %v verb for default formatting, which selects a specific format based on the type of value being printed. For pointers, the default format is the hexadecimal representation of the address.

In the first case (test1 as a pointer), the value being printed is a pointer to a Test struct. However, since the struct was initialized with zero values, the output is empty.

In the second case (test2 as a pointer), the value being printed is a pointer to an interface{}. Before reaching the %v verb, the value went through an additional wrapping inside another interface{}, which then points to Models["test"]. Since the value ultimately being printed is a pointer to an interface{}, the default formatting for pointers applies, and you get the hexadecimal representation of the address.

Solution

To address this issue, one needs to use type assertion to extract the actual Test struct from test2. This can be achieved by:

t2 := Models["test"]
test2 := t2.(Test) // test2 is now of type Test

With the type assertion, the test2 variable now points to the Test struct, and you can print it like test1.

Alternatively, one can work with pointers to Test directly by storing *Test values in the map:

var Models = map[string]*Test{
    "test": newTest(),
}

This approach eliminates the need for type assertion and the wrapping in interface{}, thus avoiding the hexadecimal representation of the address.

The above is the detailed content of How Do Go's `fmt.Printf` and Pointer Types Interact, and Why Do They Produce Different Outputs for Different Pointer Types?. For more information, please follow other related articles on the PHP Chinese website!