去领导教程-DEV365 开发者社区

本文是基于上周关于GO的上周的生命，在这里我将用文本和访问源代码进行解释（因此我们不必复制屏幕，我知道：D）。如果您发现它，可以给它喜欢，分享，评论等。

指针简介

指针与编译器保留存储位置以存储信息的变量不同，它们没有保留的内存位置，并且可以指向我们指出的内存位置。

例如，在下面的示例中，我们声明了一个称为“ V”的变量，其值是“ 4”，然后在屏幕上打印了变量的值及其内存位置（使用'＆'符号，我们访问变量的内存位置）。之后，我们声明了指向变量'v'的内存位置的指针“ p”，然后分配了另一个值（使用符号'*'我们访问指针内存的位置的值）。

var v int = 4
var p *int

fmt.Printf( "El valor de v es %d \n", v )
fmt.Printf( "La posición de memória de v es %v \n", &v )

p = &v
*p = 8

fmt.Printf( "El valor de p es %d \n", *p )
fmt.Printf( "La posición de memória de p es %v \n", p )

通过验证者的通过以进行价值

使用指针的应用之一是通过参考将变量传递给函数。当我们将参数传递给“值”编译器的函数时，它的作用就是保留该参数的内存位置并复制值。如果我们这样做是为了“引用”，也就是说，使用指针，我们使用的是相同的内存位置，因此，它会更加推动。

我们在void中以此为例：

package main

import "fmt"

func main() {
    var v int = 4
    var p *int

    p = &v
    *p = 8

    IncValor( v )
    IncReferencia( &v )

    fmt.Printf( "El valor de v es %d \n", v )
    fmt.Printf( "La posición de memória de v es %v \n", &v )

        fmt.Printf( "El valor de p es %d \n", *p )
        fmt.Printf( "La posición de memória de p es %v \n", p )
}

func IncValor( v int  ) {
    v++
    fmt.Printf( "El valor incrementado(Por valor) es %d \n", v )
    }

func IncReferencia( v *int ) {
    *v++
    fmt.Printf( "El valor incrementado(Por referencia) es %d \n", *v )
    }

带有指针的列表

证明其功率的指针的另一种应用是创建数据结构。在空白中，我们创建了一个客户的crud（创建taad-update-delte）：

package main

import "fmt"

type Cliente struct {
    nombre string
    telefono string
    next *Cliente
}

var primerCliente *Cliente

func main() {
    AddCliente( "Pepe", "555 555 555" )
        AddCliente( "Juan", "555 555 556" )
        AddCliente( "Rodrigo", "555 555 557" )
        AddCliente( "David", "555 555 558" )

    ListaClientes()

    var cliente *Cliente = GetCliente(2)
    (*cliente).nombre = "Albert"

    fmt.Printf( "\nClientes Update\n" )
    ListaClientes()

    DeleteCliente( 2 )
    fmt.Printf( "\nClientes Delete\n" )
        ListaClientes()
    }

func AddCliente(nombre string, telefono string) {
    var cliente = Cliente{
        nombre:   nombre,
        telefono: telefono,
        next:     nil,
    }

    if primerCliente == nil {
        primerCliente = &cliente

        return
    }

    var nextCliente *Cliente = primerCliente
    for nextCliente.next != nil {
        nextCliente = nextCliente.next
    }

    nextCliente.next = &cliente
}

func ListaClientes() {
    if primerCliente == nil {
        return
    }

    var nextCliente *Cliente = primerCliente
    for nextCliente.next != nil {
        fmt.Printf("Nombre: %s Teléfono: %s \n", nextCliente.nombre, nextCliente.telefono)

        nextCliente = nextCliente.next
    }

    fmt.Printf("Nombre: %s Teléfono: %s \n", nextCliente.nombre, nextCliente.telefono)
}

func GetCliente(pos int) *Cliente {
    if primerCliente == nil {
        return nil
    }

    var nextCliente *Cliente = primerCliente
    i := 0
    for i < pos && nextCliente.next != nil {
        nextCliente = nextCliente.next
        i++
    }

    if i != pos {
        return nil
    }

    return nextCliente
}

func DeleteCliente(pos int) {
    if primerCliente == nil {
        return
    }

    if pos == 0 {
        if primerCliente.next == nil {
            primerCliente = nil

            return
        }

        primerCliente = primerCliente.next
        return
    }

    var cliente *Cliente = GetCliente(pos)
    var previo *Cliente = GetCliente(pos - 1)
    if cliente == nil || previo == nil {
        return
    }

    previo.next = cliente.next
}

在示例中，我们创建了一个结构来存储客户，在该客户也有一个指向下一个客户端的指针。通过这种方式，我们可以从第一个旅行到客户直到找到最后一个（“下一个”指针没有价值），并且要从列表中删除一个，您只需要从链条中删除它（如果是GO，与C不同，不必释放内存，因为它仅使用垃圾收集器进行）。

我们可以针对不同的使用情况优化示例：使用两个指针（一个用于下一个指针，另一项用于前一个指针，以及两个方向上的列表），另一个指针指向列表的结尾，另一种指向指针在列表的一半中，用指针使用迷人订购记录等。

无论如何，我希望您喜欢这些内容，并且一直很喜欢。合作的最佳方法是给他喜欢，评论和分享，看看我们是否使这个社交网络充满了西班牙裔的内容...