2. 程式人生 > >go語言漸入佳境[14]-指標

go語言漸入佳境[14]-指標

阿新 • • 發佈：2018-12-04

變數的地址

1
2
 
a :=10
fmt.Printf("a變數的地址為：%#X\n",&a)//a變數的地址為：0XC420092008

指標的宣告

1
2
 
//宣告
var p *int

空指標

1
2
3
 
if p==nil{
  fmt.Println("p為空指標")
}

通過指標獲取值

1
2
 
p = &a
fmt.Printf("p的型別為%T, p的值為：%v,p指向的int的值為：%v,a的值為：%d\n",p,p,*p,a)

通過指標修改值

1
2
 
*p = 99
fmt.Printf("p的型別為%T, p的值為：%v,p指向的int的值為：%v,a的值為：%d\n",p,p,*p,a)

完整例子1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
package main

import "fmt"

func main(){


	//變數的地址
	a :=10
	fmt.Printf("a變數的地址為：%#X\n",&a)


	//宣告
	var p *int

	//空指標
	if p==nil
 
{
		fmt.Println("p為空指標")
	}

	//通過指標獲取值
	p = &a
	fmt.Printf("p的型別為%T, p的值為：%v,p指向的int的值為：%v,a的值為：%d\n",p,p,*p,a)


	//通過指標修改值
	*p = 99
	fmt.Printf("p的型別為%T, p的值為：%v,p指向的int的值為：%v,a的值為：%d\n",p,p,*p,a)

}

指標作為函式引數

指標作為函式引數,修改原來的值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
package main

import
 
 "fmt"

func main() {
	a := 10
	fmt.Printf("1、變數a的記憶體地址是：%p ，值為：%v \n\n", &a, a)//10

	b := &a
	change(b)
	fmt.Printf("3、change函式呼叫之後，變數a的記憶體地址是：%p ，值為：%v \n\n", &a, a)//20

	change0(a)
	fmt.Printf("5、change0函式呼叫之後，變數a的記憶體地址是：%p ，值為：%v \n\n", &a, a)//20

}

func change(a *int) {
	fmt.Printf("2、change函式內，變數a的記憶體地址是：%p ，值為：%v \n\n", &a, a)//20
	*a = 50
}

func change0(a int) {
	fmt.Printf("4、change0函式內，變數a的記憶體地址是：%p ，值為：%v \n\n", &a, a)//20
	a = 90
}

切片型別指標作為函式引數

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
package main

import "fmt"

func main() {
	a := []int{1, 2, 3, 4}
	fmt.Printf("1、變數a的記憶體地址是：%p ，值為：%v \n\n", &a, a)

	modify(&a)
	fmt.Printf("3、呼叫modify函式後，變數a的記憶體地址是：%p ，值為：%v \n\n", &a, a)

	modify0(a)
	fmt.Printf("5、呼叫modify0函式後，變數a的記憶體地址是：%p ，值為：%v \n", &a, a)
}

func modify(arr *[]int) {
	fmt.Printf("2、modify函式中引數a的記憶體地址是：%p ，值為：%v \n", &arr, arr)
	(*arr)[0] = 250
}

func modify0(arr []int) {
	fmt.Printf("4、modify0函式中引數a的記憶體地址是：%p ，值為：%v \n", &arr, arr)
	arr[0] = 99
}

指標作為函式引數例子2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
package main

import "fmt"

func main() {
	//定義兩個區域性變數
	a, b := 100, 200

	//	返回值的寫法實現資料交換
	a, b = swap0(a, b)
	fmt.Println("第一次交換後：" , a, b)

	//	使用指標實現交換
	swap(&a, &b)
	fmt.Println("第二次交換後：" , a, b)
}

//具有返回值的慣用寫法，實現兩個資料的交換
func swap0(x, y int) (int, int) {
	return y, x
}

//使用指標作為引數的寫法
func swap(x, y *int) {
	*x, *y = *y, *x
}

指標陣列

陣列，陣列中的元素儲存的都是指標。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
package main

import "fmt"

const COUNT int = 4

func main() {
	a := [COUNT]string{"abc", "ABC", "123", "一二三"}
	//檢視陣列的指標的型別和值
	fmt.Printf("%T , %v \n", &a, &a)

	//定義指標陣列
	var ptr [COUNT]*string
	fmt.Printf("%T , %v \n", ptr, ptr)

	for i := 0; i < COUNT; i++ {
		//	將陣列中每個元素的地址賦值給指標陣列的每個元素
		ptr[i] = &a[i]
	}
	fmt.Printf("%T , %v \n", ptr, ptr)

	fmt.Println(ptr[0])

	//	根據指標陣列元素的每個地址獲取該地址所指向的元素的真實數值
	for i:=0; i<COUNT ;i++  {
		fmt.Println(*ptr[i])
	}

	for _,value :=range ptr {
		fmt.Println(*value)
	}
}

多級指標

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
package main
import "fmt"

func main() {
	var a int
	var ptr *int
	var pptr **int

	a = 123

	
            
  

           

              
              

            

            
相關推薦

			   
            
            
            
 

    


    
    
go語言漸入佳境[14]-指標

     
 
 變數的地址
 
  
   
    12
    a :=10fmt.Printf("a變數的地址為：%#X\n",&a)//a變數的地址為：0XC420092008
   
  
 
 指標的宣告
 
  
   
    12
    //宣告var p *int
   
  
 
 空指標 



  
 

    


    
    
go語言漸入佳境[6]-operator運算子

     
 
 運算子
 和其他語言一樣，Go語言支援多種運算子，用於對變數進行運算。
 
  
   
    12345678910111213
    package mainimport "fmt"func main(){	//math()	//relation()	//logic()	//wei()	Assig 



  
 

    


    
    
go語言漸入佳境[5]-printf格式化列印

     
 
 golang輸出的格式化列印
 
  
   
    1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950
    package mainimport "fmt"func  



  
 

    


    
    
go語言漸入佳境[4]-scope作用域

     
 
 作用域
 universe block > package block > file block > function block > inner block
 universe block
 預宣告的識別符號。Go檔案全部使用
 
  
   
    12345678
     



  
 

    


    
    
go語言漸入佳境[3]-變數宣告與賦值

     
 
 變數
 變數是記憶體當中一段空間的抽象描述。變數的型別明確了空間的大小以及空間如何解析。
 Go中的變數型別
 
  
   
    1
    bool byte complex64 complex128 error float32 float64 int int8 int16 int32 int64 



  
 

    


    
    
go語言漸入佳境[13]-切片

     
 
 切片
 1、切片可以修改大小2、切片的拷貝不是單純值的拷貝，一個切片指向了一個數組
 切片的宣告
 
  
   
    1234567
    //切片的宣告1  //nilvar slice1 []int  //切片的宣告2var slice2 []int = make([]in 



  
 

    


    
    
go語言漸入佳境[12]-array

     
 
 陣列宣告與定義
 
  
   
    1234
    //宣告三種方式var arr [3]intvar arr2  = [4]int{1,2,3,4}arr4 :=[...] int{2,3,4}
   
  
 
 列印陣列
 
  
   
    1
    fmt.Println 



  
 

    


    
    
go語言漸入佳境[11]-function2

     
 
 匿名函式
 
  
   
    123456789101112131415161718192021222324252627282930313233
    package mainimport (	"fmt"	"math")//匿名函式func main(){	//無參匿名函式	func(){		fm 



  
 

    


    
    
go語言漸入佳境[10]-function

     
 
 無參函式
 
  
   
    123
    func printstring(){	fmt.Println("hello jonson")}
   
  
 
 帶參函式
 
  
   
    123
    func add(a,b int){	fmt.Println("a+b=",a+b) 



  
 

    


    
    
go語言漸入佳境[9]-doubleloop

     
 
 迴圈巢狀 一般形式
 
  
   
    12345678910111213
    package mainimport "fmt"func main(){	var sum int	for i:=0;i<5;i++{		for j:=0;j<3;j++{			sum = i*j		}	} 



  
 

    


    
    
go語言漸入佳境[7]-if判斷條件

     
 
 if條件語句的表現形式：
 
  
   
    1234567891011121314151617
    //第一種最基本num := 26if(num %2==0){		fmt.Printf("num是偶數\n")	}  //第二種 初始化：  if  str:="j 



  
 

    


    
    
go語言漸入佳境[8]-loop

     
 
 
  
   
    123456789101112
    package mainimport (	"fmt")func main(){  //呼叫  loop1()	sum2()}
   
  
 
 第1種形式
 
  
   
    12345678
    func l 



  
 

    


    
    
C語言筆記14--指標與掛

     
 
							
							
							指標是C語言繞不過的話題，指標的功能也非常強大，指標也有多級，但常用的也就一級和二級指標。指標其實就是地址，指標變數就是儲存指標的變數。有了指標就可以修改變數的值，也是遊戲外掛的原理。 
1.指標的長度



#include<stdio.h>
#i 



  
 

    


    
    
GO語言學習(三):指標，切片，map對映

     
  
  
  
 1.指標 
 func main() {
    var a int = 10
    //每個變數有2層含義，變數的記憶體，變數的地址
    fmt.Printf("a =%d\n", a)
    fmt.Printf("&a =%v\n", &a)

    //儲存 



  
 

    


    
    
go語言基礎之指標做函式引數

     
 1、指標做函式引數 
示例： 
 
 package main //必須有個main包

import "fmt"

func swap(a, b int) {
	a, b = b, a
	fmt.Printf("swap: a = %d, b = %d\n", a, b)
}

func  



  
 

    


    
    
go語言：陣列指標與指標陣列

     
 
                
一句話總結：注意*與誰結合，如p *[5]int，*與陣列結合說明是陣列的指標；如p [5]*int，*與int結合，說明這個陣列都是int型別的指標，是指標陣列。

packagemain

import"fmt"

funcmain(){
a:=[...]int{1,2 



  
 

    


    
    
《快學 Go 語言》第 14 課 —— 魔術變性指標

     
 本節我們要學習一些 Go 語言的魔法功能，通過內建的 unsafe 包提供的功能，直接操縱指定記憶體地址的記憶體。有了 unsafe 包，我們就可以洞悉 Go 語言內建資料結構的內部細節。 
unsafe.Pointer 
Pointer 代表著變數的記憶體地址，可以將任意變數的地址轉換成 Pointer 型 



  
 

    


    
    
go語言學習--指標陣列和陣列指標

     
 陣列指標（也稱行指標）定義 int (*p)[n];()優先順序高，首先說明p是一個指標，指向一個整型的一維陣列，這個一維陣列的長度是n，也可以說是p的步長。也就是說執行p+1時，p要跨過n個整型資料的長度。 
 
 如要將二維陣列賦給一指標，應這樣賦值：int a[3][4];int (*p)[4]; // 



  
 

    


    
    
Go語言基礎（八）—— Go語言變數作用域、Go語言陣列、Go語言指標

     
  
 
 
 Go語言變數作用域 
 作用域為已宣告識別符號所表示的常量、型別、變數、函式或包在原始碼中的作用範圍。  
 Go 語言中變數可以在三個地方宣告： 
 • 函式內定義的變數稱為區域性變數  • 函式外定義的變數稱為全域性變數  • 函式定義中的變數稱為形式引數&nb 



  
 

    


    
    
golang語言漸入佳境[19]-從go原始碼讀懂interface介面

     
 
 go原始碼中的介面
 http庫中，get方法：
 
  
   
    1
    func Get(url string) (resp *Response, err error)
   
  
 
 Response:
 
  
   
    123456789
    type Response