iOS 阶段学习第八天笔记（指针）

iOS学习(C语言)知识点整理

一、指针

1）概念：存储变量的地址的一个变量。

2） 数据存储类型分析

   1、text (代码段) ：存储二进制的可执行代码

   2、data（初始化的数据段） 存储初始化的全局变量以及初始化的static修饰的变量，分为只读数据段

     （如：字符串常量，整型常量）及可读可写数据段，静态存储。

   3、data（未初始化的数据段）存储未初始化的全局变量及未初始化的static修饰的变量，静态存储。

   4、heap(堆区) 内存使用需要手动申请，手动释放，空间非常大，通常存储大容量的数据，执行效率比较低

       使用比较麻烦，动态存储。

 5、stack（栈区）内存空间比较小，函数调用局部变量开辟都是栈上，使用效率非常高。

3）取地址符 “&”,间接寻址符 “ * ”，“%p” 打印地址的格式字符

4）指针标示符：* 例如： int *p   表示定义了一个指针p,*是指针标示，int表示p指向的类型(里面存储的是int型变量的地址)

5）各种类型的指针，在内存中拥有的空间都是一样的，64位系统下面都是8个字节(32位是4个字节)。 

6）指针运算 指针对象 ++，表示指向地址向后偏移，偏移量为sizeof(指向的类型)；- -则表示向前偏移。

7）野指针:未初始化值的指针，里面是个随机地址，可以任意修改该地址对应的值，会给系统造成不可控制的影响。

8）空指针 p=NULL=0; 0是非法地址，0地址不可赋值，不可读写。

9）指针的优点

   1、为函数提供修改调用变量的灵活手段

   2、可以使函数有多个返回值

   3、可以改善某些子程序的效率 ,在传递数据时，如果数据块较大（比如数据缓冲区域或比较大的结构），这时就可使用指针传递地址而

        不是实际数据，即可提 高传输速度,又节省大量内存。

  4、为动态数据结构（如 二叉树、链表）提供支持。

10）void* 指针，通配指针，可是指向任意类型。

11）指针的应用，函数中指针作为函数的入参。

12）int *a;  指针变量，指向int型数据。

13）指针数组  即指向一个数组类型的指针   

       例如: int *p[4] : 表示4个指向int的指针.每个指针都是独立的，没有关系; p[i] 是一个 int 型指针

       p[i]=*(p+i)

 实例代码:

int add(int *a[],int len1,int len2)
{
    int sum = 0;
    for(int i=0;i<len1;i++){
        //a[i]第i个指针＝第i个一维数组
        for(int j=0;j<len2;j++){
            sum = sum + *(a[i]+j);
        }
    }
    return sum;
}

int main()
{
    int a[4][3]={{1,2,3},{4,5,6}, {7,8,9},{10,11,12}};
    int *p[4];//指针数组,没初始化不能用，野指针组
    for(int i=0;i<4;i++){
        p[i]=a[i];//a[i]表示第i行的一个数组
    }
   int sum = add(p,4,3);
   printf("sum = %d
",sum);
   return 0;
}

14）数组指针 

实例代码：

int add(int(*p)[3],int len)
{
    int sum = 0;
    for(int i=0;i<len;i++){
        //p+i 表示指向第i个数组 *(p+i)=a[i]
        for(int j=0;j<3;j++){
        //a[i][j] = *(a[i]+j) = *(*(p+i)+j)
            sum = sum + *(*(p+i)+j);
        }
    }

    return sum;
}

int main()
{
    int a[4][3]={{1,2,3},{4,5,6}, {7,8,9},{10,11,12}};
    //a[0],a[1],a[2],a[3]:4个数组都有3个元素
    int(*p)[3];//可以指向一个有3个元素的数组
    //p = &(a[0]);//&a[0] = &(*(a+0))
    p = a;//由上面的那个式子化简
    int sum =add(a, 4);//既然p=a,就可以这么写
    printf("sum %d 
",sum);
 }

15）函数指针  int (*pfunc)(int,int); 定义了一个函数指针，必须要指向 int XXX(int a,int b) 这种样式的函数

 实例代码:

int add(int a,int b)
{
      return a+b;
}

int main(){
    int a = 10;
    int b = 20;
    int sum;
    int (*pfunc)(int,int);

    pfunc = add;//函数名相当于一个指向其函数入口指针常量
    sum = pfunc(a,b);
    printf("sum = %d
",sum);
    return 0;
}

16) 使用指针 实现函数回调

 实现代码:

 void print_hello()
{
    printf("hello world
");
}

 void print_date()
{
    time_t rawtime;
    struct tm * timeinfo;
    time ( &rawtime );
    //获取系统本地时间 需要引用 time头文件 ,#include <time.h>
    timeinfo = localtime ( &rawtime );
     printf ( "%4d-%02d-%02d %02d:%02d:%02d
",1900+(*timeinfo).tm_year, 1+(*timeinfo).tm_mon,
            (*timeinfo).tm_mday,(*timeinfo).tm_hour,(*timeinfo).tm_min,(*timeinfo).tm_sec);
}

// void(*pfunc)()
void print_all(void(*pfunc)(),int count)
{
    for(int i=0;i<count;i++){
        pfunc();
    }
}
 
int main()
{
    print_all(print_date,4);//循环输出4次
    print_all(print_hello,1);
    return 0;
}

17）使用指针实现递归算法

 实现代码:

void sort_array(int *a,int len){
   //冒泡排序
   int temp;
   for(int i=0;i<len-1;i++){ 
        for(int j=0;j<len-1-i;j++){
         if(*(a+j)>*(a+j+1))
            {
               temp = *(a+j);
               *(a+j) = *(a+j+1);
              *(a+j+1) = temp;
             }
         }
     }
}

int main(){
   int a[5]={1,20,30,4,5};
   int *p;
   p = a;
   //传递数组：2种形式 数组或者指针
   print_array(a, 5); 
   return 0;
} 

18）二级指针 指向指针的指针。

 实例代码：

void swap(int **p,int **q)
{
    int temp;
    temp = **p;
    **p = **q;
    **q = temp;
}
 
int main()
{
    int a = 10;
    int b = 20;
    int *p = &a;//p是一个指针，指向int型
    int **q;//q是一个指针，指向 int *型，int* 型就是指向int的指针类型,p就是这样一个类型
    q = &p;//*q=*(&p)=p
    printf("%d
",**q);//*q=p,**q=*p=a
    int *p_b = &b;
    int **pp_b = &p_b;
    swap(q,pp_b);
    printf("a=%d,b=%d
",a,b);
    return 0;
}

19）const 修饰符，只读  表现形式： const 数据类型 变量名 ,const 直接修饰的变量不可以改变，但加了*的变量可修改。

 实例代码:

int main()
{
    int value1 = 10;
    int value2 = 20;
    const int a = 100;
    printf("a=%d
",a);
    a = 20;//const修饰的变量不能修改
    const int *p = &value1;
    p = &value2;
    //*p = 100;//*p不可以修改，p可以改
    int const *m = &value1;
    m = &value2;
    //*m = 10;//*m不可以修改，m可以改
    int *const n;//n不可以改，*n可以改
    const int *const q//q不可以改，*q不可以改
    const int *const m,*n;//m,*m不可以改，n可以改
    *n =100;//*n也不可以改
    const int *const m, *const n;//m,*m,n不可以改
    *n = 100;//*n也不可以改
    int *const m, *const n;//m,n不可以改，*m,*n可以改，
    *n = 100;
}