[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);   // 结果相差四个字节

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';            // 无法修改

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