频道导航

golang指针与C指针的异同

2019-08-01 Go 前端之家

前端之家收集整理的这篇文章主要介绍了golang指针与C指针的异同，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

总结一下golang中的指针与C语言的指针的用法。

总体一致:

C的代码:

1

2

3

4

 
        int 
        @H_404_35@ *number; 
       
 
        @H_404_35@number = ( 
         *)  
        malloc 
        @H_404_35@( 
        sizeof 
        @H_404_35@( 
        )); 
       
 
        @H_404_35@*number = 3; 
       
 
        printf 
        @H_404_35@( 
        "%d\n" 
        @H_404_35@,*number); 
       

golang的代码:

多重指针情况:

C的代码:

        4 
      
        5 
      
        6 
      
        7 
      
        8 
      
        9 
      
        10 
      
        11 
      
        12 
      
        13 
      
      **outer; 
       
         *inter; 
       
        @H_404_35@inter = ( 
        )); 
       
        @H_404_35@*inter = 3; 
       
        @H_404_35@outer = &inter; 
       
        //地址一样 
       
        "%p\n" 
         
        //值一样 
       
        11 
      
     var outer ** 
        var inter * 
        ; 
       
        @H_404_35@inter =  
        ); 
       
        @H_404_35@*inter = 3; 
       
        @H_404_35@outer = &inter; 
       
        //地址一样 
       
        @H_404_35@fmt.Println(inter); 
       
        @H_404_35@fmt.Println(*outer); 
       
        //值一样 
       
        @H_404_35@fmt.Println(*inter); 
       
        @H_404_35@fmt.Println(**outer);

C语言的下面这种方式在golang里实现:

 
         *inter;

 
        @H_404_35@));

 
        outer = ( 
         **)  
        )); 
       

 
        *inter = 3; 
       

 
        *outer = inter; 
       

 
        //地址一样

 
        //值一样

 
        在golang中:  
 
        12 
      
     ; 
       
        ; 
       
        ); 
       
        *inter = 3; 
       
        outer =  
        (* 
        ); 
       
        *outer = inter; 
       
        //地址一样 
       
        fmt.Println(inter); 
       
        fmt.Println(*outer); 
       
        //值一样 
       
        fmt.Println(*inter); 
       
上面都是在玩指针,下面看看基本的数据结构.
基本的数据结构有: 数组与结构体 (map和树之类的不在討論范围) 

golang中的数组与C中的数组有很大的差别 

golang中的数组是这样说的: Arrays are values,not implicit pointers as in C. 

0. 数组做参数时,需要被检查长度. 

1. 
变量名不等于数组开始指针!
  2. 不支持C中的*(ar + sizeof(int))方式的指针移动. 需要使用到unsafe包
 3. 如果p2array为指向数组的指针， *p2array不等于p2array[0]
例子0  数组做参数时,宋体; font-size:13px; line-height:22.5px"> 
 
        9 
      
     func use_array( args [4] 
         ){ 
       
        args[1] = 100; 
       
        @H_404_35@} 
       
        @H_404_35@func main() { 
       
        var args = [5] 
        {1,2,3,4,5}; 
       
        use_array(args); 
       
        fmt.Println(args); 
       
        @H_404_35@}

编译出错: cannot use args (type [5]int) as type [4]int in function argument,需要有长度上的检查

例子1 变量名不等于数组开始指针!

输出結果是 [1 2 3 4],没有保存結果,数组名的用法与C的不一样. 在golang里是这样的:

 
        // 又长度检查,也为地址传参 
       

 
        @H_404_35@func use_array( args *[4] 
         ){

 
        args[1] = 100;  
        //但是使用还是和C一致,不需要别加"*"操作符

 
        @H_404_35@} 
       

 
        @H_404_35@func main() {  
       

 
        var args = [4] 
         
        use_array(&args);  
        //数组名已经不是表示地址了,需要使用"&"得到地址

 
        
        fmt.Println(args);

 
        例子2  如果p2array为指向数组的指针， *p2array不等于p2array[0]
对比一下C和golang在这方面的差别：

        8 
      
        void 
        @H_404_35@ main( 
         argc, 
        char 
        @H_404_35@ *argv[]){ 
       
         *p2array; 
       
        p2array = ( 
        ) * 3); 
       
        //等于p2array[0] 
       
        *p2array = 0; 
       
        @H_404_35@} 
       
        @H_404_35@* 输出为1

        6 
      
     func main() {

 
        var p2array *[3] 
         ;

 
        p2array =  
        ([3] 
        fmt.Printf( 
        "%x\n" 
        //不管p2array是指针变量还是数组变量,都只能使用"[]"方式使用 
       

 
        @H_404_35@} 
       

 
        @H_404_35@* 报错. 
       

golang中的结构体也与C中的有差别
下面的方式是相当一致的:
C版本的:

        13 
      
        14 
      
        15 
      
     typedef 
         struct
 
        {  
       
         x; 
       
         y; 
       
        } Point; 
       
        Point p; 
       
        p.x = 10; 
       
        p.y = 20; 
       
        //开始地址 
       
        //某元素地址 
       
        golang版本的: 

  type Point  
        struct 
        @H_404_35@{ 
       
        x  
        y  
        ; 
       
        }; 
       
        var p Point; 
       
        p.x = 10; 
       
        p.y = 20; 
       
使用allocate的方式: 
C代码: 

        15 
      
        16 
      
     Point *p; 
       
        p = (Point *)  
        (Point)); 
       
        p->x = 10; 
       
        p->y = 20; 
       
        //开始地址 
       
        //地址 
       
        //某元素地址 
       
        golang代码: 

  var p *Point; 
       
        p =  
        (Point); 
       
        p.x = 10; 
       
        p.y = 20; 
       
        //地址 
       
也可以说是一样的,只不过在使用结构中的元素时没有了"->"操作符:

        1 
      
        There is no -> notation for structure pointers. Go provides the indirection for you. 
       
结构体的地址传参与数组的方式一样,当然,和C的风格也是一模一样的. 如下例子:

        16 
      
        17 
      
        18 
      
        19 
      
        20 
      
        21 
      
        22 
      
        23 
      
        24 
      
        25 
      
        #include <stdio.h> 
       
        #include <stdlib.h> 
       
         struct 
       
        { 
       
         x; 
       
         y; 
       
        } Point; 
       
         use_struct(Point *arg){ 
       
        arg->x = 100; 
       
        @H_404_35@} 
       
         *argv[]){ 
       
        Point *p; 
       
        (Point)); 
       
        p->x = 10; 
       
        p->y = 20; 
       
        use_struct(p); 
       
        @H_404_35@} 
       
        24 
      
     import  
        "fmt" 
       
        @H_404_35@; 
       
        ; 
       
        @H_404_35@}; 
       
        @H_404_35@func use_sturct( p *Point ){ 
       
        p.x = 100; 
       
        @H_404_35@} 
       
        @H_404_35@func main() { 
       
        var p *Point; 
       
        (Point); 
       
        p.x = 10; 
       
        p.y = 20; 
       
        use_sturct(p); 
       
        @H_404_35@} 
       
总的来说......在传参方面,大体上看与C的相同:
        2 
      
     f(ar);  
        // passes a copy of ar 
 
        fp(&ar);  
        // passes a pointer to ar

* 只是变量名是不是表示首个地址有区别
"&" 与C语言一样是得到变量的指针. 与C有点不同，取golang中指针指针的内容的值是不需要使用"*"操作符的，但是指针的指针(或者继续多层时)需要显式使用"*"符号. 在 http://golang.org/doc/go_spec.html#Selectors 一节中有描述。
* 三层以上的指针使用是比较少的. 两层还是常见,如main函数的参数char * argv[] 原文链接：https://www.f2er.com/go/190794.html