“ *”和“ &”是什么意思？

我在做 http://tour.golang.org/。谁能给我解释一下这个函数 第一，三，五，七行，特别是“ *”和“ &”做什么？通过在函数声明中提到它们，它们应该/期望做什么？一个玩具例子:

    1: func intial1(var1 int, var2 int, func1.newfunc[]) *callproperfunction {
2:
3:    addition:= make ([] add1, var1)
4:    for i:=1;i<var2;i++ {
5:       var2 [i] = *addtother (randomstring(lengthofcurrent))
6:    }
7:    return &callproperfunction {var1 int, var2 int, func1.newfunc[], jackpot}
8: }

看起来它们就像我们在 C + + 中使用的指针。但我无法将这些概念与我们现在所拥有的联系起来。换句话说，当我在 Go 中的函数声明中使用’*’和’&’时，它们的作用是什么。

我知道引用和解引用是什么意思。我不明白我们怎么能在 Go 中使用一个函数的指针？例如第1行和第7行，这两行是做什么的？声明了一个名为 intial1的函数，它返回一个指针？在第7行，我们使用 return 函数用参数调用它。

80635 次浏览
小开

Those are pointers like we have in C++.

The differences are:

  • Instead of -> to call a method on a pointer, you always use ., i.e. pointer.method().

  • There are no dangling pointers. It is perfectly valid to return a pointer to a local variable. Golang will ensure the lifetime of the object and garbage-collect it when it's no longer needed.

  • Pointers can be created with new() or by creating a object object{} and taking the address of it with &.

  • Golang does not allow pointer-arithmetic (arrays do not decay to pointers) and insecure casting. All downcasts will be checked using the runtime-type of the variable and either panic or return false as second return-value when the instance is of the wrong type, depending on whether you actually take the second return type or not.

小开

Your question doesn't match very well the example given but I'll try to be straightforward.

Let's suppose we have a variable named a which holds the integer 5 and another variable named p which is going to be a pointer. This is where the * and & come into the game.

Printing variables with them can generate different output, so it all depends on the situation and how well you use. The use of * and & can save you lines of code (that doesn't really matter in small projects) and make your code more beautiful/readable.

& returns the memory address of the following variable.

* returns the value of the following variable (which should hold the memory address of a variable, unless you want to get weird output and possibly problems because you're accessing your computer's RAM)

var a = 5
var p = &a // p holds variable a's memory address
fmt.Printf("Address of var a: %p\n", p)
fmt.Printf("Value of var a: %v\n", *p)


// Let's change a value (using the initial variable or the pointer)
*p = 3 // using pointer
a = 3 // using initial var


fmt.Printf("Address of var a: %p\n", p)
fmt.Printf("Value of var a: %v\n", *p)

All in all, when using * and & in remember that * is for setting the value of the variable you're pointing to and & is the address of the variable you're pointing to/want to point to.

Hope this answer helps.

小开
最佳答案

This is possibly one of the most confusing things in Go. There are basically 3 cases you need to understand:

The & Operator

& goes in front of a variable when you want to get that variable's memory address.

The * Operator

* goes in front of a variable that holds a memory address and resolves it (it is therefore the counterpart to the & operator). It goes and gets the thing that the pointer was pointing at, e.g. *myString.

myString := "Hi"
fmt.Println(*&myString)  // prints "Hi"

or more usefully, something like

myStructPointer = &myStruct
// ...
(*myStructPointer).someAttribute = "New Value"

* in front of a Type

When * is put in front of a type, e.g. *string, it becomes part of the type declaration, so you can say "this variable holds a pointer to a string". For example:

var str_pointer *string

So the confusing thing is that the * really gets used for 2 separate (albeit related) things. The star can be an operator or part of a type.

小开

& Operator gets the memory address where as * Opeartor holds the memory address of particular variable.

小开

This is by far the easiest way to understand all the three cases as explained in the @Everett answer

func zero(x int) {
x = 0
}
func main() {
x := 5
zero(x)
fmt.Println(x) // x is still 5
}

If you need a variable to be changed inside a function then pass the memory address as a parmeter and use the pointer of this memory address to change the variable permanently.

Observe the use of * in front of int in the example. Here it just represents the variable that is passed as a parameter is the address of type int.

func zero(xPtr *int) {
*xPtr = 0
}
func main() {
x := 5
zero(&x)
fmt.Println(x) // x is 0
}
小开

Simple explanation.. its just like, you want to mutate the original value

func zero(num *int){  // add * to datatype
*num = 0 // can mutate the original number
}


i := 5
zero(&i) // passing variable with & will allows other function to mutate the current value of variable```

提交答案