c语言 - 指针 和&地址

最近在研究oc的底层,全是c/c++的代码,虽然以前学过也写过,其实不怎么用都忘得差不多了。

首先我们来了解一下 * 和 &这两个符号

通俗点儿理解其实&地址就是就是一个存放地址的变量存储空间，当p指针指向某个变量，这时这个p指针里就存放了那个变量的地址。这就是我们常说的指针指向一个地址，意思是通过它能找到以它为地址的内存单元。利用指针我们可以直接获取变量中的值用，要是在指针前加 * 就是取其真值了(也就是被指向的变量的值)

//写一串代码
    int arr[5] = {1,2,3,4,5};
    int * p = &arr[0];

首先初始化了在32位RAM处理器中的arr数组占20个字节（int 占用4个字节，32比特），然后我们定义了 一个int 类型的指针变量p,指针p指向了&arr[0] 也就是 arr数组的第一个元素地址。

声明中： * 表示指针，例如： int p，p是指针，指向整型量。p表示指针指向的整型量的值。
语句中，p表示指针指向的地址。如果p是指针，没有 &p 形式。二、 x指令：
声明中：a是整型量。&a是整型量a的地址，不是指针。
语句中：a是整型量a的值。&另一用途是按位运算符，按位* 是乘号。

此时此刻，你是不是对指针变量和地址有了一定的认知了。指针也不过如此嘛?
在此之前我们先看下下列问题

int arr[5] = {1,3,5,7,9};
arr = ?
arr[0] = ?
&arr = ?
&arr[0] = ?
&arr+1 = ?
&(arr + 1)  =   

lldb打印内容：

(lldb) po arr[0]
1

(lldb) po  arr

(lldb) po  &arr
0x00007ffeefbff4c0

(lldb) po &arr[0]
0x00007ffeefbff4c0

(lldb) po &arr + 1
0x00007ffeefbff4d4

(lldb) po &arr[1]
0x00007ffeefbff4c4

(lldb) po (arr + 1)
0x00007ffeefbff4c4

(lldb) po *(arr + 1)
3

先打印了 arr[0] 等于1。
再打印了 arr 什么也没打印出来
再打印了 &arr arr数组的首地址
再打印了 &arr[0] arr数组首元素地址
再打印了&arr + 1未知地址
再打印了&arr[1] arr数组第二个元素的地址
再打印了 arr + 1 arr数组第二个元素的地址
在打印了 *(arr + 1) arr数组第二个元素

此时此刻 其实我们只有一个疑问 arr 到底是什么？
arr 是数组名称， &arr表示数组首地址，arr表示数组首元素地址
这个结论是怎么来的呢？
由arr + 1 和 &arr + 1的结果不同

说明一下 地址 + int
后面的int所代表的字节是根据当前地址类型来
假如前面的地址所代表的是元素类型地址那么所加的 元素字节为int * 单个元素的字节
假如前面的地址所代表的是数组类型地址那么所加的 元素字节为int * 数组的字节
然后再根据元素字节获取当前地址

arr + 1 是arr数组第二个元素的地址，所以arr表示数组首元素地址，&arr + 1未知地址 说明此时的地址已经越过了当前数组内的地址

    int arr[5] = {1,3,5,7,9};
    int * p  = (int*)(&arr+1);
    printf("%d\n",*(p-2));

打印7

此时此刻 p 指向&arr + 1的地址 ，也就是超越了数组界限的下一个地址。 我们用p-2往上走了8个字节，也就到了数组的倒数的第二个元素的地址。由此看来 &arr表示数组首地址。

那么猜想一下&arr +2的地址呢？

小试牛刀：

• 1.请写出以下代码输出

    int a[5] = {1,3,5,7,9};
    int *ptr = (int*)(&a+1);
    printf("%d, %d", *(a + 1), *(ptr - 1));

解析:
&a  ：   代指   数组的整体 的地址，这里的    a是数组整体

a+1：   代指    数组的第一个成员，这里的    a是数组首地址

• 2.写一个标准宏Max，并给出以下代码的输出

int array[5] = {1, 2, 3, 4, 5};
int *p = &array[0];
int max = Max(*p++, 1);
printf("%d %d", max, *p);
参考答案： 1，2
#define Max(X, Y) ((X) > (Y) (X) : (Y))
当看到宏时，就会想到宏定义所带来的副作用。对于++、–，在宏当中使用是最容易产生副作用的，因此要慎用。
分析：
p指针指向了数组array的首地址，也就是第一个元素对应的地址，其值为1.
宏定义时一定要注意每个地方要加上圆括号
*p++相当于*p, p++,所以Max(*p++, 1)相当于：
(*p++) > (1) (*p++) : (1)
=>
(1) > (1) (*p++) : (1)
=>
第一个*p++的结果是，p所指向的值变成了2，但是1 > 1为値，所以最终max的值就是1。而后面的(*p++)也就不会执行，因此p所指向的地址对应的值就是2，而不是3.
扩展：如果上面的*p++改成*(++p)如何？
(*++p) > (1) (*++p) : (1)
=>
(2) > (1) (*++p) : (1)
=> 
max = *++p;
=> 
*p = 3，max = 3;

3.请写出c语言整型和字符型数组的所有定义方法，并根据该文章写出打印出的相对应的地址代表什么

4.链表和数组的区别

5.单向链表和双向链表的区别

6.请写出以下代码的输出

        int i[] = {10, 20, 30, 40, 50};
        int *pa[] = {i, i+2, i+1, i+4, i+3};
        int **p = pa;

        printf("Initial **p = %d\n", **p);//10
        p++;
        printf("After p++, the **p = %d\n", **p);//30
        ++*p;
        printf("After ++*p, the **p = %d\n", **p);//40
        **p++;
        printf("After **p++, the **p = %d\n", **p);//20
        ++**p;
        printf("After ++**p, the **p = %d\n", **p);//21

Initial **p = 10
After p++, the **p = 30
After ++*p, the **p = 40
After **p++, the **p = 20
After ++**p, the **p = 21

定义分析 : (右结合性)
        int i[] = {10, 20, 30, 40, 50}; //定义一个一维整型数组
        int *pa[] = {i, i+2, i+1, i+4, i+3};//定义一个指针数组pa,pa[0],pa[1]分别执行I数组的某一个元素的地址
        int **p = pa;//定一个二重指针(指向指针的指针)p 指向的是pa的地址既&pa(既指针数组pa的首地址的地址), 

        printf("Initial **p = %d\n", **p);//10
        p++;//p++  运行后表示p指向针数组pa的首地址的下一个地址
        printf("After p++, the **p = %d\n", **p);//30
        ++*p;//右结合性 相当于++(*p),*p表示指针数组pa的第二个元素的值既整型数组i的第3个地址,++后*p指向整型数组i的第4个地址,p指向指针数组pa的第二个元素的地址
        printf("After ++*p, the **p = %d\n", **p);//40
        **p++;//右结合性 相当于**(p++),此时p指向指针数组pa的第二个元素的地址,++后p指向指针数组pa的第三个元素的地址
        printf("After **p++, the **p = %d\n", **p);//20
        ++**p;//右结合性 相当于++(**p),此时p指向指针数组pa的第三个元素的地址,**p则为整型数组的第二个元素的值,++后 **p = 21
        printf("After ++**p, the **p = %d\n", **p);//21