[TwistedFate]指针

1.字节是内存当中最小的存储单位
1个字节是8个二进制位
2.访问变量的方式:
1.直接访问:通过变量名直接访问
2.间接访问:通过变量的地址(内存编号)访问变量
3.指针变量:保存的是地址

int *p = NULL;

声明指针变量的时候*没有特殊意义 只是告诉编译器这是一个指针变量
int: 表示这个指针变量所指向的是一片整型存储区域 也就是说指针变量p只想的内存存储的值是一个整型

    int  a = 5;
    // 声明一个指针变量
    int *p = NULL;
    // 指针变量p指向a的存储区域(地址)
    // &取地址符
    p = &a;
    // 打印地址占位符 %p
    printf("%p\n",p);
    printf("%p\n",&a);

4.* 取值符 // 注意*区别
// * p表示指针变量 所指向的地址所保存的值

    printf("%d\n",a);
    printf("%d\n",*p);

// 修改变量的值

        a = 3;   // 直接访问
        *p = 30; // 间接访问
        printf("%d\n",*p);

5.打印指针变量占用的字节数:
指针变量 占用八个字节 与数据类型无关,只和操作系统有关系
指针变量的赋值 相当于指针的重指向

    int num1 = 50;
    int num2 = 40;
    int *p1 = &num1;
    int *p2 = &num2;
    p2 = p1;
    *p2 = 100;
    printf("num1 = %d\n",num1);  // 100
    printf("num2 = %d\n",num2);  // 40
    printf("p1 = %p\n",p1);      // 地址和p2一样
    printf("p2 = %p\n",p2);      // 同上
    printf("*p1 = %d",*p1);      // 100
    printf("*p2 = %d",*p2);      // 100

6.指针的运算
地址里面存储的值可以加减乘除
地址运算只有 加 和 减
地址加 1 需要看指针变量的数据类型
如果是int 类型 地址 + 1, 相当于加4个字节
如果char类型 地址+1　相当于＋　1个字节

    int a = 3;
    int *p = &a;
    p++;
    printf("%p %p",&a, &b);   // 结果相差四个字节

1. 7.

        int a = 3;
        int b = 5;
        int *p = &a;
        // 系统在分配内存的时候 不一定是分配的是连续的
        // 如果是数组,则分配的内存一定是连续的
        printf("&a = %p\n",&a);
        printf("&b = %p\n",&b);
        printf("*p = %d\n",*p);
        p--;              // 地址-4
        printf("*p = %d\n",*p);

8.需求编写一个函数,通过指针交换两个整型变量的值

void exchangeValue(int *num1, int *num2)
{
    int  temp = *num1;
    *num1 = *num2;
    *num2 = temp;
}
int main(int argc, const char * argv[]) {
    int a = 3;
    int  b = 4;
    exchangValue(&a, &b);
    printf("a = %d,b = %d",a,b);    // a = 4,b = 3
    return 0;
}

分析:
1.参数的传递 是实参向形参进行的传递 是一个拷贝的过程 是值的传递 地址不一样
2.交换时应该本着一个原则 操作的变量的地址应该是一样的
9.指针与数组

    int array[4] ={1, 3, 5, 7};
    printf("%p\n",&array[0]);
    printf("%p\n",array);// 数组的名字本身就是数组首元素的地址 不需要加取地址符

// 声明一个指针变量 指向数组(数组的元素)

    int *p = array;
    int *p2 = &array[0];
    // 利用数组取出其中元素方法:
    // array[下标]
    // *(array + 下标)
    // 利用指针变量p取出数组元素
    // p[下标]
    // *(p + 下标)
    printf("*(p + 1) = %d, *p2 = %d\n",*(p + 1), *p2);     // *(p + 1) = 3, p2 = 1 
     printf("%d \n",p[2]);  // p[2] = 5

10.计算数组中的元素个数
数组总元素占用的字节数 / 数组中单个元素的字节数 = 数组元素个数
// array 代表的是整个数组
// p代表的是指针变量(8个字节)

    int count = sizeof(array) / sizeof(int);
    printf("count = %d\n",count);

// x 需求: 通过指针变量p,不能求出元素个数

    int count = sizeof(p) / sizeof(int);
    printf("count1 = %d\n ",count1); // 8/4=2

11.数组当函数参数时,传递的不是整个数组,传递的是数组元素的首地址(传递了一个指针)
12.

    short a[4] = {6, 7, 9, 1};
    int *p1 = a;
    printf("%d\n",*p1); //458758
    char *p2 = a;
    printf("%d\n",*p2); //6

// short占两个字节,int占四个字节 char占一个字节
13.指针与字符串

    // 指针与字符串
    char str1[] = "iphone";
    char str2[] = {'i', 'p', 'h', 'o','n', 'e'};
    char *p = str1;
    // 1.利用指针 打印字符串
    printf("%s\n",str1);
    printf("%s\n",p);
    // 2.利用指针 打印字符h
    printf("%c\n",*(p + 2));
    printf("%c\n",p[2]);
    printf("%c\n",*(str1 + 2));
    printf("%c\n",str1[2]);
    // 3.把h 更改成w
    p[2] = 'w';
    printf("%c\n",p[2]);
     4.通过指针来计算字符串的长度
    char str[] = "wanglong";
    // 声明指针 指向字符串str
    char *p = str;
    // 思路: 第一位 *(p + 0);
    //      第二位 * (p + 1);
    //      第三位 *(p + 2);
    //      *(p + i) == '\0'字符串结束
    //    int count = 0;
    //    while (*(p + count) != '\0') {
    //        count++;
    //    }
    int count = 0;
    while (*(p + count) != '\0') {
        count++;
        p++;
    }
    printf("%d \n",count);
    // 把 l 改成 x
    printf("%c\n",*(p + 4));
    // 缺点 : 指针p重指向了

14.指针数组

    // 指针数组
    char *strings[3] = { "iOS", "Android", "Win8"};
    // 指针数组  数组当中保存的都同一个类型的数据 指针数据当中保存都是指针指针类型 保存的都是地址
    // 把常量的常量字符串 拷贝一份 
    printf("%s\n",strings[0]);
    printf("%s\n",*strings);
    printf("%s\n",*(strings + 1));
    // 打印iOS里面的o
    printf("%c\n",strings[0][1]);
    printf("%c\n",*strings[0]);
   // *strings[0] = 'x';            // 无法修改

    /**
     如果你声明时 直接声明常量字符串 那么你是不能更改的  如果你声明时 先声明一个字符串(这时候这个字符串就不是常量字符串了 是从常量区拷贝的拷贝栈区),这时候你可以对该字符进行修改
     */