Όπως πολλές άλλες γλώσσες, έτσι και η Go έχει δείκτες.
Αν οι δείκτες είναι κάτι καινούριο για σένα, μπορεί να σου φανούν λίγο μυστηριώδεις, αλλά μόλις τους συνηθίσεις, είναι αρκετά απλοί.
Αποτελούν κρίσιμο κομμάτι της Go, οπότε αφιέρωσε λίγο χρόνο για να τους καταλάβεις πραγματικά.
Πριν μπούμε στις λεπτομέρειες, αξίζει να καταλάβουμε τη χρήση των δεικτών.
Οι δείκτες είναι ένας τρόπος να μοιραζόμαστε μνήμη με άλλα μέρη του προγράμματός μας, κάτι που είναι χρήσιμο για δύο βασικούς λόγους:
- Όταν έχουμε μεγάλες ποσότητες δεδομένων, το να φτιάχνουμε αντίγραφα για να τα περνάμε από τη μία συνάρτηση στην άλλη είναι πολύ αναποτελεσματικό.
Περνώντας αντ' αυτού τη θέση μνήμης όπου είναι αποθηκευμένα τα δεδομένα, μπορούμε να μειώσουμε δραστικά το αποτύπωμα πόρων των προγραμμάτων μας.
- Περνώντας δείκτες από τη μία συνάρτηση στην άλλη, μπορούμε να έχουμε πρόσβαση και να τροποποιούμε απευθείας το μοναδικό αντίγραφο των δεδομένων, που σημαίνει ότι οποιαδήποτε αλλαγή κάνει μια συνάρτηση είναι αμέσως ορατή στα υπόλοιπα μέρη του προγράμματος μόλις τελειώσει η συνάρτηση.
Ας πούμε ότι έχουμε μια συνηθισμένη ακέραια μεταβλητή a:
var a int
Όταν δηλώνουμε μια μεταβλητή, η Go πρέπει να βρει μια θέση στη μνήμη για να αποθηκεύσει την τιμή της.
Αυτό είναι σε μεγάλο βαθμό αφηρημένο για εμάς: όταν θέλουμε να πάρουμε την τιμή που είναι αποθηκευμένη σε αυτό το κομμάτι μνήμης, αρκεί να αναφερθούμε σε αυτή με το όνομα της μεταβλητής.
Για παράδειγμα, όταν γράφουμε a + 2, στην ουσία παίρνουμε την τιμή που είναι αποθηκευμένη στη μνήμη που σχετίζεται με τη μεταβλητή a και προσθέτουμε 2 σε αυτή.
Παρομοίως, όταν θέλουμε να αλλάξουμε την τιμή στο κομμάτι μνήμης της a, μπορούμε να χρησιμοποιήσουμε το όνομα της μεταβλητής για να κάνουμε μια ανάθεση:
a = 3
Το κομμάτι μνήμης που σχετίζεται με τη a θα αποθηκεύει τώρα την τιμή 3.
Δείκτες
Ενώ οι μεταβλητές μάς επιτρέπουν να αναφερόμαστε σε τιμές στη μνήμη, μερικές φορές είναι χρήσιμο να γνωρίζουμε τη διεύθυνση μνήμης στην οποία δείχνει η μεταβλητή. Οι δείκτες κρατούν τις διευθύνσεις μνήμης αυτών των τιμών.
Δηλώνεις μια μεταβλητή με τύπο δείκτη βάζοντας έναν αστερίσκο μπροστά από τον υποκείμενο τύπο:
var p *int // 'p' contains the memory address of an integer
Εδώ δηλώνουμε μια μεταβλητή p τύπου "δείκτης σε int" (*int).
Αυτό σημαίνει ότι η p θα κρατά τη διεύθυνση μνήμης ενός ακέραιου.
Η μηδενική τιμή των δεικτών είναι nil, επειδή ένας δείκτης nil δεν κρατά καμία διεύθυνση μνήμης.
Για να βρούμε τη διεύθυνση μνήμης της τιμής μιας μεταβλητής, μπορούμε να χρησιμοποιήσουμε τον τελεστή &.
Για παράδειγμα, αν θέλουμε να βρούμε και να αποθηκεύσουμε τη διεύθυνση μνήμης της μεταβλητής a στον δείκτη p, μπορούμε να κάνουμε το εξής:
var a int
a = 2
var p *int
p = &a // the variable 'p' contains the memory address of 'a'
Πρόσβαση στην τιμή μέσω δείκτη (αποαναφορά)
Όταν έχουμε έναν δείκτη, μπορεί να θέλουμε να μάθουμε την τιμή που είναι αποθηκευμένη στη διεύθυνση μνήμης που αντιπροσωπεύει ο δείκτης.
Μπορούμε να το κάνουμε αυτό με τον τελεστή *:
var a int
a = 2
var p *int
p = &a // the variable 'p' contains the memory address of 'a'
var b int
b = *p // b == 2
Η πράξη *p παίρνει την τιμή που είναι αποθηκευμένη στη διεύθυνση μνήμης που κρατά η p.
Αυτή η πράξη συχνά ονομάζεται "αποαναφορά".
Μπορούμε επίσης να χρησιμοποιήσουμε τον τελεστή αποαναφοράς για να αναθέσουμε μια νέα τιμή στη διεύθυνση μνήμης στην οποία αναφέρεται ο δείκτης:
var a int // declare int variable 'a'
a = 2 // assign 'a' the value of 2
var pa *int
pa = &a // 'pa' now contains to the memory address of 'a'
*pa = *pa + 2 // increment by 2 the value at memory address 'pa'
fmt.Println(a) // Output: 4
// 'a' will have the new value that was changed via the pointer!
Η ανάθεση στο *pa θα αλλάξει την τιμή που είναι αποθηκευμένη στη διεύθυνση μνήμης που κρατά η pa.
Επειδή η pa κρατά τη διεύθυνση μνήμης της a, αναθέτοντας στο *pa αλλάζουμε στην ουσία την τιμή της a!
Μια προειδοποίηση όμως: να ελέγχεις πάντα αν ένας δείκτης δεν είναι nil πριν κάνεις αποαναφορά.
Η αποαναφορά ενός δείκτη nil θα κάνει το πρόγραμμα να καταρρεύσει κατά την εκτέλεση!
var p *int // p is nil initially
fmt.Println(*p)
// panic: runtime error: invalid memory address or nil pointer dereference
Δείκτες σε struct
Μέχρι τώρα έχουμε δει μόνο δείκτες σε πρωτόγονες τιμές.
Μπορούμε επίσης να δημιουργήσουμε δείκτες για struct:
type Person struct {
Name string
Age int
}
var peter Person
peter = Person{Name: "Peter", Age: 22}
var p *Person
p = &peter
Θα μπορούσαμε επίσης να έχουμε δημιουργήσει ένα νέο Person και να αποθηκεύσουμε αμέσως έναν δείκτη σε αυτό:
var p *Person
p = &Person{Name: "Peter", Age: 22}
Όταν έχουμε έναν δείκτη σε struct, δεν χρειάζεται να κάνουμε αποαναφορά του δείκτη πριν αποκτήσουμε πρόσβαση σε ένα από τα πεδία του:
var p *Person
p = &Person{Name: "Peter", Age: 22}
fmt.Println(p.Name) // Output: "Peter"
// Go automatically dereferences 'p' to allow
// access to the 'Name' field
Τα slice και τα map είναι ήδη δείκτες
Τα slice και τα map είναι ειδικοί τύποι, επειδή έχουν ήδη δείκτες στην υλοποίησή τους.
Αυτό σημαίνει ότι τις περισσότερες φορές δεν χρειάζεται να δημιουργήσουμε δείκτες για αυτούς τους τύπους προκειμένου να μοιραστούμε τη διεύθυνση μνήμης των τιμών τους.
Φαντάσου ότι έχουμε μια συνάρτηση που αυξάνει την τιμή ενός κλειδιού σε ένα map:
func incrementPeterAge(m map[string]int) {
m["Peter"] += 1
}
Αν δημιουργήσουμε ένα map και καλέσουμε αυτή τη συνάρτηση, οι αλλαγές που έκανε η συνάρτηση στο map παραμένουν μετά το τέλος της συνάρτησης.
Αυτή είναι παρόμοια συμπεριφορά με αυτή που θα είχαμε αν χρησιμοποιούσαμε δείκτη, αλλά πρόσεξε ότι σε αυτό το παράδειγμα δεν χρησιμοποιούμε καθόλου αναφορά ή αποαναφορά ούτε κανένα από τα στοιχεία σύνταξης των δεικτών:
ages := map[string]int{
"Peter": 21
}
incrementPeterAge(ages)
fmt.Println(ages)
// Output: map[Peter:22]
// The changes the function 'incrementPeterAge' made to the map are visible after the function ends!
Το ίδιο ισχύει όταν αλλάζουμε ένα υπάρχον στοιχείο σε ένα slice.
Ωστόσο, οι ενέργειες που επιστρέφουν ένα νέο slice, όπως η append, αποτελούν ειδική περίπτωση και μπορεί να μην τροποποιήσουν το slice έξω από τη συνάρτηση.
Αυτό οφείλεται στον τρόπο με τον οποίο λειτουργούν τα slice εσωτερικά, αλλά δεν θα το καλύψουμε αναλυτικά σε αυτή την άσκηση, καθώς είναι ένα πιο προχωρημένο θέμα.
Αν έχεις πραγματικά περιέργεια, μπορείς να διαβάσεις περισσότερα για αυτό στο Go Blog: Mechanics of 'append'
Άσκηση εκμάθησης
