{"id":56478,"date":"2023-01-23T20:11:07","date_gmt":"2023-01-23T14:41:07","guid":{"rendered":"https:\/\/www.tothenew.com\/blog\/?p=56478"},"modified":"2024-01-02T17:41:54","modified_gmt":"2024-01-02T12:11:54","slug":"go-pointers-lets-talk-about-it","status":"publish","type":"post","link":"https:\/\/www.tothenew.com\/blog\/go-pointers-lets-talk-about-it\/","title":{"rendered":"Go Pointers! Let\u2019s talk about it\u2026"},"content":{"rendered":"

<\/p>\n

A pointer<\/strong>, as name suggests, is a variable that points to a location in the memory of your system where a value is stored rather than a value itself. Basically, it is an address to the value stored in memory. The definition is simple but this concept can be a little tricky to wrap your head around.<\/p>\n

When I first developed a good understanding of pointers in Go, I asked myself, \u201cHow can I explain this concept to a 5-year-old?\u201d Well, I don\u2019t know if I can find words to explain this to a 5 year old, but I will still attempt to give you a simplistic and comprehensive understanding.<\/p>\n

Let\u2019s write a small piece of code:<\/p>\n

package<\/span> main\r\n\r\nimport<\/span> \"fmt\"<\/span>\r\n\r\ntype<\/span> animal struct<\/span> {\r\nname string<\/span>\r\nsound string<\/span>\r\n}\r\n\r\nfunc<\/span> main<\/span>()<\/span><\/span> {\r\nmyAnimal := animal{\r\nname: \"Cat\"<\/span>,\r\nsound: \"Meeeaaawwwwww\"<\/span>,\r\n}\r\n\r\nmyAnimal.updateAttributes(\"Cow\"<\/span>, \"Mooooooooo\"<\/span>)\r\n\r\nmyAnimal.print<\/span>(\"Updated Structure\"<\/span>)\r\n}\r\n\r\nfunc<\/span> (p animal)<\/span><\/span> updateAttributes(newName string<\/span>, sound string<\/span>) {\r\np.name = newName\r\np.sound = sound\r\n}\r\n\r\nfunc<\/span> (p animal)<\/span><\/span> print<\/span>(text string<\/span>) {\r\nresult := fmt.Sprintf(\"%s ==> %+v \\n \\n\"<\/span>, text, p)\r\nfmt.Printf(\"%+v\"<\/span>, result)\r\n}<\/pre>\n
Let\u2019s break this down:<\/p>\n
    \n
  1. We are creating an animal,\u00a0cat<\/code>\u00a0which has attributes defined in type\u00a0animal<\/code>\u00a0.<\/li>\n
  2. Now, I want to update\u00a0myAnimal<\/code>\u00a0from a\u00a0cat<\/code>\u00a0to a\u00a0cow<\/code>. To do so, I am calling my receiver function\u00a0cat.updateAttributes(\"cow\", \"mooooooooo\")<\/code>\u00a0to update the attributes\u00a0name<\/code>\u00a0and\u00a0sound<\/code>\u00a0.<\/li>\n
  3. Finally, I have invoked another receiver function\u00a0print<\/code>\u00a0to print my updated animal.<\/li>\n<\/ol>\n
    Let\u2019s run our go module using\u00a0go run .<\/code>:<\/p>\n
    \/\/Output:\r\n\r\nUpdated Structure ==> {\r\nname:Cat \r\nsound:Meeeaaawwwwww \r\nzooInfo:{\r\ntown:California \r\nemail:abc@xyz.com \r\npinCode:12345\r\n\u00a0 }\r\n}<\/pre>\n
    Wooops\u2026 as you can see, my animal is still a cat<\/code>.<\/p>\n
    Let\u2019s see what gets printed inside the receiver function:<\/p>\n
    func<\/span> (p animal)<\/span><\/span> updateAttributes(newName string<\/span>, sound string<\/span>) {\r\np.name = newName\r\np.sound = sound\r\n\r\n\/\/ Let's call the print command here!<\/span>\r\np.print<\/span>(\"Tadaaa\"<\/span>)\r\n}\r\n\r\n\/\/Output<\/span>\r\nTadaaaa ==> {\r\nname:cow \r\nsound:Mooooooooo \r\n}<\/pre>\n
    Here is what happens in the background:<\/strong><\/h3>\n
    <\/p>\n
    In nutshell, Go creates an entirely new\u00a0struct<\/code>\u00a0when a\u00a0myAnimal<\/code>\u00a0is passed from one function to another and\u00a0p<\/code>\u00a0, the receiver function argument becomes a new\u00a0struct<\/code>\u00a0altogether.<\/p>\n
    In other words,\u00a0p<\/code>\u00a0has its value stored in a different memory location than\u00a0myAnimal<\/code>\u00a0.<\/em><\/p><\/blockquote>\n
    For making changes in the original\u00a0struct<\/code>\u00a0, we can use\u00a0*<\/code>\u00a0and\u00a0&<\/code>\u00a0operators.<\/p>\n
    The \u2018*\u2019 and \u2018&\u2019 operator<\/strong><\/h2>\n
    Let\u2019s modify our main function and receiver function updateAttributes a bit:<\/p>\n
    func<\/span> main<\/span>()<\/span><\/span> {\r\nmyAnimal := animal{\r\nname: \"Cat\"<\/span>,\r\nsound: \"Meeeaaawwwwww\"<\/span>,\r\n}\r\n\r\n\/\/STEP#1. Print the original struct myAnimal<\/span>\r\nmyAnimal.print<\/span>(\"Original Structure\"<\/span>)\r\n\r\n\/\/STEP#2. Create a pointer<\/span>\r\nmyAnimalPointer := &myAnimal\r\n\r\n\/\/STEP#3. myAnimalPointer will still have access<\/span>\r\n\/\/to receiver functions of myAnimal.<\/span>\r\n\/\/So let's update myAnimalPointer value attributes<\/span>\r\nmyAnimalPointer.updateAttributes(\"Dog\"<\/span>, \"Woof Woof Woof\"<\/span>)\r\n\r\n\/\/STEP#4. Print the myAnimal values and see if the <\/span>\r\n\/\/original struct values changed<\/span>\r\nmyAnimal.print<\/span>(\"Updated Struct\"<\/span>)\r\n}\r\n\r\n\/\/STEP#3.1: We'll access the value attributes using * operator <\/span>\r\n\/\/and make the changes in the orginal struct value<\/span>\r\nfunc<\/span> (p *animal)<\/span><\/span> updateAttributes(newName string<\/span>, sound string<\/span>) {\r\n(*p).name = newName\r\n(*p).sound = sound\r\n}<\/pre>\n
    Let\u2019s talk about \u201cmain\u201d function: Creation of a pointer<\/strong><\/h3>\n
    myAnimal := animal{\r\nname: \"Cat\"<\/span>,\r\nsound: \"Meeeaaawwwwww\"<\/span>\r\n}\r\n\r\nmyAnimalPointer := &myAnimal\r\nmyAnimalPointer.updateAttributes<\/span>(\"Dog\"<\/span>, \"Woof Woof Woof\"<\/span>)\r\n\r\n\/\/OR We can simply do something like \r\n(&myAnimal).updateAttributes<\/span>(\"Dog\"<\/span>, \"Woof Woof Woof\"<\/span>) \/\/Same thing!\r\n\r\nmyAnimal.print<\/span>(\"Updated Struct\"<\/span>)\r\n}<\/pre>\n
    Using the\u00a0&<\/code>operator, we can create a pointer and we can get the address in memory where the value of the\u00a0myAnimal<\/code>\u00a0is stored. We have assigned\u00a0&myAnimal<\/code>\u00a0pointer to\u00a0myAnimalPointer<\/code>\u00a0variable.<\/p>\n
    Let\u2019s talk about the receiver function \u201cupdateAttributes\u201d : Retrieving value from the pointer<\/strong><\/h3>\n
    func<\/span> (p *animal)<\/span><\/span> updateAttributes(newName string<\/span>, sound string<\/span>) {\r\n(*p).name = newName\r\n(*p).sound = sound\r\n}<\/pre>\n
    p<\/code>\u00a0is the pointer that function receives when invoked.<\/p>\n
    *animal<\/code>\u00a0is not a pointer but a mere description of what this function expects when invoked.<\/p>\n
    The value in memory that pointer\u00a0p<\/code>\u00a0references to, can be accessed using the\u00a0*<\/strong><\/code>\u00a0operator.<\/p>\n
    Using brackets,\u00a0(*p)<\/code>, will give you the access to the\u00a0struct<\/code>\u00a0attributes.<\/p>\n
    <\/p>\n
    Let\u2019s run the code again:<\/p>\n
    go<\/span> run .\r\n\r\n\/\/Output<\/span>\r\nOriginal Structure ==> {name:Cat sound:Meeeaaawwwwww}\r\n\r\nUpdated Struct ==> {name:Dog sound:Woof Woof Woof}<\/pre>\n
    Woohooo ?\u2026 we have updated the original struct myAnimal with the power of pointers.<\/p>\n
    A Gotcha moment\u2026<\/strong><\/h2>\n
    \u201cabracadabra\u201d, let the code appear\u2026<\/p>\n
    func<\/span> main<\/span>()<\/span><\/span> {\r\nmyAnimal := animal{\r\nname: \"Cat\"<\/span>,\r\nsound: \"Meeeaaawwwwww\"<\/span>,\r\n}\r\nmyAnimal.print<\/span>(\"Original Structure\"<\/span>)\r\n\r\n\/\/Let's comment the 2 lines below<\/span>\r\n\r\n\/\/myAnimalPointer := &myAnimal<\/span>\r\n\/\/myAnimalPointer.updateAttributes(\"Dog\", \"Woof Woof Woof\")<\/span>\r\n\r\n\/\/Let's use our same old myAnimal struct without creating a pointer <\/span>\r\nmyAnimal.updateAttributes(\"Dog\"<\/span>, \"Woof Woof Woof\"<\/span>)\r\n\r\nmyAnimal.print<\/span>(\"Updated Struct\"<\/span>)\r\n}\r\n\r\nfunc<\/span> (p *animal)<\/span><\/span> updateAttributes(newName string<\/span>, sound string<\/span>) {\r\n(*p).name = newName\r\n(*p).sound = sound\r\n}<\/pre>\n
    Go automatically takes care of pointer creation in the background so that you don\u2019t have to. And that\u2019s how, you will get the same result:<\/p>\n
    go<\/span> run .\r\n\r\nOriginal Structure ==> {name:Cat sound:Meeeaaawwwwww}\r\n\r\nUpdated Struct ==> {name:Dog sound:Woof Woof Woof}\r\n\r\n<\/pre>\n
    The new Keyword<\/strong><\/h2>\n
    Lets create a pointer using a\u00a0new<\/code>\u00a0keyword:<\/p>\n
    package<\/span> main\r\n\r\nimport<\/span> \"fmt\"<\/span>\r\n\r\ntype<\/span> animal struct<\/span> {\r\nname string<\/span>\r\nsound string<\/span>\r\n}\r\n\r\nfunc<\/span> (p *animal)<\/span><\/span> updateAttributes(newName string<\/span>, sound string<\/span>) {\r\n(*p).name = newName\r\n(*p).sound = sound\r\n}\r\n\r\nfunc<\/span> main<\/span>()<\/span><\/span> {\r\n\/\/ LOOK OVER HERE!!!<\/span>\r\n\r\nmyAnimal := new<\/span>(animal)\r\nmyAnimal.updateAttributes(\"Dog\"<\/span>, \"Woof Woof Woof\"<\/span>)\r\nfmt.Printf(\"%+v\"<\/span>, *myAnimal)\r\n\r\n}\r\n\r\n\r\n\/\/Output:<\/span>\r\n{name:Dog sound:Woof Woof Woof}%<\/pre>\n
    \n
    Official Definition:<\/strong><\/em><\/p>\n
    The\u00a0new<\/code>\u00a0takes type as an argument, allocates enough memory to fit a value of that type and returns a pointer to it.<\/em><\/p>\n<\/blockquote>\n
    I hope, I was able to make this concept a little easier to grasp for all my lovely readers and followers like yourself. If you feel, something can be improved, please drop a comment and I will look into it.<\/p>\n
    Have a lovely day!<\/p>\n
    . . .<\/p>\n
    Note of thanks \u2764\ufe0f<\/strong><\/p>\n
    <\/p>\n
    Thank you for stopping by. Hope, you find this article useful. Please follow me<\/em><\/strong><\/a>\u00a0on medium and help me reach 1k followers ??. That will truly encourage me to put out more content.<\/p>\n
    P.S.: If you feel something can be improved or lacks proper explanation, drop me a note in the comment box or mail me at\u00a0shiva.chaturvedi91@gmail.com<\/a>. After all, you can teach me a thing or two as well.<\/em><\/p><\/blockquote>\n
     <\/p>\n
    <\/div>","protected":false},"excerpt":{"rendered":"
    A pointer, as name suggests, is a variable that points to a location in the memory of your system where a value is stored rather than a value itself. Basically, it is an address to the value stored in memory. The definition is simple but this concept can be a little tricky to wrap your […]<\/p>\n","protected":false},"author":1535,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"iawp_total_views":5},"categories":[4112,1994,1],"tags":[5084,1787,1471,1470,1472,5085,2591],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/56478"}],"collection":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/users\/1535"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/comments?post=56478"}],"version-history":[{"count":3,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/56478\/revisions"}],"predecessor-version":[{"id":59767,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/56478\/revisions\/59767"}],"wp:attachment":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/media?parent=56478"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/categories?post=56478"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/tags?post=56478"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}