cft
Become a CreatorSign inGet Started

POINTERS IN GO.

Pointers are objects e.g variables that link to the memory address of another variable. The memory address of a pointer contains the memory address to the referenced variable which often looks like…


user

Ukeje Chukwuemeriwo Goodness

4 months ago | 4 min read
Follow

TABLE OF CONTENTS

  • What are Pointers?.
  • Pass by Value and Pass by Reference.
  • Declaring Pointers in Go.
  • Referencing Pointers in Go.
  • Dereferencing Pointers in Go.
  • A pointers use case program

cat from giphy

Pointers are objects e.g variables that link to the memory address of another variable. The memory address of a pointer contains the memory address to the referenced variable which often looks like this 0xc00010230 .

Pointers are important in programming as they help us write more efficient clean code, helping us make references to various objects from various parts of a program and increase the performance of the program.

The process of creating a pointer variable is known as Referencing while the process of extracting the data the pointer holds is known as Dereferencing the pointer.

Pointers come in handy in Go when using objects like structs, arrays, maps. e.g wanting to update an object without making effects to the existing.

PASS BY VALUE & PASS BY REFERENCE

The two ways to declare variables are to Pass-by-value and Pass-by-reference.

  • Pass-by-value is the assignment of a value to a variable or parameter directly. i.e there data type passed does not refer to another variable.
  • Pass-by-reference is the assignment of a value by passing the address of the variable or parameter. This can be done using pointers.

DECLARING POINTERS IN GO.

Pointers are special data types in Go. A pointer datatype is given as * followed by the primitive datatype(e.g *int, *string e.t.c).

The syntax for declaring a pointer is as thus…

var pointerName *data_type

The specified data type of the pointer is that of the object the pointer is to refer to.

An example of pointer declaration is…

var num *int

REFERENCING POINTERS IN GO.

meme from giphy

Pointers are referenced in Go using the Ampersand (&) symbol.

The syntax for referencing a pointer in Go is…

var pointer_variable = &variable_name

or

pointer_variable := &variable_name

An example of pointer referencing is…

func pointer(){

a := "This is an actual variable that a pointer will link to"

pointer_a := &a

fmt.Println(pointer_a)

fmt.Println(reflect.TypeOf(pointer_a))

}

fmt.Println(pointer_a) outputs the memory address to the variable a . 

fmt.Println(reflect.TypeOf(pointer_a)) outputs the data type of pointer_a which is *string.

DEREFERENCING POINTERS IN GO.

Of course, the memory address of the variable or parameter isn’t that important in most cases, what is important is the value stored. 
To access the value stored in a pointer, we have to dereference it. 
Dereferencing pointers in go is done with the
Asterisk(*) symbol.

func pointer() {

a := 4

pointer_a := &a

fmt.Println(*pointer_a)

}

in the example above, pointer_a which refers to the variable a is dereferenced and output to the console as seen in the line of code fmt.Println(*pointer_a) .

POINTERS AND STRUCTS

A good use-case for pointers is in updating objects. 

Let us assume we are building a music app, we would often have to update stuff such as playlists, albums e.t.c. 

In the case of albums, most artists release a song or two before releasing the full album. In this case, we would want to add those songs to the album when they are out, but we won’t want to re-upload those songs since they also exist on our imaginary platform and that means more memory. 
If the album data is saved in a struct, we can easily update the album struct each time a new song rolls out or the artiste releases a
deluxe


We could take the following steps.

  • Create and initialize structs for albums.
  • Each struct contains songs in the album stored in a slice.
  • Use pointers to rename and update the contents of the album when new songs roll out


Creating the struct album and initializing with the songs datatype

type Album struct {

name string

songs_list []string

}

I created a struct Album and initialized it with the album name name
and a slice
songs_listfor the list of songs in the album.


func new_album(album_name string, number_of_songs int) Album {

var songsList = make([]string, number_of_songs)

album_details := Album{

name: album_name,

songs_list: songsList,

}

return

album_details

}

I created a function new_albumto create new instances of the struct. The function takes in two parameters which are the album name album_name and number of songs number_of_songs .

album_details creates an instance of the album type and sets the specified slice and album names. var songsList creates the slice as initialized.

The function returns the album details album_details which is an instance of the Album struct.

func (album_details *Album) update_songs(song_name string) []string

{

album_details.songs_list = append(album_details.songs_list, song_name)

return

album_details.songs_list

}

Using a pointer to the Album struct, I am able to update the contents(songs) in the album. 

The function update_songis a receiver function for the Album struct. The function receives the name of the song to be added to the slice and updates the slice by appending it using append(slice_name, value) method of the slice object. 

The function returns the list of songs in the album.

The full Program…

package mainimport "fmt"

func main() {

x := new_album("We are all alone in this together", 12)

x.update_songs("Verdansk")

x.update_songs("Clash")

fmt.Println(x)

}

type Album struct {

name string

songs_list []string }

func new_album(album_name string, number_of_songs int) Album {

var songsList = make([]string, number_of_songs)

album_details := Album{

name: album_name,

songs_list: songsList,}

return

album_details

}

func (album_details *Album) update_songs(song_name string) []string {

album_details.songs_list = append(album_details.songs_list, song_name)

return

album_details.songs_list

}

The Output…

>>> {We are all alone in this together [ Verdansk Clash]}

Pointers really come in handy in Go for so many uses. Have fun!



Looking to learn Go?

Check out my Golang beginners' guide here;

A BEGINNERS INTRODUCTION TO GO (GOLANG)

Connect with me on Twitter here



Upvote


user
Created by

Ukeje Chukwuemeriwo Goodness

Follow

Software Developer

I am a data analyst who writes about cryptocurrencies and decentralized ledger technologies. Find me on Twitter @Goodylili.


people
Post

Upvote

Downvote

Comment

Bookmark

Share


Related Articles