指针入门

作者: 某尤 | 来源:发表于2016-03-21 18:31 被阅读108次

    sizeof 运算符

    sizeof运算符,能给出某个类型或变量在内存中所占据的字节数。

    • sizeof(int)

    • sizeof(i)

    示例代码:

    #include <stdio.h>
    int main()
    {
        int a;
        a = 6;
        printf("sizeof(int)=%ld\n", sizeof(int));
        printf("sizeof(a)=%ld\n", sizeof(a));
        return 0;   
    }
    

    程序输出:
    sizeof(int)=4
    sizeof(a)=4

    注:1byte=8bit,则一个整型要占用4byte(32bit)内存。

    & 运算符

    获取变量的地址,它的操作数必须是变量

    #include <stdio.h>
    int main()
    {
        int i = 0;
        printf("0x%x\n", &i);  //0x22fe4c
        printf("%p\n", &i);    //000000000022FE4C
        
        
        printf("%lu\n", sizeof(int)); //4 整型4字节
        printf("%lu\n", sizeof(&i));  //8 32位架构下地址使用4字节存储、64位架构下地址使用8字节存储
        return 0;
    }
    
    • & 操作符不能操作非变量
    #include <stdio.h>
    int main()
    {
        int i = 0;
        int p;
        p = (int)&i;
        p = (int)&(i+p); //[Error] lvalue required as unary '&' operand
        return 0;
    }
    
    • 相邻变量的地址,有什么特点?
    #include <stdio.h>
    int main()
    {
        int i = 0;
        int p;
    
        printf("%p\n", &i); //0022FE4C
        printf("%p\n", &p); //0022FE48
    
        return 0;
    }
    

    i与p相差4(整型变量占用4字节)
    i地址高于p(C语言内存模型,本地变量在堆栈中分配,变量由高至低分配。)

    &操作符与数组

    • 数组的地址
    • 数组单元的地址
    • 相邻的数组单元的地址
    #include <stdio.h>
    int main()
    {
        int a[10];
    
        printf("%p\n", &a);     //数组的地址
        printf("%p\n", a);      //不写&
    
        printf("%p\n", &a[0]);
        printf("%p\n", &a[1]);
    
        return 0;
    }
    

    程序输出:
    0022FE20
    0022FE20
    0022FE20
    0022FE24

    • &a == a == &a[0],获取数组第一个元素的三种方式。
    • a[0]与a[1] 之间差4字节,相邻的数组单元的差距都是4字节。

    如何保存地址的变量?

    • *是一个单目运算符,用来访问指针的值所表示的地址上的变量。
    • 可以做右值也可做左值
    #include <stdio.h>
    
    void f(int *p);
    
    int main(void)
    {
        int i = 6;
        printf("&i=%p\n", &i);
        f(&i);                  //通过&i传递i的地址
        printf(" i=%d\n", i);
        return 0;
    }
    
    void f(int *p)             //通过 *p 接收 &i
    {
        printf(" p=%p\n", p);  //通过 p 访问 i 的地址
        printf("*p=%d\n", *p); //通过 *p 访问 i 变量
        *p = 26;               //通过 *p 给 i 变量赋值
    }
    

    程序输出:
    &i=0022FE4C
    p=0022FE4C
    *p=6
    i=26

    数组与指针

    函数参数表中的数组实际上是指针

    #include <stdio.h>
    void getMin(int a[], int len, int *min);
    int main()
    {
        int a[] = {1, 2, 3, 4, 5, 6};
        int min;
    
        printf("main sizeof(a)=%lu\n", sizeof(a));
        printf("main a=%p\n", a);
    
        getMin(a, sizeof(a)/sizeof(a[0]), &min);    
        printf("a[0]=%d\n", a[0]);
        printf("min=%d\n", min);
    
        return 0;
    }
    
    void getMin(int a[], int len, int *min)
    {
        int i;
        printf("min sizeof(a)=%lu\n", sizeof(a));
        printf("min a=%p\n", a);
        *min = a[0];
        for( i=1; i<len; i++) {
            if( a[i] < *min) {
                *min = a[i];
            }
        }
    }
    

    程序输出:
    main sizeof(a)=24
    main a=0022FE30
    min sizeof(a)=8
    min a=0022FE30
    a[0]=1
    min=1

    • sizeof(a) == sizeof(int*)
    • 在函数参数表中 int sum(int a[])int sum(int *a) 是等价的

    数组变量是特殊的指针

    数组变量本身表达地址,所以

    • int a[10]; int* p = a //无需用&取地址

    但是数组的单元表达的是变量,需要用&取地址

    • &a[0]&a[1]&a[2]

    []运算符可以对数组做,也可以对指针做:

    • p[0] 等价于 a[0]

    *运算符可以对指针做,也可以对数组做:

    • *a = 25

    数组变量是const的指针,所以不能被赋值

    • int a[] 可以看成是 int * const a

    指针的常见错误

    指针变量在未指向一个变量前不能被赋值

    int *p;
    *p = 12; // Error
    
    int *p;
    int i = 10;
    p = &i;  // Right
    *p = 12;
    

    const 与 指针

    int i;
    const int *p1 = &i; //指针所指的不可修改
    int const *p2 = &i; //指针所指的不可修改
    int *const p3 = &i; //指针不可修改
    
    const int a[] = {1, 2, 3, 4, 5, 6};
    

    数组变量已经是const的指针,这里的const表明数组的每个单元都是const int,所以只能通过初始化赋值。

    相关文章

      网友评论

        本文标题:指针入门

        本文链接:https://www.haomeiwen.com/subject/epbklttx.html