{"id":251,"date":"2024-09-14T10:59:34","date_gmt":"2024-09-14T03:59:34","guid":{"rendered":"https:\/\/gotutorial.org\/?page_id=251"},"modified":"2024-09-14T11:14:53","modified_gmt":"2024-09-14T04:14:53","slug":"go-pointers","status":"publish","type":"page","link":"https:\/\/www.gotutorial.org\/go-tutorial\/go-pointers\/","title":{"rendered":"Go Pointers"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you will learn about Go pointers and how to use them effectively.<\/p>\n\n\n\n

Introduction to Go pointers<\/h2>\n\n\n\n

The following declares a variable<\/a> x<\/code> and initialize its value to 10:<\/p>\n\n\n

var<\/span> x int<\/span> = 10<\/span><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
In the computer memory, Go places the variable x<\/code> at a memory address 0xc00000a0f8<\/code> and add the number 10<\/code> to this memory location.<\/p>\n\n\n\n
Note that the memory address of the variable x<\/code> on your computer may be different. Additionally, it may be changed when you restart the program.<\/p>\n\n\n\n
To get the memory address of the variable x<\/code>, you can use the &<\/code> operator:<\/p>\n\n\n
&x<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
For example:<\/p>\n\n\n
package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n\tvar<\/span> x int<\/span> = 10<\/span>\n\tfmt.Println(&x)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
0xc00000a0f8<\/span><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
In Go, a pointer is a variable that stores the memory address of another variable<\/strong>. To declare a pointer, you use the following syntax:<\/p>\n\n\n
var<\/span> pointer *type<\/span><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
In this syntax:<\/p>\n\n\n\n
    \n
  • var<\/code>: var keyword to indicate that a variable declaration.<\/li>\n\n\n\n
  • pointer<\/code>: specifies the pointer variable name.<\/li>\n\n\n\n
  • *type<\/code>: specifies the type of variable that the pointer will point to. Like a regular variable, a pointer has a type, meaning that it can point to only a variable with the type specified in the declaration.<\/li>\n<\/ul>\n\n\n\n
    For example, to declare a pointer that points to an integer variable, you use the following statement:<\/p>\n\n\n
    var<\/span> px *int<\/span><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    The px<\/code> is an integer pointer. It can point to a variable of type integer only.<\/p>\n\n\n\n
    When you declare a pointer without initialization, its value is nil. The nil indicates that the pointer does not point to any variable.<\/p>\n\n\n
    package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n\tvar<\/span> px *int<\/span>\n\tfmt.Println(px)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    <nil<\/span>><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    The following shows how to declare a pointer px and point it to x variable:<\/p>\n\n\n
    package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n\tx := 10<\/span>\n\tfmt.Println(\"The memory addres of x is\"<\/span>, &x)\n\n\tvar<\/span> px *int<\/span> = &x\n\tfmt.Println(\"The value of pointer px is\"<\/span>, px)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    The memory addres of x is 0xc00000a0f8<\/span>\nThe value of pointer px is 0xc00000a0f8<\/span><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    How it works.<\/p>\n\n\n\n
    First, declare and initialize the variable x to 10:<\/p>\n\n\n
    x := 10<\/span><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Second, display the memory address of x:<\/p>\n\n\n
    fmt.Println(&x)<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Third, declare a pointer px and initialize its value to the memory address of x:<\/p>\n\n\n
    var<\/span> px *int<\/span> = &x<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Finally, display the value of the pointer px:<\/p>\n\n\n
    fmt.Println(px)<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    The value of the pointer is the same as the memory address of variable x.<\/p>\n\n\n\n
    Dereference pointers<\/h2>\n\n\n\n
    To get the value of the variable that the pointer points to, you use the * operator:<\/p>\n\n\n
    package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n\tx := 10<\/span>\n\tvar<\/span> px *int<\/span> = &x\n\tfmt.Println(\"The value of x is\"<\/span>, *px)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    The value of x is 10<\/span><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this example, we access the value of x via the pointer using the * operator.<\/p>\n\n\n\n
    Additionally, you can change the value of the variable x via the pointer using the * operator:<\/p>\n\n\n
    package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n\tx := 10<\/span>\n\tvar<\/span> px *int<\/span> = &x\n\tfmt.Println(\"The value of x is\"<\/span>, *px)\n\n\t*px = 20<\/span>\n\tfmt.Println(\"The value of x is\"<\/span>, x)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    The value of x is 10<\/span>\nThe value of x is 20<\/span><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    The * operator<\/h3>\n\n\n\n
    When you place the * operator before a type such as int, you declare a pointer:<\/p>\n\n\n
    var<\/span> px *int<\/span><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    But when you place the * operator before a pointer, you dereference that pointer. In other words, you access the value of the variable to which the pointer points to:<\/p>\n\n\n
    *px<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Passing by value<\/h2>\n\n\n\n
    The following program attempts to increase the value of the variable x by one:<\/p>\n\n\n
    package<\/span> main\n\nfunc<\/span> addOne<\/span>(x int<\/span>)<\/span><\/span> {\n\tx = x + 1<\/span>\n}\nfunc<\/span> main<\/span>()<\/span><\/span> {\n\tx := 10<\/span>\n\taddOne(x)\n\tprintln<\/span>(x)\n}\n<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    10<\/code><\/span><\/pre>\n\n\n
    How it works.<\/p>\n\n\n\n
    First, define a function addOne that adds one to an argument:<\/p>\n\n\n
    func<\/span> addOne<\/span>(x int<\/span>)<\/span><\/span> {\n\tx = x + 1<\/span>\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Second, declare a variable x and initialize its value to 10:<\/p>\n\n\n
    x := 10<\/span><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Third, call the addOne function to add 1 to the variable x:<\/p>\n\n\n
    addOne(x)<\/code><\/span><\/pre>\n\n\n
    Finally, display the value of the variable x:<\/p>\n\n\n
    println<\/span>(x)<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    It doesn’t work as expected.<\/p>\n\n\n\n
    The reason is that when we pass an argument to a function, Go creates a copy of that argument inside the function.  In this example, x inside the addOne() is different from the x inside the main function.<\/p>\n\n\n\n
    When we change the x inside the addOne() function, we change the copy of x, not change the value of the original x argument:<\/p>\n\n\n
    x = x + 1<\/span><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    When the addOne()<\/code> function returns, the value of x<\/code> inside the main()<\/code> function remains intact.<\/p>\n\n\n\n
    To solve this issue, you can use a pointer as follows:<\/p>\n\n\n
    package<\/span> main\n\nfunc<\/span> addOne<\/span>(px *int<\/span>)<\/span><\/span> {\n\t*px = *px + 1<\/span>\n}\nfunc<\/span> main<\/span>()<\/span><\/span> {\n\tx := 10<\/span>\n\taddOne(&x)\n\tprintln<\/span>(x)\n}\n<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    11<\/code><\/span><\/pre>\n\n\n
    How it works.<\/p>\n\n\n\n
    First, change the x argument to an integer pointer px:<\/p>\n\n\n
    func addOne(px *int) {\n\t*px = *px + 1\n}<\/code><\/span><\/pre>\n\n\n
    Inside the addOne()<\/code> function, we add one to the value of the variable that px<\/code> pointer points to.<\/p>\n\n\n\n
    Second, pass the memory address of the x variable to the addOne()<\/code> function:<\/p>\n\n\n
    addOne(&x)<\/code><\/span><\/pre>\n\n\n
    In other words, we pass a pointer that points to the x variable to the addOne()<\/code> function. In this case, the addOne()<\/code> function creates a copy of the px<\/code> pointer. <\/p>\n\n\n\n
    However, this pointer still points to the x<\/code> variable inside the main function:<\/p>\n\n\n\n
    When we increase the value of *px<\/code> by one inside the addOne()<\/code> function, it changes the value of the x<\/code> variable:<\/p>\n\n\n
    *px = *px + 1<\/code><\/span><\/pre>\n\n\n
    Therefore, the change is reflected in the main()<\/code> function.<\/p>\n\n\n\n
    Summary<\/h2>\n\n\n\n
      \n
    • A pointer is a variable that stores the memory address of another variable.<\/li>\n\n\n\n
    • Use a pointer to directly access and change the value stored at a particular memory location.<\/li>\n\n\n\n
    • Go passes arguments to functions by values.<\/li>\n<\/ul>\n
      \n\t
      Was this tutorial helpful?<\/div>\n\t
      \n\t\t\n\t\t\t\n\t\t\t\t<\/path>\n\t\t\t<\/svg>\n\t\t\t Yes <\/span>\n\t\t<\/button>\n\n\t\t\n\t\t\t\n\t\t\t\t<\/path>\n\t\t\t<\/svg>\n\t\t\t No <\/span>\n\t\t<\/button>\n\t<\/div>\n\n\t
      \n\t\t
      \n\t\t\t
      <\/div>\n\t\t\t