Maison >développement back-end >Golang >Qu'est-ce qu'un pointeur Go ? Quels sont les points de connaissances à maîtriser ?
Qu'est-ce qu'un pointeur Go ? Quels sont les points de connaissances à maîtriser ?
- 藏色散人avant
- 2021-09-17 16:28:322301parcourir
Cet article est introduit par la colonne tutoriel go language pour présenter 11 points de connaissances sur Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ? Pointer. J'espère qu'il sera utile aux amis dans le besoin !
2. Syntaxe du pointeur Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?LangLa syntaxe des pointeurs est très simple. Voici la syntaxe de déclaration du pointeur dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?. La valeur zéro du pointeur
var ptr *typevar ptrint *int // 指向 int 的指针
est nil
.
3. Initialisation des pointeurs dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?
les pointeurs de type sont initialisés à l'aide de& :
package mainimport (
"fmt")func main() {
var q int = 42
var p *int // declare the pointer
p = &q // initialize the pointer
fmt.Println(p) // 0x40e020}
4. adresse. Voici un exemple d'utilisation de l'opérateur * pour effectuer une opération sur la valeur du pointeur :
package mainimport (
"fmt")func main() {
var q int = 42
var p *int
p = &q
fmt.Println(p) // 0x40e020
fmt.Println(*p) // 42}
& 对其进行初始化：package mainimport (
"fmt")func main() {
i := 64
j := &i // j 是 int 类型的指针
k := &j // k 是存放指针地址的指针，也是 int 类型
fmt.Println(i) // 64
fmt.Println(j) // 0x40e020
fmt.Println(*j) // 64 (value inside that address)
fmt.Println(k) // 0x40c138
fmt.Println(*k) // 0x40e020 (address of j)}
4. Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ? 指针取值
指针取值意味着获取指针保存的地址内的值。下面是使用 * 运算符执行指针取值操作的示例：
package mainimport (
"fmt")func main() {
var a interface{}
b := &a
fmt.Println(b) // 0x40c138
fmt.Println(*b) // <nil>}</nil>
5. Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?Lang 中指针的指针
指针的地址为一个数值，此数值也可以被赋值给其他变量。因此，我们可以创建间接级别。这些间接级别有时会产生不必要的混淆，所以请谨慎使用。
package mainimport (
"fmt")// 定义接口type Bird interface{
fly()}type B struct{
name string}// 实现它func (b B)fly() {
fmt.Println("Flying...")}func main() {
var a Bird = B{"Peacock"}
b := &a
fmt.Println(b) // 0x40c138
fmt.Println(*b) // {Peacock}}
6. 指向接口的指针
指针可以指向任何东西，甚至可以指向接口。当使用空接口时，返回的值为 nil。
package mainimport (
"fmt")//声明指针参数func f(a *int) {
fmt.Println(*a)}func main() {
var a int = 42
// 传递地址
f(&a) // 42}
下面是一个使用带有指针接口的例子。
package mainimport (
"fmt")type Human struct {
name string
age int
place string}func f(h *Human) {
fmt.Println("The user", (*h).name, "is", (*h).age, "years old and he is from", (*h).place)}func main() {
john := Human{"John", 36, "Las Vegas"}
f(&john) // The user John is 36 years old and he is from Las Vegas}
这里 “a” 是一个 struct 类型的 Bird，然后用于接口类型，如您所见。这就是多态的使用。Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ? 允许使用 接口来实现多态. 因此，您可以看到指向结构或接口的指针是 Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ? 中必不可少的工具。
7. 指针作为函数参数
指针可以在 函数 中作为参数使用。与直接使用值相比，它有一些优势。使用指针作为参数是将大对象传递给函数的一种非常有效的方式。因此，使用它是一个巨大的优化。
package mainimport (
"fmt")func main() {
ptri := new(int)
*ptri = 67
fmt.Println(ptri) // 0x40e020
fmt.Println(*ptri) // 67}
使用大型对象可以减缓执行时间，这是将指针传递给结构体的示例。这是处理大对象的有效方法。
package mainimport (
"fmt")func p() *int { // 将返回类型指定为指针
v := 101
// 返回地址
return &v}func main() {
n := p()
fmt.Println(n) // 0x40e020
fmt.Println(*n) // 101}
取消引用结构时要小心。如果您使用它像*structname.field1那么它会抛出错误。 正确的方法是(*structname).field1
5 Le pointeur du pointeur dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?LangL'adresse du pointeur est une valeur numérique, et cette valeur peut également être attribuée à d'autres valeurs variables. Nous pouvons donc créer des niveaux d’indirection. Ces niveaux d’indirection peuvent parfois créer une confusion inutile, alors utilisez-les avec prudence.
package mainimport (
"fmt")func main() {
f := func() {
fmt.Println("a function")
}
pf := f pf() // 一个函数}
6. Pointeurs vers des interfaces
Les pointeurs peuvent pointer vers n'importe quoi, même vers des interfaces. Lors de l'utilisation de l'interface vide, la valeur renvoyée est nil.
rrreeeCe qui suit est un exemple d'utilisation d'une interface avec des pointeurs. rrreeeIci
"a"est un type de structure Bird qui est ensuite utilisé pour le type d'interface comme vous pouvez le voir. C'est l'utilisation du polymorphisme. Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ? permet le polymorphisme à l'aide d'interfaces. Vous pouvez donc voir que les pointeurs vers des structures ou des interfaces sont un outil essentiel dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?.
7. Pointeurs comme paramètres de fonction
Les pointeurs peuvent être utilisés comme paramètres dans les fonctions. Cela présente certains avantages par rapport à l'utilisation directe des valeurs. Utiliser des pointeurs comme arguments est un moyen très efficace de transmettre des objets volumineux aux fonctions. Son utilisation est donc une énorme optimisation.
rrreeeL'utilisation d'objets volumineux peut ralentir le temps d'exécution, voici un exemple de passage d'un pointeur vers une structure. C'est un moyen efficace de gérer des objets volumineux. rrreeeSoyez prudent lorsque vous déréférencez des structures. Si vous l'utilisez comme *structname.field1 alors il générera une erreur.
La bonneméthode est (*structname).field1.
mutable8. La fonction "nouvelle" dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ? 🎜🎜La fonction 🎜nouvelle🎜 dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ? renvoie un pointeur vers un type. 🎜rrreee🎜🎜🎜9. Renvoi de pointeurs à partir de fonctions 🎜🎜 Tout type de pointeur peut être renvoyé à partir d'une fonction, tout comme les autres valeurs. C'est vraiment simple. Nous ne renvoyons pas directement la valeur, mais l'adresse de la valeur. 🎜rrreee🎜🎜🎜10. Pointeurs vers des fonctions🎜🎜Les pointeurs vers des fonctions fonctionnent implicitement dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?. Cela signifie que nous n'avons pas besoin de le déclarer comme pointeur. 🎜rrreee🎜🎜🎜11. Choses à retenir lors de l'utilisation de pointeurs dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?🎜🎜L'arithmétique des pointeurs n'est pas autorisée dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?. Par conséquent, nous ne pouvons pas effectuer d’opérations telles que l’incrémentation ou la décrémentation unaire comme nous le pouvons en C/C++. 🎜Nous souhaiterions peut-être utiliser un pointeur vers un tableau, mais utiliser une tranche est une meilleure option. Les tranches sont beaucoup plus polyvalentes que les pointeurs vers des tableaux. Le code est très concis et facilite notre travail. Par conséquent, utilisez des tranches autant que possible. 🎜🎜🎜Adresse originale : https://golangdocs.com/pointers-in-golang🎜🎜Adresse de traduction : https://learnku.com/go/t/60880🎜🎜" à moins que son paramètre ne soit const, donc chaque fois que nous voulons modifier une valeur, nous devons utiliser un pointeur vers cette valeur comme paramètre de fonction, puis effectuer les modifications nécessaires.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!