We have learned some basic knowledge about Golang, and it is clear that Golang is very similar to C, so when you see this, you may be even more shocked, this may be a new era of C language.
Pointer to the
Variables are convenient placeholders used to refer to computer memory addresses. The Go address is &, and when used before a variable, it returns the memory address of the variable.
Example code is as follows:
package main
import "fmt"
func main(a) {
var a int = 10
fmt.Printf("Variable address: %x\n", &a )
}
Copy the codeThe output is as follows, perhaps different from one computer to another:
Variable address: C420014058
Copy the codeThe concept of a pointer is: the memory address that points to any value, is the number of the memory address. Key points:
- Is the basic data type in GO
- Represents memory address
- An address that can point to any data
- Pointers to different data types require different combinations of data types and pointer symbols to represent them
Let’s look at some simple examples:
// Pointer declaration format
// var var_name *var-type
// var-type is the type of the pointer, var_name is the name of the pointer variable, and * is used to specify whether the variable is used as a pointer.
var ip *int /* points to an integer */
var fp *float32 /* points to floating point */
Copy the codePointers, like any other type of variable, need to be declared and assigned before they can be used.
package main
import "fmt"
func main(a) {
var a int = 20 /* Declare the actual variable */
var aPointer *int /* Declare a pointer variable */
aPointer = &a /* The storage address of the pointer variable */
fmt.Printf("The address of variable A is: %x\n", &a)
/* The storage address of the pointer variable */
fmt.Printf("APointer variable stored pointer address: %x\n", aPointer)
/* Use Pointers to access values */
fmt.Printf("*aPointer variable value: %d\n", *aPointer)
}
Copy the codeThe output is as follows (different computers may have different addresses) :
The address of variable A is: C420014050
APointer variable store pointer address: C420014050
*aPointer variable value: 20
Copy the codeIn fact, for a more detailed use of Pointers, you can see the university C language textbooks, and data Structures C language edition.
Null pointer
When a pointer is defined without assigning any variables, its value is nil.
Nil Pointers are also called null Pointers.
Nil is conceptually the same as null, None, nil, and null in other languages.
A pointer variable is usually abbreviated to PTR.
Note that Pointers also have the following operations:
- Pointer arrays (arrays and Pointers at heart)
- Multilevel Pointers (Pointers to Pointers)
- A pointer argument to a function
Let’s look at the following example:
package main
import "fmt"
func main(a) {
var a int = 20 /* Declare the actual variable */
var aPointer *int /* Declare a pointer variable */
aPointer = &a /* The storage address of the pointer variable */
fmt.Printf("The address of variable A is: %x\n", &a)
/* The storage address of the pointer variable */
fmt.Printf("APointer variable stored pointer address: %x\n", aPointer)
/* Use Pointers to access values */
fmt.Printf("*aPointer variable value: %d\n", *aPointer)
b := 35
bPointer := &b
fmt.Printf("a = %d ，b = %d \n", a, b)
fmt.Printf("aPointer = %x ，bPointer = %x \n", aPointer, bPointer)
swap(aPointer, bPointer)
fmt.Println("The result of the exchange.")
fmt.Printf("a = %d ，b = %d \n", a, b)
fmt.Printf("aPointer = %x ，bPointer = %x \n", aPointer, bPointer)
pBPtr := &bPointer
fmt.Printf("PBPtr = %x, *pBPtr = %x, **pBPtr = %x \n", pBPtr, *pBPtr, **pBPtr)
}
func swap(a, b *int) {
tmp := *a
*a = *b
*b = tmp
}
Copy the codeThe output is hi:
The address of variable A is: C420014050
APointer variable store pointer address: C420014050
*aPointer variable value: 20
A is 20, b is 35
APointer = C420014050, bPointer = C420014060
The result of the exchange
A is equal to 35, b is equal to 20
APointer = C420014050, bPointer = C420014060
PBPtr = c42000C030, *pBPtr = C420014060, **pBPtr = 14
Copy the codeIn the above example, we can clearly see that the values of A and B change after the exchange, but the values of aPointer and bPointer do not change.
In the exchange function, we directly change the values of A and B through pointer manipulation, but aPointer and bPointer point to the addresses of A and B. We do not change them, so the values of aPointer and bPointer remain unchanged.
Then we declare and initialize a secondary pointer pBPtr that is the address of bPointer and *pBPtr that is the address of B.
The structure of the body
Structs, like the ones we encountered in C, are used to assemble disparate data (whether of the same type or not) together. In other object-oriented languages, such as Java, we are used to writing bean objects as follows:
Create the Person entity in Java
class Person implements Serializable{
private String name;
private Integer age;
}
Copy the codeSo how do we do that in GO?
type Person struct {
name string
age int
}
Copy the codeOf course, let’s take a look at the demo:
package main
import "fmt"
type Person struct {
name string
age int
}
// Here is the method, enter the Person method
func (person Person) logPerson(a) {
fmt.Printf("%s age: %d", person.name, person.age)
}
func main(a) {
var aPerson Person
aPerson.name = "The language"
aPerson.age = 8
aPerson.logPerson()
}
Copy the codeIn the above code, we used some knowledge points:
- Variables, declarations, and assignments
- Package name, guide package, main function
- Function, method
- The structure of the body
In the main function, we declare the aPerson variable and the data type is the structure Person. We then initialize the specific properties of the structure and call the structure’s own methods to print information about Person.
Of course the structure has the following operations:
- Property access, structure variable name. The property name
- Use methods like basic data types (declare variables, function parameters, Pointers, and so on)
The following demo illustrates the general usage of structs:
package main
import "fmt"
type Person struct {
name string
age int
}
func (person Person) logPerson(a) {
fmt.Printf("%s, age: %d \n", person.name, person.age)
}
func printPersonByPointer(person *Person) {
fmt.Printf("%s, age: %d \n", person.name, person.age)
}
func printPerson(person Person) {
fmt.Printf("%s, age: %d \n", person.name, person.age)
}
func main(a) {
var aPerson Person
aPerson.name = "The language"
aPerson.age = 8
aPerson.logPerson()
printPersonByPointer(&aPerson)
printPerson(aPerson)
}
Copy the codeNote: Function overloading is not supported in the GO language
conclusion
Go and C have a lot in common. Pointers and structures are similar concepts in C.
- Pointers support operations of any dataType and are declared in the following format: var *name dataType
- The pointer stores the memory address, & is the address of the variable, and * is the value of the pointer to memory
- The hierarchy of multilevel Pointers
- Structs can be called extended data types or wrapper data types
- Structs are used to define non-basic data types
- Basic operations on the structure (property reads and writes, function parameters, structure Pointers)
If you recognize what I have done and think it is of some help to you, I hope you can also give me a cup of coffee, thank you.
