C语言指针

指针：

• 指针的概念：
  指针就是地址。

• 内存：
  内存的每一字节都分配了一个编号，从0x00 00 00 00 开始到 0x ff ff ff ff
  这个编号咱们称之为内存的地址。

• 指针变量：
  存放地址编号的变量被称为指针变量。
  指针变量的分类：
  按类型分:

• 一级指针

char * p ; //字符指针变量 可以保存字符变量的地址，或字符串的地址。
int * p;//整型指针变量 可以保存整型变量的地址
long int *p;
float *p;//浮点型的指针变量，可以保存float类型变量的地址。
double *p //双浮点型的指针
多级指针:指针的指针
char **p;//可以保存char * 类型变量的地址。
int **p;
float **p;
数组指针：
int (*p)[4]; //定义了一个数组指针，p=p+1 一下跳一个整型数组（有四个元素）
函数指针：
int (*p)(char *,int );//定义了一个函数指针变量p ，可以保存函数的入口地址。
注意p所指向的函数，必须有一个int类型的返回值，第一个形参类型必须是char * ,第二个形参必须是int

• 指针数组：
  指针数组，本身是一个数组。

int *p[5];//定义了一个整型的指针数组，数组有5个元素，每个元素都是 int *类型的指针变量。

int (*p[6])(char *,int );//定义了一个函数指针数组，有6个指针，分别是p[0]~p[5]

• 指针和函数的关系：
  指针可以作为函数的返回值
  void * malloc (int size);//malloc这个函数返回的就是一个指针。

举例1：

     char * fun()
     {
          char str[]="hello world";
          return str;
     }
     int main()
     {
          char *p;
          p=fun();
          printf("p=%s\n",p);
     }

 程序的执行结果。
 打印乱码，因为str是一个局部数组，函数调用完毕后str数组就被释放了，内容就不确定了

举例2：

char * fun()
     {
          char *str="hello world";
          return str;
     }
     int main()
     {
          char *p;
          p=fun();
          printf("p=%s\n",p);
     }

 程序执行结果：打印hello world
 因为hello world在文字常量区，返回地址给p赋值，p就指向了文字常量区，文字常量区的东西
 在程序运行过程中一直存在。

举例3：

  char * fun()
   {
        static char str[]="hello world";
        return str;
   }
   int main()
   {
        char *p;
        p=fun();
        printf("p=%s\n",p);
   }

 程序执行结果：打印hello world
 因为str是静态数组，函数结束后，不释放其空间，还存在，所以可以打印str的内容。

指针可以作为函数的参数
1：传变量的地址
例1:

void fun(int *p)
{
     *p=9;
}
int main()
{
     int a=10;
     fun(&a);
     printf("a=%d\n",a);
}

程序的执行结果 a=9;
因为p指向main 函数中的a ，*p =9 其实就是给main函数中的a赋值.

例2:

void fun(int p)
{
     p=9;
}
int main()
{
     int a=10;
     fun(a);
     printf("a=%d\n",a);
}

//此程序执行的结果是 a=10;
注意a给p赋值，p的值是10 然后再fun中重新给p赋值为9 ，
p是一个局部变量，函数结束后p释放了，在fun中没有给main函数中的a赋值，所以
main函数中的a的值还是10

例3:

void fun(char *p)
{
     p="I love China!!!";
}
int main()
{
     char *str="hello world";
     fun(str);
     printf("str=%s\n",str);
}

此程序的运行结果，hello world

调用fun的时候用str给p赋值，p是局部变量，指向了hello world 在fun中
p又指向了 I love China!!!,fun结束后p被释放了，在fun中没有给str赋值。
所以str还是指向helloworld

例4:

void fun(char **p)
{
     *p="I love China!!!";
}
int main()
{
     char *str="hello world";
     fun(&str);
     printf("str=%s\n",str);
}

此程序的运行结果，I love China!!!
因为用str变量的地址给p赋值，*p等价于main函数中str 让其指向I love China!!!

总结：要想改变主调函数中变量的值，必须传变量的地址，无论它是什么类型的变量。

2：传数组的地址

指针可以保存函数的入口地址

传一维数组的地址
// 定义方法1

void fun(int p[])
{

}

// 定义方法二

void fun(int *p)
{
     p[1]=10;
     *(p+1)=10;
}

//方法一和方法二等价，形参将来都认为是 int *类型的

int main()
{
     int a[10];
     fun(a);//传数组的名字
}

传二维数组的地址
// 定义方法1

void fun(int p[][10])//行数可以不给出，但是列数一定要给出。
{

}

// 定义方法二

void fun(int (*p)[10])
{
    
}

//方法一和方法二等价，形参将来都认为是 数组指针类型的。

int main()
{
     int a[4][10];
     fun(a);//传数组的名字,数组的名字就是数组的首地址。
}

传指针数组的地址

int my_strtok(char *q,char *s,char **p)
{
     int i=0;
     p[i]=strtok(q,s);
     while(p[i]!=NULL)
     {
          i++;
          p[i]=strtok(NULL,s);
     }
     return i;
}
int main()
{
     char str[]="秀涛:15010248451:你好，在吗？";
     char *p[4];//该数组有4个元素p[0]~p[3] 每个元素是char *
     char *str1=":";
     int n;
     n=my_strtok(str,str1,p);
     for(i=0;i<3;i++)
     {
    
     }
}

动态内存申请：
动态申请的内存在堆里开辟
malloc
calloc
relloc

void * malloc (int size);
malloc会申请一块连续的size个字节的空间，并且返回首地址
申请的内存里存放的东西是未知的。

void* calloc(int count,int size);
在堆里开辟count块，每一块是size个字节，连续的存储空间，
并且会把申请的内存的每一个字节全部变成0

void *relloc(void *p,int newsize);
接着以前申请的内存（首地址是p）重新申请newsize个字节。
注意p必须指向堆，不能是文字常量区，也不能是静态全局区，也不能是栈区

char *p;
p=(char *)malloc(100);//申请100个字节，让p去指向
如果想追加申请50个字节。
不能再次malloc,因为两次malloc出来的内存，可能不连续
p=(char *)relloc(p,150);//在原先内存的后边追加申请50个字节的空间
如果100字节后边不够50个字节了
重新找一个150个字节的地方，申请150个字节，
将原先100个字节的内容拷贝过来。释放原先的100个字节，返回新内存的首地址。

如果想重新申请50个字节

p=(char *)relloc(p,50);//relloc会将原先100个字节的后边的50个字节释放掉。

释放：
free§;
注意：释放的内存就不能再用了，并且同一块内存，不能释放多次。