C语言指针笔记

我们知道C语言包含了short、int、long、char、float、double 六种基本的数据类型。这其中存储的数据比特，不方便理解，这里为了方便理解将这六中类型具象化。
假设有六种水果，
（1）首先是体型小的水果：
①葡萄对应char类型，只要一个字节(一个字节对应八个比特)；
（2）其次是体型次的水果：
②草莓对应short类型，需要两个字节。
（3）再次是体型中等大小的水果：
③梨子对应int类型，需要四个字节；
④苹果对应float类型，也需要四个字节；
⑤橘子对应long类型，也需要四个字节。
（4）最后是体型较大的水果：
⑥西瓜对应double类型，需要八个字节。
计算机内有很多空间可以存储这六种类型的数据；类比我们有很多同样大小的抽屉可以存储各种水果，如果是大的水果一个抽屉放不下就需要拆分了。

在我们有足够的空间的情况下，怎么能存储和找到这些水果呢？
这里就用到了一个很好用的东西就是指针；类比假如我们雇佣了一个帮手，这个帮手用于帮我们找到水果和指针起到同样的作用。

一、单个变量的情况：
（1）&符号用于取地址。

int a = 1;
printf("a的值为%d\n",a);
printf("a的地址为0X%x\n",&a);

这里首先定义了变量，电脑会自动分配一个空余的存储空间用于存储变量a，电脑为了找到这个变量a，可以直接通过它的名称a来调用它，也记录了a的地址知道a存储在哪里(&a)(这个地址不是很好辨认，还是用的16进制表示，因为我们计算机的内存是很大的，从上图的结果来看有8个十六进制(2^32=4GB))；
类比的也将梨子存储起来，为了方便找到这个梨子，我们需要知道这个梨子的名字和梨子存放的位置，比如将这个梨子命名为a，记录梨子存放的位置(比如25号抽屉)。

（2）*符号用于取值。

 int* p1;//定义一
 p1 = &a;
 printf("p1的值是%d\n",*p1);
 printf("p1的地址是0X%x\n",p1);

 int* p2 = &a;//定义二
 printf("p2的值是%d\n",*p2);
 printf("p2的地址是0X%x\n",p2);

p1和p2就是指针用于存储地址；
这里的*p1=a;*p2=a，都是对应地址中存储的内容。
*符号和&符号是相反的。
*符号加在指针前面相当于取地址中的内容，有了地址，再通过*符号就可以取得地址中的值。

这里有一个容易迷惑的地方就是int* p2 = &a;因为*p2表示的是具体的值，在这里赋值岂不是*p2的值成了a的地址。
其实不是的，这里的

int *p2 = &a;
//作用等同于，只是把两句话写成了一句话
int *p2;
p2 = &a;

注意：
这里赋值的时候一定要给地址：
下面这种写法是有问题的，因为p2没有给地址，相当于没有地方放。

int* p2;
*p2 = 10;
//报错：Segmentation fault

这里和前面int a;a=10;要区分开来，如果是用int定义会自动分配地址，而现在之定义了p2这个指针并没有分配地址，再要赋值是不行的；相当于要放一个梨子，可是没有指出要放的位置，所以是不会成功的。

二、一维数组的情况：
这里是不是有些多此一举，既然又知道名字又知道地址就重复了，因为二者只要一个就可以达到对a或是这个梨子操作的目的。这里只是举个例子，实际上一般不这样用在变量中，而是用于数组中（只知道地址而不知道名字的情况），这里也体现了指针的好处，因为如果有很多变量，我们一个个命名岂不是太麻烦了，所有我们才需要用到数组，可以对变量批量命名，有了指针就可以批量进行处理。

int a[3]={10,20,30};
for(int i = 0;i < 3;i++)
	printf("第%d个元素的值为%d\n",i,a[i]);

假设定义一个数组，可以很容易的取得变量中的每一个值。这是我们常用的形式，其实这里的a就是一个指针，指向a[0]的起始地址。

引入指针：

int *p_int = a;
for(int i = 0;i < 3;i++)
{
    printf("第%d个元素的值为%d\n",i,*(p_int+i));
}

①这里的指针定义就和前面对变量的定义有了不同，因为对变量的定义p_int = &a，而这里直接p_int = a，因为a本身代表的就是地址了。

如果把二者的地址打印出来：

printf("a的地址为:0X%x\n",a);
printf("p_int的地址为:0X%x\n",p_int);

这里取元素的值a[i],*(a+i),p_int[i]或*(p_int+i)都是一样的。
这里的a和p_int虽然值是相同的，但是还是有一些小区别：

//写法一
for(int i = 0;i < 3;i++)
{
    printf("第%d个元素的值为%d\n",i,*p_int);
    p_int++;
}
//写法二
for(int i = 0;i < 3;i++)
{
    printf("第%d个元素的值为%d\n",i,*p_int);
    a++;
}

写法一是正确的，也会打印出正确的结果；
写法二会报错，因为a的值是不可以改变的，因此a这是在程序编译时分配的一段内存空间的起始地址，算不上指针，因为指针的指向是可以改变的。

②而下一个元素就是*(p_int+i)，和*(p_int)+i有区别吗？

 int *p_int = a;
 for(int i = 0;i < 3;i++)
 {
     printf("1.第%d个元素的值为%d\n",i,*(p_int+i));
 }
 printf("\n");
 for(int i = 0;i < 3;i++)
 {
     printf("2.第%d个元素的值为%d\n",i,*(p_int)+i);
 }

二者是有区别的，可以看到如果用*(p_int)+i的话相当于每次的*(p_int)都是第一个元素的值即为10，因此*(p_int)+i相当于10+i

③不同类型大小不同：

int a[3]={10,20,30};
int *p_int = a;
for(int i = 0;i < 3;i++)
{
    printf("a数组中第%d个元素的值为%d\n",i,*p_int);
    printf("a数组中第%d个元素的地址为0X%x\n",i,p_int);
    p_int++;
}
printf("\n");
double b[3] = {3.14,6.28,9.42};
double *p_double = b;
for(int i = 0;i < 3;i++)
{
    printf("b数组中第%d个元素的值为%f\n",i,*p_double);
    printf("b数组中第%d个元素的地址为0X%x\n",i,p_double);
    p_double++;
}

这里一个数组存储的是int类型，一个存储的是double类型；
可以看出定义为int类型的指针p_int，在p_int++后，其实增大了四个地址；而定义为double类型的指针p_double，在p_double++后，其实增大了八个地址；这就像我们要取水果的话不仅要指定地址即指针的值知道去哪儿取水果，还必须知道水果的类型是什么，如果是西瓜的话就要把8个抽屉的内容都取出来才能取到完整的西瓜。对于计算机而言是一样的，必须定义好正确的指针类型，如果是char就取一个字节，int就取四个字节。

④怎么取得数组的大小？
在其他高级语言里会有内置的库函数表示数组的大小，比如python的len()函数，在c语言里要相对麻烦一些。

int a_size = sizeof(a)/sizeof(a[0]);
printf("数组a的总大小为：%d\n",sizeof(a));
printf("数组a的一个元素的大小为：%d\n",sizeof(a[0]));
printf("数组a的包含元素的个数为：%d\n",a_size);
printf("\n");
int b_size = sizeof(b)/sizeof(b[0]);
printf("数组b的总大小为：%d\n",sizeof(b));
printf("数组b的一个元素的大小为：%d\n",sizeof(b[0]));
printf("数组b的包含元素的个数为：%d\n",b_size);

这里取的总大小是把所有的a所占用的空间都取出来了；类别而言就是有3个草莓，一个草莓占用2个抽屉，3个草莓占用3x2=6个抽屉，而sizeof(a)就相当于计算出了总抽屉数，sizeof(a[0])计算出了一个水果所需要的空间，二者相除就得到了总共有多少水果。
这里一定要记得相除，忘记除了的话除非定义的是char类型，sizeof(a[0])=1，否则会得到错误的结果。

三、对字符串进行操作：

int main(void)
{
    char a[] = "apple";
    char *b = "banana";
    int size_a = 5;
    for (int i = 0;i < size_a;i++)
    {
        printf("%c",a[i]);
    }
    printf("\n");
    
    int size_b = 6;
    for (int i = 0;i < size_b;i++)
    {
        printf("%c",b[i]);
    }
    return 0;
}

对字符串进行操作和对字符数组进行操作是很类似的。只是不是通过char a[]={‘a’,‘p’,‘p’,‘l’,‘e’}的方式赋值，而是通过char a[]="apple"的形式整体赋值。还是有一个挺大的区别。那就是末尾多了一位’\0’表示字符串的结束。

 int size_a = sizeof(a)/sizeof(a[0]);
 printf("数组a的大小为%d\n",size_a);
 int size_b = sizeof(b)/sizeof(*b);
 printf("数组b的大小为%d\n",size_b);

所以如果我们打印出来的话可以发现多了一位，正确的大小应该要-1，减去最后那一位’\0’，当然嫌麻烦的话，c语言在string.h的头文件里提供了strlen函数可以直接得到字符串的值：

#include<string.h>
int size_a = strlen(a);

这个函数的内部可能是这样写的，也比较容易看懂：

int strlen(const char * s)
{
	const char * sc;
	for (sc = s; *sc != '\0'; ++sc);
	return sc - s;
}

所以这两种定义是相同的：

char a[] = {'a','p','p','l','e','\n'};
char a[] = "apple";

正是因为有字符串有这个特点，因此我们可以这样利用：

int main(int argc, char const *argv[])
{
    char *a = "juice";
    while(*a!='\0')
    {
        printf("%c",*a);
        a++;
    }
    return 0;
}

四、作为实参传递：
我们经常会遇到的问题就是如何将数组作为实参传递给函数？
如何在函数内部改变数组的值？
函数是很好用的，可以大大简化我们的程序，可是在函数中往往只能return一个变量，如果我们要通过函数改变多个变量的值应该怎么做呢，这里指针就派上用场了。
（1）对单个数进行操作：
比如这种情况：

void change_value(int a,int b)
{
    a = 1;
    b = 2;
}

int main(int argc, char const *argv[])
{
    int a = 10, b = 5;
    printf("a=%d\n",a);
    printf("b=%d\n",b);
    change_value(a,b);
    printf("a=%d\n",a);
    printf("b=%d\n",b);
    return 0;
}

想要在函数中修改a和b的值，可是在函数内部修改不会影响实参。
使用指针：

void change_value(int* p_a,int* p_b)
{
    *p_a = 1;
    *p_b = 2;
}

int main(int argc, char const *argv[])
{
    int a = 10, b = 5;
    printf("a=%d\n",a);
    printf("b=%d\n",b);
    change_value(&a,&b);
    printf("a=%d\n",a);
    printf("b=%d\n",b);
    return 0;
}

使用指针就可以成功修改了。

（2）对数组进行操作：

void change_value(int a[],int a_size)
{
    for (int i = 0;i < a_size;i++)
    {
        a[i] = a[i]*10;
    }
}

void change_value2(int* a,int a_size)
{
    for (int i = 0;i < a_size;i++)
    {
        *(a+i) = *(a+i)/10;
    }
}

int main(int argc, char const *argv[])
{
    int a[] = {1,2,3};
    int a_size = sizeof(a)/sizeof(a[0]);
    for (int i = 0;i < a_size;i++)
    {
        printf("第%d个元素为%d\n",i,a[i]);
    }
    change_value(a, a_size);
    for (int i = 0;i < a_size;i++)
    {
        printf("第%d个元素为%d\n",i,a[i]);
    }
    change_value2(a, a_size);
    for (int i = 0;i < a_size;i++)
    {
        printf("第%d个元素为%d\n",i,a[i]);
    }
    return 0;
}

（3）对字符串：

void change_value(char a[],int a_size)
{
    for (int i = 0;i < a_size;i++)
    {
        a[i] = 'a';
    }
}

void change_value2(char* a,int a_size)
{
    for (int i = 0;i < a_size;i++)
    {
        *(a+i) = 'b';
    }
}

int main(int argc, char const *argv[])
{
    char a[] = "juice";
    int a_size = sizeof(a)/sizeof(a[0])-1;//-1是因为减去最后一位'\0'
    for (int i = 0;i < a_size;i++)
    {
        printf("%c",a[i]);
    }
    change_value(a, a_size);
    printf("\n");
    for (int i = 0;i < a_size;i++)
    {
        printf("%c",a[i]);
    }
    change_value2(a, a_size);
    printf("\n");
    for (int i = 0;i < a_size;i++)
    {
        printf("%c",a[i]);
    }
    return 0;
}

指针还有很多高级的应用，比如二维数组，除了指向变量指针还可以指向函数被称为指向函数的指针等，有待未来继续探索。