Why do Go's `fmt.Printf` outputs differ when printing pointers to structs and pointers to map values?

Pointers in Go: Understanding the Printf Formatting

In Go, pointers play a crucial role in passing variables by reference. However, their usage can sometimes lead to unexpected results, as seen in the code example provided. Let's delve into the details and resolve the discrepancies.

The Problem:

The code attempts to print two variables, one a pointer to a Test struct (&test1) and the other a value from a map (&test2). The issue arises when printing these values, as they produce different outputs.

The Explanation:

The key to understanding the discrepancy lies in the fmt.Printf function. This function takes a format string and a variable number of arguments of type interface{}. When passing a value that is not of type interface{}, it is automatically wrapped in an interface{} value.

In the first case, &test1 is of type *Test, and when passed to fmt.Printf, it is wrapped in an interface{} value. The default formatting for pointers is %p, which prints the hexadecimal address of the value. Hence, the output is "0xc00009e190".

In contrast, &test2 is of type *interface{}. When passed to fmt.Printf, it is wrapped in another interface{} value. The default formatting for interface{} values is %v and varies depending on the underlying type. In this case, the underlying type is a pointer to interface{}, and the %v format for pointers is %p. Therefore, the output is also a hexadecimal address, but for the address of the *interface{} value, hence "0xc00029c0a0".

The Solution:

To obtain a struct value from test2, type assertion can be used. This essentially assumes that the value stored in test2 is a Test struct and casts it appropriately.

test2 := Models["test"].(Test)

With this modification, test2 will be of type Test, and when passed to fmt.Printf, it will produce the same output as &test1.

Best Practice:

It is generally recommended to store *Test values in the map directly to avoid the need for type assertions or intermediate variable declarations. This ensures that the interface values stored in the map are already pointers to Test, which can be used and passed around as-is.

The above is the detailed content of Why do Go's `fmt.Printf` outputs differ when printing pointers to structs and pointers to map values?. For more information, please follow other related articles on the PHP Chinese website!