C语言学习笔记-指针

定义

指针：数据在内存中的地址。
指针变量：存储了数据所在地址的变量。指针变量的值就是某份数据的地址，这样的一份数据可以是数组、字符串、函数，也可以是另外的一个普通变量或指针变量。

使用*表明一个变量是指针变量：

 int *p1;

或者：

int a = 100;
int *p_a = &a;

在定义指针变量 p_a 的同时对它进行初始化，并将变量 a 的地址赋予它，此时 p_a 就指向了 a。值得注意的是，p_a 需要的是一个地址，a 前面必须要加取地址符&，否则是不对的。

和普通变量一样，指针变量也可以被多次写入:

//定义普通变量
float a = 99.5, b = 10.6;
char c = '@', d = '#';
//定义指针变量
float *p1 = &a;
char *p2 = &c;
//修改指针变量的值
p1 = &b;
p2 = &d;

什么时候需要指定*:
* 是一个特殊符号，表明一个变量是指针变量，所以在定义时 p1、p2 时必须带*；
而给 p1、p2 赋值时，因为已经知道了它是一个指针变量，就没必要多此一举再带上*；
即：定义指针变量时必须带*，给指针变量赋值时不能带*。

通过指针变量取得数据

#include <stdio.h>
int main(){
    int a = 15;
    int *p = &a;
    printf("%d, %d\n", a, *p);  //两种方式都可以输出a的值
    return 0;
}

假设 a 的地址是 0X1000，p 指向 a 后，p 本身的值也会变为 0X1000，*p 表示获取地址 0X1000 上的数据，也即变量 a 的值。从运行结果看，*p 和 a 是等价的。
虽然通过 *p 和 a 获取到的数据一样，但它们的运行过程稍有不同：a 只需要一次运算就能够取得数据，而 *p 要经过两次运算，多了一层“间接”。

使用 *p 的话，要先通过变量 p的地址 0XF0A0 取得变量 p 本身的值，这个值是变量 a 的地址，然后再通过这个值取得变量 a 的数据，前后共有两次运算；而使用 a 的话，可以通过地址 0X1000 直接取得它的数据，只需要一步运算。
也就是说，使用指针是间接获取数据，使用变量名是直接获取数据，前者比后者的代价要高。

指针除了可以获取内存上的数据，也可以修改内存上的数据:

#include <stdio.h>
int main(){
    int a = 15, b = 99;
    int *p = &a;  //定义指针变量
    *p = b;  //通过指针变量修改内存上的数据
    printf("%d, %d, %d\n", a, b, *p);
    return 0;
}

定义指针变量时的*和使用指针变量时的*意义完全不同，使用指针变量时在前面加*表示获取指针指向的数据，或者说表示的是指针指向的数据本身。

指针变量的运算

指针变量保存的是地址，而地址本质上是一个整数，所以指针变量可以进行部分运算，例如加法、减法、比较等：

#include <stdio.h>
int main(){
int a = 10, *pa = &a;
double b = 99.9, *pb = &b;
char c = '@', *pc = &c;
printf("pa=%#X, pb=%#X, pc=%#X\n", pa, pb, pc);
pa++; pb++; pc++;
printf("pa=%#X, pb=%#X, pc=%#X\n", pa, pb, pc);
}

结果：
&a=0X28FF44, &b=0X28FF30, &c=0X28FF2B
pa=0X28FF44, pb=0X28FF30, pc=0X28FF2B
从运算结果可以看出：pa、pb、pc 每次加 1，它们的地址分别增加 4、8、1，正好是 int、double、char 类型的长度；

数组指针

定义数组时，要给出数组名和数组长度，数组名可以认为是一个指针，它指向数组的第 0 个元素。在C语言中，我们将第 0 个元素的地址称为数组的首地址。

int arr[] = { 99, 15, 100, 888, 252 };
int len = sizeof(arr) / sizeof(int);  //求数组长度
    int i;
    for(i=0; i<len; i++){
        printf("%d  ", *(arr+i) );  //*(arr+i)等价于arr[i]
    }

运行结果：
99 15 100 888 252
arr 是数组名，指向数组的第 0 个元素，表示数组首地址， arr+i 指向数组的第 i 个元素，*(arr+i) 表示取第 i 个元素的数据，等价于 arr[i]。
arr 是int*类型的指针，每次加 1 时它自身的值会增加 sizeof(int)，加 i 时自身的值会增加 sizeof(int) * i，这在指针变量的运算中已经进行了详细讲解。

本身就是一个指针，可以直接赋值给指针变量 p

int arr[] = { 99, 15, 100, 888, 252 };
int *p = arr; // 也可写作 int *p = &arr[0];

数组指针指向的是数组中的一个具体元素，而不是整个数组，所以数组指针的类型和数组元素的类型有关，上面的例子中，p 指向的数组元素是 int 类型，所以 p 的类型必须也是int *。

使用数组指针来遍历数组元素：

 int arr[] = { 99, 15, 100, 888, 252 };
    int i, *p = arr, len = sizeof(arr) / sizeof(int);
    for(i=0; i<len; i++){
        printf("%d  ", *(p+i) );
    }

使用指针访问数组元素
也就是使用 *(p+i) 的形式访问数组元素。另外数组名本身也是指针，也可以使用 *(arr+i) 来访问数组元素，它等价于 *(p+i)。

int arr[] = { 99, 15, 100, 888, 252 };
int i, *p = arr, len = sizeof(arr) / sizeof(int);
for(i=0; i<len; i++){
    printf("%d  ", *p++ );
}

字符串指针

C语言中没有特定的字符串类型，我们通常是将字符串放在一个字符数组中：

#include <stdio.h>
#include <string.h>
int main(){
    char str[] = "http://c.biancheng.net";
    char *pstr = str;
    //直接输出字符串
    printf("%s\n", str);
    int len = strlen(str), i;
    //使用*(pstr+i)
    for(i=0; i<len; i++){
        printf("%c", *(pstr+i));
    }
    //使用pstr[i]
    for(i=0; i<len; i++){
        printf("%c", pstr[i]);
    }
    //使用*(str+i)
    for(i=0; i<len; i++){
        printf("%c", *(str+i));
    }
}

可看到使用*(pstr+i)、 pstr[i]、*(str+i)、str[i]都能取得数组中下标i对应的数据，也就是都可以使用*或[ ]获取单个字符。

除了字符数组，C语言还支持直接使用一个指针指向字符串：

char *str = "http://c.biancheng.net";

char *str2;
str2 = "http://c.biancheng.net";

两种声明字符串方式的区别：
在内存中的存储区域不一样，字符数组存储在全局数据区或栈区，第二种形式的字符串存储在常量区。全局数据区和栈区的字符串（也包括其他数据）有读取和写入的权限，而常量区的字符串（也包括其他数据）只有读取权限，没有写入权限。

指针变量作为函数参数

看以下想要交换两个变量的值的例子：

#include <stdio.h>
void swap(int a, int b){
    int temp;  //临时变量
    temp = a;
    a = b;
    b = temp;
}
int main(){
    int a = 66, b = 99;
    swap(a, b);
    printf("a = %d, b = %d\n", a, b);
    return 0;
}

运行结果：
a = 66, b = 99，交换失败，这是因为 swap() 函数内部的 a、b 和 main() 函数内部的 a、b 是不同的变量，占用不同的内存，它们除了名字一样，没有其他任何关系，swap() 交换的是它内部 a、b 的值，不会影响它外部（main() 内部） a、b 的值。

改用指针变量作参数后解决上面的问题：

#include <stdio.h>
void swap(int *p1, int *p2){
    int temp;  //临时变量
    temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}
int main(){
    int a = 66, b = 99;
    swap(&a, &b);
    printf("a = %d, b = %d\n", a, b);
    return 0;
}

运行结果：
a = 99, b = 66
其中swap函数接收的是两个指针变量，指针变量存的是内存地址，在swap函数中对指针指向的地址上的值进行修改，即修改变量a、b的地址中所保存的值，它对外部 a、b 造成的影响是“持久化”的，不会随着函数的结束而“恢复原样”。

数组作为作函数参数

查找数组中值最大的元素：

#include <stdio.h>
int max(int *intArr, int len){
    int i, maxValue = intArr[0];  //假设第0个元素是最大值
    for(i=1; i<len; i++){
        if(maxValue < intArr[i]){
            maxValue = intArr[i];
        }
    }
   
    return maxValue;
}
int main(){
    int nums[6], i;
    int len = sizeof(nums)/sizeof(int);
    //读取用户输入的数据并赋值给数组元素
    for(i=0; i<len; i++){
        scanf("%d", nums+i);
    }
    printf("Max value is %d!\n", max(nums, len));
    return 0;
}

运行结果：
12 55 30 8 93 27↙
Max value is 93!