指针的四方面的内容：指针的类型，指针所指向的类型，指针的值或者叫指针所指向的内存区，还有指针本身所占据的内存区

指针的类型

从语法的角度看，你只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。这是指针本身所具有的类型。让我们看看例一中各个指针的类型：

int *ptr; //指针的类型是int *
char *ptr; //指针的类型是char *
int **ptr; //指针的类型是 int **
int (*ptr)[3]; //指针的类型是 int(*)[3]
int *(*ptr)[4]; //指针的类型是 int *(*)[4]

指针指向的类型

从语法上看，你只须把指针声明语句中的指针名字和名字左边的指针声明符*去掉，剩下的就是指针所指向的类型。例如：

int *ptr; //指针所指向的类型是int
char *ptr; //指针所指向的的类型是char
int **ptr; //指针所指向的的类型是 int *
int (*ptr)[3]; //指针所指向的的类型是 int()[3]
int *(*ptr)[4]; //指针所指向的的类型是 int *()[4]

指针的值或者叫指针所指向的内存区

指针的值是指针本身存储的数值，这个值将被编译器当作一个地址，而不是一个一般的数值。在32位程序里，所有类型的指针的值都是一个32位整数，因为32位程序里内存地址全都是32位长。
指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为sizeof(指针所指向的类型)的一片内存区。以后，我们说一个指针的值是XX，就相当于说该指针指向了以XX为首地址的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内存区域的首地址。

指针本身所占据的内存区

指针本身占了多大的内存？你只要用函数sizeof(指针的类型)测一下就知道了。在32位平台里，指针本身占据了4个字节的长度。

#include<iostream>
using namespace std;
int main(){
    int b[6]={1,2,3,4,5};
    int* c[6];
    int *d;
    *c=b;
    cout<<sizeof(c)<<endl<<sizeof(&c)<<endl<<sizeof(*c)<<endl;
}
sizeof(c)指的是c所指向的内存区的大小为40b
sizeof(&c)指的是指针c的本身地址大小为8b
*c指的是地址
*(*c+2)指的是b[2]
*c[0]指的是数值b[0]
sizeof(*c)指的是大小为8b

二维指针

作用1:在子函数中修改主函数传过来的指针的指向

比如主函数申明一个指针变量，且不为其分配指向空间（只是指向NULL），然后取该指针变量的地址传参给子函数；
在子函数里根据需要申请一片空间；
对传参解引用后得到原来的指针变量，且把该指针变量指向刚才申请的空间（修改了原来指针的指向，这是本质）；
从而实现不确定返回值个数的编程方法（这是应用）；

#include<stdio.h>
int find(char *s, char src, char **rt)//从s中查询出src字符所在的位置并在rt中返回。
{
    int i = 0;
    while (*(s + i))
    {
        if (*(s + i) == src)//只会出现一次满足条件，此时将此地址给*rt，即p
        {
            * rt = s + i;//这里修改了p的指向
        }
        i++;
    }
    return 0;
 }
int main(void)
{
   char a[10] = "zhuyujia";
   char *p=NULL;
   find(a, 'y', &p);//改变p的指向，在子函数中实现
   printf("%s", p);
   getchar(); getchar();
   return 0;
}

#include <stdlib.h>
#include <time.h>
#include<stdio.h>
/*当然有必须使用二级指针才能解决的情况,如,某个函数的功能是
返回某个问题的计算结果,但是结果数据是不确定个数的值,所以
在调用此函数时不知道事先应分配多少空间来保存返回的数据,此时
的处理办法就是传递一个没有分配空间的指针的指针(地址)进去,
让函数自己根据计算的结果分配足够的空间来保存结果,并返回,
调用者使用了结果后,由调用者负责内存的释放,即,大家可能听说
过的"谁使用(调用)谁释放"之类的话,如下面的代码:*/
 
//返回不定结果个数的计算函数
//参数int **pResult  保存返回数据的指针的指针
//参数int &count     保存返回的结果个数
void Compute2(int **pResult, int &count)
{
    //使用随机数来模拟计算结果数的个数
    srand(time(NULL));
    count = rand() % 10;//控制个数在10个以内
 
    *pResult = new int[count];
//注意！！！
//已经确定指向的内存空间不能新赋值，只有指向地址的指针可以新赋值
//*pResult相当于主函数传来的pResult指针，实参&pResult是(int*)的地址，
// 则*pResult则是指针指向的地址
//这里就修改了主函数中的pResult指向，因为还是指针，因此可以指向新开辟的空间
    for (int i = 0; i < count; i++)
    {
        (*pResult)[i] = rand();//给结果随即赋值
    }
}
 
//返回不定结果个数的计算函数(此函数不能返回数据)
//参数int *pResult   为保存返回数据的指针
//参数int &count     为保存返回的结果个数
void Compute1(int *pResult, int &count)
{
    //使用随机数来模拟计算结果数的个数
    srand(time(NULL));
    count = rand() % 10;//控制个数在10个以内
 
    pResult = new int[count];
    for (int i = 0; i < count; i++)
    {
        pResult[i] = rand();//给结果随即赋值
    }
}
 
int main(void)
{
    int *pResult = NULL;//待获取结果的指针，这里没有分配空间大小，因为不知道返回结果的个数
                        //具体返回的个数在在子函数中确定，此时指针pResult指向也改变了
                        //这就间接的说明“在子函数中修改主函数传来的指针”的意图
                        //具体的应用就在于返回个数不确定的场景，这是后面编程的一个体会点
    int count = 0;//返回结果的个数
 
                  /*
                  Compute1(pResult,count);//pResult为指针,第二个参数使用引用传递,
                  //使用这个函数时,在函数内部分配的内存的指针并没有返回到主函数中
                  for ( int i = 0 ; i < count ; i++ )
                  printf("第 %d 个结果为 : %d\n",pResult[i]);//执行了Compute1()函数后,pResult的值还是为NULL
                  delete [] pResult;
                  pResult = NULL;
                  */
 
    Compute2(&pResult, count); //&pResult为指针的地址(即指针的指针),第二个参数使用引用传递
    for (int i = 0; i < count; i++)
        printf("第 %d 个结果为 : %d\n", i, pResult[i]);
 
    delete[] pResult;
    pResult = NULL;
 
    getchar();
    return 0;
}

c++指针