When does golang use pointer methods?

func main() {    cat := New("little pig", "American Shorthair", "cat")    cat.SetName("monster") // (&cat).SetName("monster")    fmt.Printf("The cat: %s\n", cat)
    cat.SetNameOfCopy("little pig")    fmt.Printf("The cat: %s\n", cat)
}type Cat struct {    name           string // 名字。    scientificName string // 学名。    category       string // 动物学基本分类。}//构造一个cat实例func New(name, scientificName, category string) Cat {    return Cat{        name:           name,        scientificName: scientificName,        category:       category,    }}//传指针设置cat名字func (cat *Cat) SetName(name string) {    cat.name = name}//传入值func (cat Cat) SetNameOfCopy(name string) {    cat.name = name}func (cat Cat) String() string {    return fmt.Sprintf("%s (category: %s, name: %q)",        cat.scientificName, cat.category, cat.name)}

In this example, we set two methods for Cat, SetName is a method of passing pointers, and SetNameOfCopy is a method of passing values. The receiver type of the method SetName is Cat. The left side of Cat represents the pointer type of the Cat type. We can see by running the above example that the receiver of a value method is a copy of the value of the type to which the method belongs. The receiver of a pointer method, on the other hand, is a copy of the pointer value of the primitive value to which the method belongs. We modify the value pointed to by the copy in such a method, but it will definitely reflect the original value.

2) If you need to modify the instance, use the pointer. The pointer is similar to passing by reference. The scope will go to gc, of course, it is not absolute. For example, the return of the pointer from the inline function will not necessarily lead to heap allocation. The global variable memory of reference type in golang is allocated in On the heap, global variables of value type are allocated on the stack, and the built-in new and make, map, slice, etc. are allocated on the heap and must go to gc. The consequence of gc for intensive computing services is that a lot of CPU calculations are consumed on gc, which seriously affects performance.

Off topic: what is a stack?

Heap In programming, the heap is the memory that the application requests the operating system to allocate to itself when it is running. Take a C/C++ program as an example. When using it, we need to actively apply for it (through malloc/New) and use it up. Active release, or reclaimed by the operating system when the program ends, will result in memory fragmentation.

Stack (Stack) The stack (Stack) is a specific area of ​​computer memory, which is generally allocated and released automatically by the CPU. The data structure is characterized by first-in, first-out (FIFO—first in first out). Because the CPU organizes memory efficiently, reading and writing stack variables is very fast, and there is no memory fragmentation.

The difference between Heap and Stack

• The stack is generally allocated and released by the operating system, and the heap is applied for creation and release by the programmer through the programming language;

• The stack is used to store function parameters, return values, local variables, temporary contexts when the function is called, etc. As long as the data is local and occupies a certain space, it is generally stored in the Stack, otherwise it is placed in the Heap;

• The access speed of the stack is relatively faster than that of the heap;

• Generally speaking, Stack is exclusive to threads, and Heap is shared by threads;

• When the Stack is created, the size is determined, and the size of the Heap is indeterminate and can be increased freely;

In C/C++ threads, the default thread stack size on most architectures is about 2MB ~ 4MB. If the program runs hundreds or even thousands of threads at the same time, it will take up a lot of memory space and bring other extra overhead. The execution context is considered to be lightweight at design time, so it implements Goroutine as the execution context in user mode, and the minimum stack space is only 2KB. So very efficient.

To sum up, having more pointers does not necessarily increase performance. It may increase the pressure on gc, thereby reducing performance. If you need to modify the instance, use the pointer, and use the non-pointer version if you don't need it. If you are not sure what to use, you can use the pointer receive