【C语言】指针&位运算

谁借莪１个温暖的怀抱￠ 2022-04-23 15:54 299阅读 0赞

### 文章目录 ###

*  一、前言
 *  二、地址和指针的概念
 *  三、变量的指针和指向变量的指针变量
 *   *  3.1 定义一个指针变量
     *  3.2 指针变量的引用
     *   *  3.2.1 "&" 和"\*"说明
     *  3.3 指针变量作为函数参数
 *  四、数组和指针
 *   *  4.1 指向数组元素的指针
     *  4.2 通过指针引用数组元素
     *  4.3 输出数组中的全部元素
     *   *  1、下标法
         *  2、通过数组名计算数组元素地址，找出元素的值
         *  3、 指针变量指向数组元素
     *  4.4 用数组名作函数参数
     *   *  4.4.1 将数组a中n个整数按相反顺序存放
         *  4.4.2 用实参指针改写4.4.1
         *  4.4.3 用选择法对10个整数按由大到小顺序排序
     *  4.5 多维数组和指针
     *   *  4.5.1 指向多维数组元素的指针变量
         *   *  4.5.1.1 指向数组元素的指针变量
             *  4.5.1.2 指向由m个元素组成的一维数组的指针变量
         *  4.5.2 用指向数组的指针作函数参数
         *   *  4.5.2.1 案例一
             *  4.5.2.2 案例二
 *  4.6 字符串和指针
 *   *  4.1 用字符数组存放一个字符串，然后输出该字符串。
     *  4.2 用字符指针指向一个字符串
     *   *  4.2.1 定义字符指针
         *  4.2.2 将字符串a赋值为字符串b
         *  4.2.3 用指针变量来处理例4.2.2问题
         *  4.2.4 字符指针作为函数参数
         *   *  4.2.4.1 用字符数组作参数
             *  4.2.4.2 形参用字符指针变量
         *  4.2.5 使用字符指针变量和字符数组的讨论
         *   *  4.2.5.1 改变指针变量的值
             *  4.2.5.2 用带下标的字符指针变量引用字符串中的字符
 *  五、指向函数的指针
 *   *  5.1 函数指针变量调用函数
     *   *  5.1.1 求a和b中的大者
     *  5.2 指向函数的指针做函数参数
     *   *  5.2.1 案例：函数process，在调用它的时候，每次实现不同的功能
     *  5.3 返回指针值的函数：类型名 \* 函数名(参数表列);
     *   *  5.3.1 指针函数来实现案例
         *  5.3.2 优化5.3.1
     *  5.4 指针数组和指向指针的指针
     *   *  5.4.1 指针数组案例
         *  5.4.2 指向指针的指针案例
         *  5.4.3 指针数组作main函数的形参
         *   *  5.4.3.1
 *  六、有关指针的数据类型和指针运算的小结
 *   *  6.1 有关指针的数据类型的小结
     *  6.2 指针运算小结
     *  6.3 void指针类型
 *  七、位运算
 *   *  7.1 位运算符和位运算
     *   *  7.1.1 按位与运算符“&”
         *  7.1.2 按位或“|”
         *  7.1.3 异或运算符：“^”
         *  7.1.4 取反运算符“~”
         *  7.1.5 左移运算符：“<<”
         *  7.1.6 右移运算符：“>>”
         *  7.1.7 位运算赋值运算符
         *  7.1.8 不同长度的数据进行位运算
         *  7.1.9 位段

# 一、前言 #

指针是C语言中的一个重要概念，也是C语言的一个重要特色。正确而灵活地运用它，可以有效地表示复杂的数据结构；能动态分配内存；方便地使用字符串；有效而方便地使用数组；在调用函数时能获得1个以上的结果；能直接处理内存单元地址等，这对设计系统软件是非常必要的。掌握指针的应用，可以使程序简洁、紧凑、高效。每一个学习和使用C语言的人，都应当深入地学习和掌握指针。可以说，不掌握指针就是没有掌握C的精华。

# 二、地址和指针的概念 #

变量的属性：名、值和地址  
变量的访问方式：直接访问、间接访问  
变量的地址称为该变量的“指针”  
指针变量是存放地址的变量

#include <stdio.h>
    #define CHANGE 1
    
    int main(int argc, char *argv[]) { 
    
        int i,j;
        int *i_pointer,*j_pointer; // 创建指针变量
    
    
        i_pointer = &i; // 变量的地址：该变量的指针
        j_pointer = &j;
        // printf("%d\n",sizeof(i_pointer));
    
        printf("i=%d\n",i); // 通过变量访问：直接访问 
        printf("i=%d\n",*i_pointer); // 通过指针变量访问：间接访问 *i_pointer = i
        return 0;
    }

# 三、变量的指针和指向变量的指针变量 #

变量的指针就是变量的地址。存放变量地址的变量是指针变量，它用来指向另一个变量。为了表示指针变量和它所指向的变量之间的联系，在程序中用“\*”符号表示“指向”。如果已定义i\_pointer为指针变量，则(\*i\_pointer)是i\_pointer所指向的变量。

#include <stdio.h>
    
    int main(int argc, char *argv[]) { 
    
        int i,j;
        int *i_pointer,*j_pointer; // 创建指针变量
    
        i = 12;
        i_pointer = &i; // 指向整型变量i,i_pointer存放的是变量i的地址
        j_pointer = &j;
                                   
        printf("i=%d\n",i); // 通过变量访问：直接访问 
        printf("*i_pointer=%d\n",*i_pointer); // 通过指针变量访问：间接访问 *i_pointer = i
        return 0;
    }

## 3.1 定义一个指针变量 ##

C语言规定所有变量在使用前必须定义，指定其类型，并按此分配内存单元。指针变量不同于整型变量和其他类型的变量，它是用来专门存放地址的，必须将它定义为“指针类型”。
    	定义指针变量的一般形式为
    		基类型 * 指针变量名;
    	可以用赋值语句使一个指针变量得到另一个变量的地址，从而使它指向一个该变量。

> (1)指针变量前面的“\*”表示该变量的类型为指针型变量  
> (2)在定义指针变量时必须指定基类型

## 3.2 指针变量的引用 ##

指针变量中只能存放地址(指针)，不要将一个整数(或其他非地址类型的数据)赋给一个指针变量。
    	有两个有关的运算符：
    	(1)&：取地址运算符
    	(2)*：指针运算符(或称“间接访问”运算符)，取其指向的内容。

通过指针变量访问整型变量

#include <stdio.h>
    
    int main(int argc, char *argv[]) { 
    
      int a, b;
      int *pointer_1, *pointer_2; 
      a = 100;
      b = 10;
    
      pointer_1 = &a;
      pointer_2 = &b;
      printf("%d, %d\n", a, b);
      printf("%d, %d\n", *pointer_1, *pointer_2);
    
      return 0;
    }

![在这里插入图片描述][20190402184513254.png]

### 3.2.1 “&” 和"\*"说明 ###

![在这里插入图片描述][20190402192009115.png]  
输入a和b两个整数，按先大后小的顺序输出a和b

#include <stdio.h>
    
    int main(int argc, char *argv[]) { 
    
      int *p1, *p2, a, b;
      scanf("%d,%d", &a, &b);
      p1 = &a;
      p2 = &b;
    
      if (a < b) { 
    
        p1 = &b;
        p2 = &a;
        
      }
    
      printf("a=%d,b=%d\n", a, b);
      printf("max = %d,min = %d\n", *p1, *p2);
      return 0;
    }

![在这里插入图片描述][2019040219334021.png]

## 3.3 指针变量作为函数参数 ##

![在这里插入图片描述][20190402193445196.png]  
1、输入a和b两个整数，按先大后小的顺序输出a和b

#include <stdio.h>
    
    void swap(int *x, int *y) { 
    
      // int *temp;
      // int i;
      // temp = &i;
      // *temp = *x; // i= a
      // *x= *y;// a= b
      // *y = *temp; // b= i
    
      int i;
      i = *x;
      *x = *y;
      *y = i;
    
      
    }
    
    int main(int argc, char *argv[]) { 
    
      int a, b;
      scanf("%d,%d", &a, &b);
      if (a < b)
        swap(&a, &b);
    
      printf("max=%d min=%d\n", a, b);
      return 0;
    }

![在这里插入图片描述][20190402200326163.png]

2、输入a、b、c这3个整数，按大小顺序输出

#include <stdio.h>
    
    void swap(int *x, int *y) { 
    
      // int *temp;
      // int i;
      // temp = &i;
      // *temp = *x; // i= a
      // *x= *y;// a= b
      // *y = *temp; // b= i
    
      int i;
      i = *x;
      *x = *y;
      *y = i;
    }
    
    void exchange(int *q1, int *q2, int *q3) { 
      if (*q1 < *q2)
        swap(q1, q2);
      if (*q1 < *q3)
        swap(q1, q3);
      if (*q2 < *q3)
        swap(q2, q3);
    }
    
    int main(int argc, char *argv[]) { 
    
      int a, b, c;
      scanf("%d,%d,%d", &a, &b, &c);
    
      exchange(&a, &b, &c);
    
      printf("%d %d %d\n", a, b, c);
      return 0;
    
      
    }

![在这里插入图片描述][20190402200640889.png]

# 四、数组和指针 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70]

## 4.1 指向数组元素的指针 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 1]

#include <stdio.h>
    
    
    int main(int argc, char *argv[]) { 
    
      int a[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    
      int *p;
      p = a;
      p = &a[9];// a[9]指针地址复制给指针p
    
      printf("*p = %d\n", *p);
      return 0;
    }

![在这里插入图片描述][20190402201426297.png]

## 4.2 通过指针引用数组元素 ##

![在这里插入图片描述][20190402202146924.png]

#include <stdio.h>
    
    int main(int argc, char *argv[]) { 
    
      int a[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    
      int *p;
      p = a;
      // p = &a[0];// a[9]指针地址复制给指针p
      *p = 1;
    
      printf("a[0]=%d\n", *p);
      return 0;
    }

![在这里插入图片描述][20190402204930563.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 2]

## 4.3 输出数组中的全部元素 ##

![在这里插入图片描述][20190402221927821.png]

### 1、下标法 ###

#include <stdio.h>
    
    int main(int argc, char *argv[]) { 
    
      int a[10];
      for (int i = 0; i < 10; i++) { 
        scanf("%d", &a[i]);
      }
    
    
      for (int i = 0; i < 10; i++) { 
        printf("%d\n", a[i]); // 下标法
      }
    
      return 0;
    }

### 2、通过数组名计算数组元素地址，找出元素的值 ###

#include <stdio.h>
    
    int main(int argc, char *argv[]) { 
    
      int a[10];
      
      for (int i = 0; i < 10; i++) { 
        scanf("%d", &a[i]);
      }
    
      for (int i = 0; i < 10; i++) { 
        printf("%d", *(a + i)); // 下标法
      }
    
      return 0;
    }

### 3、 指针变量指向数组元素 ###

#include <stdio.h>
    
    int main(int argc, char *argv[]) { 
    
      int a[10];
      int *p;
      p = a;
    
      for (int i = 0; i < 10; i++) { 
        scanf("%d", &a[i]);
      }
    
      for (int i = 0; i < 10; i++) { 
        printf("%d", *(p + i)); // 下标法
      }
    
      return 0;
    }

4、通过指针变量输出a数组的10个元素

## 4.4 用数组名作函数参数 ##

如果一个实参数组，要想在函数中改变此数组中的元素的值，实参与形参的对应关系有以下4种情况

> (1)形参和实参都用数组名  
> (2)实参用数组名，形参用指针变量  
> (3)实参形参都用指针变量  
> (4)实参为指针变量，形参为数组名

### 4.4.1 将数组a中n个整数按相反顺序存放 ###

#include <stdio.h>
    
    void inv(int x[], int n) { 
        
      int i, j;
      for (i = 0, j = n - 1; i <= (n - 1) / 2; i++, j--) { 
        int temp;
        temp = x[i]; // x[i]==*(x+i)
        x[i] = x[j]; // x[j]==*(x+j)
        x[j] = temp;
      }
    }
    
    int main(int argc, char *argv[]) { 
      int a[10];
    
      for (int i = 0; i <= 9; i++)
        scanf("%d", &a[i]);
    
      inv(a, 10);
      for (int i = 0; i <= 9; i++)
        printf("%d,", a[i]);
    
      return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 3]

### 4.4.2 用实参指针改写4.4.1 ###

#include <stdio.h>
    
    void inv(int *x, int n) { 
    
      int i, j;
      for (i = 0, j = n - 1; i <= (n - 1) / 2; i++, j--) { 
          
        // int temp;
        // temp = x[i]; // x[i]==*(x+i)
        // x[i] = x[j]; // x[j]==*(x+j)
        // x[j] = temp;
    
        int temp;
        temp = *(x + i);
        *(x + i) = *(x + j);
        *(x + j) = temp;
    
    
      }
    }
    
    int main(int argc, char *argv[]) { 
      int a[10];
    
      for (int i = 0; i <= 9; i++)
        scanf("%d", &a[i]);
    
      int *p;
      p = a; // 指向数组首地址
      // p = &a[0];
      inv(p, 10);
    
      for (int i = 0; i <= 9; i++)
        printf("%d,", a[i]);
    
      return 0;
    }

### 4.4.3 用选择法对10个整数按由大到小顺序排序 ###

#include <stdio.h>
    
    void sort(int x[], int n) { 
      for (int i = 0; i < n - 1; i++) { 
    
        int p = i;
        for (int j = i + 1; j < n; j++)
          if (x[j] < x[p])
            p = j;// 更新指针
    
        if (p != i) { 
          int temp;
          temp = x[p];
          x[p] = x[i];
          x[i] = temp;
        }
      }
    }
    
    int main(int argc, char *argv[]) { 
    
      int a[10];
      int *p = a;
    
      for (int i = 0; i < 10; i++)
        scanf("%d", p++);
    
      p = a; // 初始化首地址
      sort(p, 10);
    
      for (int i = 0; i < 10; i++)
        printf("%d ", *(p + i));
    
      return 0;
    }

![在这里插入图片描述][20190403003808607.png]

## 4.5 多维数组和指针 ##

![在这里插入图片描述][20190403003907782.png]  
![在这里插入图片描述][20190403003939279.png]

输出二维数组有关的值

#include <stdio.h>
    
    int main(int argc, char *argv[])
    { 
    
      int a[3][4] = { { 1, 3, 5, 7}, { 9, 11, 13, 15}, { 17, 19, 21, 23}};
      printf("%x,%x\n", a, *a); //*a==a[0]
    
      printf("%x,%x\n", a[0], *(a + 0)); //*(a+0)==a[0]
    
      printf("%x,%x\n", &a[0], &a[0][0]); //&a[0]==a+0
    
      printf("%x,%x\n", a[1], a + 1);
    
      printf("%x,%x\n", &a[1][0], *(a + 1) + 0); //*(a+1)==a[1]
    
      printf("%x,%x\n", a[2], *(a + 2)); //*(a+2)==a[2]
    
      printf("%x,%x\n", &a[2], a + 2);
    
      printf("%d,%d\n", a[1][0], *(*(a + 1) + 0));// a+1:第一行 + 0：第一行第0个元素
      return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 4]

### 4.5.1 指向多维数组元素的指针变量 ###

#### 4.5.1.1 指向数组元素的指针变量 ####

用指针变量输出二维数组元素的值

#include <stdio.h>
    
    int main(int argc, char *argv[])
    { 
    
      int a[3][4]={ 0,1,2,3,4,5,6,7,8,9,10,11};
    
      int *p; // 创建指针p
      for (p = a[0]; p < a[0] + 11; p++)
      { 
        if ((p - a[0]) % 4 == 0) // 每四个元素换行
          printf("\n");
        printf("%d ", *p);
    
      }
      printf("\n");
    
      return 0;
    }

![在这里插入图片描述][20190403104513587.png]

#### 4.5.1.2 指向由m个元素组成的一维数组的指针变量 ####

输出二维数组任一行任一列的值

#include <stdio.h>
    
    int main(int argc, char *argv[])
    { 
    
      int a[3][4]={ 0,1,2,3,4,5,6,7,8,9,10,11};
    
      int (*p)[4];  // p是一个指针变量，指向大小为4的一维数组
    
      p = a;// 指向二维数组的第一行的一维数组
    
      int i,j;
      scanf("%d %d",&i,&j);
      printf("%d\n", *(*(p+i)+j)); // p+i行， +j,第j列
    
      return 0;
    }

![在这里插入图片描述][20190403105716424.png]

### 4.5.2 用指向数组的指针作函数参数 ###

一维数组名可以作为函数参数传递，多维数组名也可作函数参数传递。在用指针变量作形参以接受实参数组名传递来的地址时，有两种方法:  
1、用指向变量的指针变量  
2、用指向一维数组的指针变量

#### 4.5.2.1 案例一 ####

有一个班，3个学生，各学4门课，计算总平均分数以及第n个学生的成绩

#include <stdio.h>
    
    float average(float *p, int n)
    { 
    
      float *start;
      float sum = 0.0;
    
      for (start = p; p <= start + n - 1; p++)
      {  // 将指针p赋给start指针，start+n-1:一共的元素
    
        sum += *p; // 统计分数和
      }
      return sum / n; // 返回平均分
    }
    
    
    
    
    void search(float (*p)[4], int n)
    {  // p是一个指针变量，指向大小为4的一维数组
    
      for (int i = 0; i < 4; i++)
      { 
        printf("%f ", *(*(p + n) + i)); // p+n 第n行 +i 第i列
      }
      printf("\n");
    }
    
    
    
    int main(int argc, char *argv[])
    { 
    
      float score[3][4] = { { 65, 67, 70, 60}, { 80, 87, 90, 81}, { 90, 99, 100, 98}};
    
      printf("average=%f\n", average(*score, 12)); //*score==score[0]
    
      search(score, 2); // 行标是2的人的分数
    
      return 0;
    }

![在这里插入图片描述][20190403112415590.png]

#### 4.5.2.2 案例二 ####

在上题基础上，查找有一门以上课程不及格的学生，输出他们的全部课程的成绩

#include <stdio.h>
    
    void search(float (*p)[4], int n) {  // p是一个指针变量，指向大小为4的一维数组
    
      for (int i = 0; i < n; i++) { 
    
        int flag = 0;
        for (int j = 0; j < 4; j++) { 
          if (*(*(p + i) + j) < 60.0) { 
            flag = 1;
            break;
          }
        }
    
    
        // 打印
        if (flag == 1) { 
          printf("%d:\n",i);
          for (int j = 0; j < 4; j++) { 
            printf("%f ", *(*(p + i) + j)); // 第几行第几列
          }
          printf("\n");
        }
      }
    }
    
    int main(int argc, char *argv[]) { 
    
      float score[3][4] = { { 55, 67, 70, 60}, { 50, 87, 90, 81}, { 90, 99, 100, 98}};
      search(score, 3); // 行标是2的人的分数
    
      return 0;
    }

![在这里插入图片描述][20190403123938467.png]

# 4.6 字符串和指针 #

在C程序中，可以用两种方法访问一个字符串

## 4.1 用字符数组存放一个字符串，然后输出该字符串。 ##

1、定义一个字符数组，对它初始化，然后输出该字符串

#include <stdio.h>
    
    int main(int argc, char *argv[])
    { 
    
      char string[] = "I love China!"; // !后面会自动加一个\0
    
      printf("%s\n", string);
    
      //string++;
    
      return 0;
    }

## 4.2 用字符指针指向一个字符串 ##

### 4.2.1 定义字符指针 ###

#include <stdio.h>
    
    int main(int argc, char *argv[])
    { 
    
      // char string[] = "I love China!"; // !后面会自动加一个\0
      char *string = "I love China!";
      printf("%s\n", string);
    
      return 0;
    }

### 4.2.2 将字符串a赋值为字符串b ###

#include <stdio.h>
    
    int main(int argc, char *argv[])
    { 
      int i;
      char a[] = "I am a boy.", b[20];
      for (i = 0; *(a + i) != '\0'; i++)
      { 
        *(b + i) = *(a + i);
      }
    
      *(b + i) = '\0'; // 字符串结束标识
    
      for (i = 0; b[i] != '\0'; i++)
        printf("%c", b[i]);
    
        
      printf("\n");
      printf("%s\n", b);
    
      return 0;
    }

![在这里插入图片描述][20190403133742461.png]

### 4.2.3 用指针变量来处理例4.2.2问题 ###

#include <stdio.h>
    
    int main(int argc, char *argv[])
    { 
      int i;
      char a[] = "I am a boy.", b[20];
    
      char *p, *q;
    
      for (p = a, q = b; *p != '\0'; p++, q++) // p,q分别指向数组a[]和b[]第一个元素
      { 
        *q = *p;
      }
    
      *q = '\0';
      q = b; // 重新初始化
    
      printf("%s\n", q);
    
      return 0;
    }

![在这里插入图片描述][20190403134420724.png]

### 4.2.4 字符指针作为函数参数 ###

将一个字符串从一个函数传递到另一个函数，可以用地址传递的方法，即用字符数组名作参数，也可以用指向字符的指针变量作参数。在被调用的函数中可以改变字符串的内容，在主调函数中可以得到改变了的字符串。

用函数调用实现字符串的复制

#### 4.2.4.1 用字符数组作参数 ####

#include <stdio.h>
    
    void copy_string(char from[], char to[])
    { 
    
      int i = 0;
      while (from[i] != '\0')
      { 
        to[i] = from[i];
        i++;
      }
      to[i] = '\0';
    }
    
    int main(int argc, char *argv[])
    { 
      char a[] = "I am a teacher.";
      char b[] = "You are student.";
    
      printf("string a=%s string b=%s\n", a, b);
      printf("copy string a to string b:\n");
      copy_string(a, b);
      printf("string a=%s string b=%s\n", a, b);
    
      return 0;
    }

![在这里插入图片描述][20190403141414752.png]

#### 4.2.4.2 形参用字符指针变量 ####

#include <stdio.h>
    
    void copy_string(char *from, char *to)
    { 
    
      // 方式一
      // for (; *from != '\0'; from++,to++)
      // { 
      // *to = *from;
      // }
      // *to = '\0';
    
      // 方式二
      // while(*from != '\0'){ 
      // *to = *from;
      // from++;
      // to++;
      // }
    
      // 方式三
      // while (*from != '\0')
      // { 
      // *to++ = *from++;
      // }
    
      // *to = '\0';
    
      // 方式四
      while(*to++ = *from++);
    
    }
    
    int main(int argc, char *argv[])
    { 
      char a[] = "I am a teacher.";
      char b[] = "You are student.";
    
      printf("string a=%s string b=%s\n", a, b);
      printf("copy string a to string b:\n");
    
      char *from = a;
      char *to = b;
    
      copy_string(from, to);
      printf("string a=%s string b=%s\n", a, b);
    
      return 0;
    }

![在这里插入图片描述][20190403142605915.png]

### 4.2.5 使用字符指针变量和字符数组的讨论 ###

虽然用字符数组和字符指针变量都能实现字符串的存储和运算，但它们两者之间是有区别的，不应混为一谈，主要有以下几点。
    (1)字符数组由若干个元素组成，每个元素中放一个字符，而字符指针变量中存放的是地址，决不是将字符串放到字符指针变量中。
    (2)赋值方式。
    (3)对字符指针变量赋初值。
    (4)如果定义了一个字符数组，在编译时为它分配内存单元，它有确定的地址。而定义一个字符指针变量时，给指针变量分配内存单元，在其中可以放一个字符变量的地址，也就是说，该指针变量可以指向一个字符型数据，但如果未对它赋予一个地址值，则它并未具体指向一个确定的字符数据。
    (5)指针变量的值是可以改变的。

#### 4.2.5.1 改变指针变量的值 ####

int main(int argc, char *argv[])
    { 
      char *a = "I love China!";
      a = a + 7;
    
      // char a[] = "I love China!";
      // a = a + 7;
    
      printf("%s", a);
    
      return 0;
    }

#### 4.2.5.2 用带下标的字符指针变量引用字符串中的字符 ####

用指针变量指向一个格式字符串，可以用它代替printf函数中的格式字符串。

int main(int argc, char *argv[])
    { 
    
    
      char *a = "I love China!";
      printf("The sixth character is %c\n", *(a + 5)); //a[5]==*(a+5)
    
      for (int i = 0; *(a + i) != '\0'; i++)
        printf("%c", a[i]);
      printf("\n");
    
      char *format = "a=%d,b=%d\n";
    
      int aa = 1, bb = 2;
      printf(format, aa, bb);
    
      return 0;
    }

![在这里插入图片描述][20190403144942828.png]

# 五、指向函数的指针 #

## 5.1 函数指针变量调用函数 ##

可以用指针变量指向整型变量、字符串、数组，也可以指向一个函数。一个函数在编译时被分配给一个入口地址。这个函数的入口地址就称为函数的指针。可以用一个指针变量指向函数，然后通过该指针变量调用此函数。

### 5.1.1 求a和b中的大者 ###

#include <stdio.h>
    
    int max(int a, int b)
    { 
      if (a > b)
        return a;
      else
    
        return b;
    }
    
    int min(int a, int b)
    { 
      if (a > b)
        return b;
      else
        return a;
    }
    
    
    int main(int argc, char *argv[])
    { 
    
      int a, b;
    	scanf("%d %d", &a, &b);
      printf("max=%d\n", max(a, b));
    
      int (*p)(int,int); // (*p):指针变量---指向函数的类型--->(int,int)：函数形参类型
    
      p = max; // 指向函数首地址
      printf("max=%d\n", (*p)(a, b));
    
      
      return 0;
    }

![在这里插入图片描述][20190403154020436.png]

说明  
(1)指向函数的指针变量的一般定义形式为：数据类型 (\*指针变量名) (函数参数表列);  
(2)函数的调用可以通过函数名调用，也可以通过函数指针调用(即用指向函数的指针表量调用)。  
(3)“int (\*p)(int,int);”表示定义一个指向函数的指针变量p，它不是固定指向哪一个函数的，而是表示定义了这样一个类型的变量，它是专门用来存放函数的入口地址的。  
(4)在给函数指针变量赋值时，只需给出函数名而不必给出参数。  
(5)用函数指针变量调用函数时，只需将(\*p)代替函数名即可，在(\*p)之后的括号中根据需要写上实参。  
(6)对指向函数的指针变量，像p+n、p++等运算是无意义的。

## 5.2 指向函数的指针做函数参数 ##

函数指针变量通常的用途之一是把指针作为参数传递到其他函数。函数的参数可以是变量、指向变量的指针变量、数组名、指向数组的指针变量等。函数的指针也可以作为参数，以实现函数地址的传递，这样就能够在被调用的函数中使用实参函数。

### 5.2.1 案例：函数process，在调用它的时候，每次实现不同的功能 ###

设一个函数process，在调用它的时候，每次实现不同的功能。输入a和b两个数，第一调用process时找出a和b中大者，第二次找出其中小者，第三次求a与b之和

#include <stdio.h>
    
    int max(int a, int b)
    { 
      if (a > b)
        return a;
      else
    
        return b;
    }
    
    int min(int a, int b)
    { 
      if (a > b)
        return b;
      else
        return a;
    }
    
    int add(int a, int b)
    { 
    
      return a + b;
    }
    
    void process(int a, int b, int (*p)(int, int))  // 指向函数的指针做函数参数
    { 
    
      printf("%d\n", (*p)(a, b));
    }
    
    int main(int argc, char *argv[])
    { 
    
      int a, b;
      scanf("%d %d", &a, &b);
    
      process(a, b, max);
      process(a, b, min);
      process(a, b, add);
    
      return 0;
    }

![在这里插入图片描述][20190403160649941.png]

## 5.3 返回指针值的函数：类型名 \* 函数名(参数表列); ##

一个函数可以返回一个整型值、字符值、实型值等，也可以返回指针型的数据，即地址。其概念与以前类似，只是返回的值的类型是指针类型而已。
    这种返回指针值的函数，一般定义形式为
    		类型名 * 函数名(参数表列);

### 5.3.1 指针函数来实现案例 ###

有若干个学生的成绩(每个学生有4门课程)，要求在用户输入学生序号后，能输出该学生的全部成绩。用指针函数来实现

#include <stdio.h>
    
    int *search(int n, int (*p)[4]) // 一维数组指针类型
    { 
      return *(p + n); //*(p+n)==score[n]
    }
    
    
    
    int main(int argc, char *argv[])
    { 
      int score[][4] = { { 1, 2, 3, 4}, { 5, 6, 7, 8}, { 9, 10, 11, 12}};
    
      //score score[0] score[1] score[2]
      int *p = search(1, score);
    
      for (int i = 0; i < 4; i++)
        printf("%d ", *(p + i));
    
      return 0;
    }

![在这里插入图片描述][20190403183321759.png]

### 5.3.2 优化5.3.1 ###

对上例中的学生，找出其中不及格课程的学生及其学生号

#include <stdio.h>
    
    int *search(int (*p)[4])
    { 
      for (int i = 0; i < 4; i++)
      { 
        if (*(*p + i) < 60) // 当前一维数组*p + i第i个元素
        { 
          return *(p + 1); // 指向下一个一维数组指针
        }
      }
    
      return *p; // 一维数组
    }
    
    int main(int argc, char *argv[])
    { 
      int score[][4] = { { 1, 2, 3, 4}, { 5, 6, 7, 8}, { 9, 10, 11, 12}};
    
      for (int i = 0; i < 3; i++)
      { 
        int *p = search(score + i);
    
        if (p != *(score + i)) // 行类型指针
        { 
          printf("student number=%d\n", i);
    
          for (int j = 0; j < 4; j++)
            printf("%d ", *(*(score + i) + j));
          printf("\n");
        }
      }
      return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 5]

## 5.4 指针数组和指向指针的指针 ##

一个数组，若其元素均为指针类型数据，称为指针数组，也就是说，指针数组中的每一个元素都相当于一个指针变量。一维指针数组的定义形式为

类型名 * 数组名[数组长度];
    	例如：int * p[4];

### 5.4.1 指针数组案例 ###

将若干字符串按字母顺序输出

#include <stdio.h>
    #include <string.h>
    
    void sort(char *name[], int n) // 字符指针数组类型
    { 
    
      for (int i = 0; i < n - 1; i++) // 选择法，n个元素需要n-1次排序
      { 
    
        int p = i;
        for (int j = i + 1; j < n; j++)
        { 
          if (strcmp(name[j], name[p]) < 0)
          { 
            p = j; // 改变指针的位置
          }
    
        }
    
        if (p != i)
        { 
          char *temp;
          temp = name[i];
          name[i] = name[p];
          name[p] = temp;
        }
      }
    }
    
    void print(char *name[], int n)
    { 
    
      for (int i = 0; i < n; i++)
      { 
        printf("%s\n", name[i]);
      }
    }
    
    
    
    
    int main(int argc, char *argv[])
    { 
      char *name[5] = { "Follow me", "BASIC", "Great Wall", "FORTRAN", "Computer design"};
    
    
      sort(name, 5);
      print(name, 5);
      return 0;
    
    }

![在这里插入图片描述][20190404092544366.png]

### 5.4.2 指向指针的指针案例 ###

1、使用指向指针的指针

#include <stdio.h>
    
    int main(int argc, char *argv[])
    { 
      char *name[5] = { "Follow me", "BASIC", "Great Wall", "FORTRAN", "Computer design"}; // 字符指针的数组
    
      char **p; // 指向字符指针的指针
      // for (int i = 0; i < 5; i++)
      // { 
      // p = name + i; // 字符指针的指针
      // printf("%s\n", *p); // 第i个元素
      // }
    
      p = name + 1;
      printf("%c\n",**p);
      printf("%c\n", *(*p+1)); // *p--->name[1]
    
      return 0;
    }

![在这里插入图片描述][2019040410302031.png]

2、指针数组的元素指向整型数据

#include <stdio.h>
    
    int main(int argc, char *argv[])
    { 
      int a[5] = { 1, 2, 3, 4, 5};
    
      int *num[5] = { &a[0], &a[1], &a[2], &a[3], &a[4]}; // 指针数组
    
      int **p; // 指向指针的指针
    
      p = num; // 指针数组的第一个元素
    
      for (int i = 0; i < 5; i++)
      { 
        printf("%d ", **p);
        p++;
      }
    
      
    
      return 0;
    }

![在这里插入图片描述][20190404103502847.png]

### 5.4.3 指针数组作main函数的形参 ###

指针数组的一个重要应用是作为main函数的形参。在以往的程序中，main函数的第一行一般写成以下形式：`void main()`括号中是空的。实际上，main函数可以有参数，例如：`void main(int argc, char * argv[])`

#### 5.4.3.1 ####

#include <stdio.h>
    
    int main(int argc, char *argv[]) // *argv[]：指针数组
    { 
    
      for (int i = 0; i < argc; i++)
      { 
        printf("%s\n", argv[i]);
      }
      
      getchar();
    
      return 0;
    }

![在这里插入图片描述][20190404104439591.png]

# 六、有关指针的数据类型和指针运算的小结 #

## 6.1 有关指针的数据类型的小结 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 6]

## 6.2 指针运算小结 ##

(1)指针变量加(减)一个整数

#include <stdio.h>
    
    int main(int argc, char *argv[]) // *argv[]：指针数组
    { 
    
      int a[5] = { 1, 2, 3, 4, 5};
      int *p;
      p = a;
      //printf("%x\n",*p);
      printf("%x\n", p);
      p++;
      printf("%x\n", p);
    
      return 0;
    
      
    }

(2)指针变量赋值

#include <stdio.h>
    
    int main(int argc, char *argv[]) // *argv[]：指针数组
    { 
    
      int a[5] = { 1, 2, 3, 4, 5};
      int *p;
      p = a;
      
      int i = 5;
      p = &i;
    
    
      printf("%d\n",*p);
    
      return 0;
    }

![在这里插入图片描述][20190404105650257.png]  
(3)指针变量可以有空值，即该指针变量不指向任何变量

#include <stdio.h>
    
    int main(int argc, char *argv[]) // *argv[]：指针数组
    { 
    
      int a[5] = { 1, 2, 3, 4, 5};
      int *p;
      p = NULL;
    
      // if(p == NULL){ 
    
      // }else
      // { 
      // /* code */
      // }
    
      printf("%x\n", p);
    
      return 0;
    }

(4)两个指针变量可以相减

#include <stdio.h>
    
    int main(int argc, char *argv[]) // *argv[]：指针数组
    { 
    
      int a[5] = { 1, 2, 3, 4, 5};
      int *p1, *p2;
    
      p1 = &a[0];
      p2 = &a[1];
    
      printf("p2-p1 = %d\n", (p2-p1));
    
      return 0;
    }

(5)两个指针变量比较

#include <stdio.h>
    
    int main(int argc, char *argv[]) // *argv[]：指针数组
    { 
    
      int a[5] = { 1, 2, 3, 4, 5};
      int *p1, *p2;
    
      p1 = &a[0];
      p2 = &a[4];
    
      printf("p2==p1 = %d\n",  p2==p1);
    
      return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 7]

## 6.3 void指针类型 ##

![在这里插入图片描述][2019040411063128.png]

#include <stdio.h>
    #include <malloc.h>
    
    
    int main(int argc, char *argv[]) // *argv[]：指针数组
    { 
    
      char *string;
      string = NULL;
    
      string = (char *)malloc(5);
    
      if (string == NULL)
        printf("Insufficient memory available\n");
      else
      { 
    
        *(string + 0) = 'a';
        *(string + 1) = 'b';
        *(string + 2) = 'c';
        *(string + 3) = 'd';
        *(string + 4) = '\0';
    
        printf("%s\n", string);
    
        free(string);
        printf("Memory freed\n");
      }
    
      return 0;
    }

![在这里插入图片描述][20190404112210109.png]

# 七、位运算 #

![在这里插入图片描述][20190404230930885.png]

## 7.1 位运算符和位运算 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 8]

### 7.1.1 按位与运算符“&” ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 9]

### 7.1.2 按位或“|” ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 10]

### 7.1.3 异或运算符：“^” ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 11]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 12]

#include <malloc.h>
    #include <stdio.h>
    
    // 主函数
    int main(int argc, char *argv[]) // *argv[]：指针数组
    { 
    
      int a = 3;
      int b = 4;
      a = a ^ b;
      b = b ^ a;
      a = a ^ b;
    
      printf("a=%d b=%d\n", a, b);
    
      return 0;
    }

![在这里插入图片描述][20190405003647151.png]

### 7.1.4 取反运算符“~” ###

![在这里插入图片描述][20190405002916487.png]

int a = 122388;
      int c = ~a;
      
      printf("a=%d\n", c);

### 7.1.5 左移运算符：“<<” ###

![在这里插入图片描述][2019040500423967.png]

#include <malloc.h>
    #include <stdio.h>
    
    // 主函数
    int main(int argc, char *argv[]) // *argv[]：指针数组
    { 
    
      int a = 2;
      int c =a<<1;
      
      printf("a=%d\n", c);
    
      return 0;
    }

![在这里插入图片描述][20190405004349728.png]

### 7.1.6 右移运算符：“>>” ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 13]

### 7.1.7 位运算赋值运算符 ###

![在这里插入图片描述][20190405005503347.png]

int a = 0x80000001;
      a = a>>1;
      a>>=1;

### 7.1.8 不同长度的数据进行位运算 ###

![在这里插入图片描述][20190405005754365.png]

### 7.1.9 位段 ###

实际上，有时存储一个信息不必用一个或多个字节，例如，“真”或“假”用0或1表示，只需1位即可。在计算机用于过程控制、参数检测或数据通信领域时，控制信息往往只占一个字节中的一个或几个二进制位，常常在一个字节中放几个信息。  
向一个字节中的一个或几个二进制位赋值和改变它的值，可以用以下两种方法：  
(1)可以人为地将一个整型变量data分为几部分。  
(2)段位结构体  
C语言允许在一个结构体中以位为单位来指定其成员所占内存长度，这样以位为单位的成员称为“位段”或称“位域”。利用位段能够用较少的位数存储数据。例如：

struct packed_data
    		{ 
    			unsigned a:2;
    			unsigned b:6;
    			unsigned c:4;
    			unsigned d:4;
    			int i;
    		} data;

#include <malloc.h>
    #include <stdio.h>
    
    struct packed_data
    { 
    
      unsigned int a : 2; // 占用两个二进制位
      unsigned int b : 3;
      unsigned int c : 4;
       
      int i;
    
    }data;
    // 主函数
    int
    main(int argc, char *argv[]) // *argv[]：指针数组
    { 
    
      data.a = 3;
      data.b = 7;
      data.c =15;
      data.i = 2345678;
      printf("%d %d %d %d\n", data.a, data.b, data.c, data.i);
    
      return 0;
    }

![在这里插入图片描述][20190405100032892.png]  
说明  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 14]  
案例  
1、编写一个函数getbits，从一个16位的单元中取出某几位(即该几位保留原值，其余位为0)。函数调用形式为getbits(value, n1, n2)，value为该16位(2个字节)中的数据值，n1为欲取出的起始位，n2为欲取出的结束位，例如：getbits(0101675,5,8)表示对八进制101675这个数，取出它的从左面起第5位到第8位。

#include <malloc.h>
    #include <stdio.h>
    
    unsigned short getbits(unsigned short int value, int n1, int n2)
    { 
      return (unsigned short int)(value << (n1 - 1)) >> (16 - (n2 - n1 + 1));
      //00000000 00000000 00000000 10000011
    }
    
    // 主函数
    int main(int argc, char *argv[]) // *argv[]：指针数组
    { 
    
      unsigned short int a;
    
      printf("%x\n", getbits(0101675, 5, 8));
    
      return 0;
    }

![在这里插入图片描述][20190405101730597.png]

2、 编写一函数用来实现左右循环移位。函数名为move，调用方法为move(value, n)，其中value为要循环位移的数，n为位移的位数。例如，n<0表示为左移；n>0为右移。n=4表示要右移4位；n=-3表示要左移3位。

#include <malloc.h>
    #include <stdio.h>
    unsigned int move(unsigned int value, int n)
    { 
      unsigned int t1, t2;
      if (n > 0)
      { 
        t1 = value << (32 - n);
        t2 = value >> n;
      }
      else
      { 
        t1 = value >> (32 + n); // 负数
        t2 = value << (-n);
      }
      return t1 | t2;
    
    }
    
    // 主函数
    int main(int argc, char *argv[]) // *argv[]：指针数组
    { 
      unsigned int a;
      a = 0x12345678;
      printf("%x\n", a);
      printf("right>>%x\n", move(a, 4));
      printf("left<<%x\n", move(a, -4));
    
      return 0;
    }

![在这里插入图片描述][20190405103707935.png]

[20190402184513254.png]: /images/20220225/5c26192739414c079cebfb946d13b8db.png
[20190402192009115.png]: /images/20220225/d8685f2a0f7a420f9ee2027b5fd43425.png
[2019040219334021.png]: /images/20220225/a41f2ca21f6f48cc8e2478198a0137cb.png
[20190402193445196.png]: /images/20220225/643ff1c1921e4e749893a08ed1b3ce37.png
[20190402200326163.png]: /images/20220225/8b68c46289654f74bbee644fbdb6fa94.png
[20190402200640889.png]: /images/20220225/37db1e202eb0492bb3f68f8b4f4285b0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70]: /images/20220225/c2a2a6dd824f40c4aa02040fe30fd318.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 1]: /images/20220225/af6e7fec2ee2474b970f3bac654e0f49.png
[20190402201426297.png]: /images/20220225/1a942b8daa77435092fc5c7cdbb91ed0.png
[20190402202146924.png]: /images/20220225/51505dc4852c43fe865cdee33d5af4ae.png
[20190402204930563.png]: /images/20220225/b674f681d69c4f8fbbc8f3aea07a031b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 2]: /images/20220225/fc3447de674844b6947f72f5a9609b6a.png
[20190402221927821.png]: /images/20220225/13667088668440d6ab13a550d82f64be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 3]: /images/20220225/03d79e54c1774496b157e4ae04debdda.png
[20190403003808607.png]: /images/20220225/4152a518206643bb9feea1178e970aba.png
[20190403003907782.png]: /images/20220225/8fc7177fdd46419483952538f916818e.png
[20190403003939279.png]: /images/20220225/ccabf1d7163e438f902cd0167c1f205c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 4]: /images/20220225/fde1324986f044f1bd4e2ce65882a001.png
[20190403104513587.png]: /images/20220225/e746c8a72fbf4e7a8b55f4f7fa0fc7bb.png
[20190403105716424.png]: /images/20220225/6be0a2dab7064aaba0b7c9c513d3c9c2.png
[20190403112415590.png]: /images/20220225/b9aacd0227014db5ad4ef8fc6af432c8.png
[20190403123938467.png]: /images/20220225/ec818f0875034220a71ba0ae05f81192.png
[20190403133742461.png]: /images/20220225/380c7c63c3554d068b8cfb065dcca4fd.png
[20190403134420724.png]: /images/20220225/7afa01dd0d3049ad9c2339c7bd326fa1.png
[20190403141414752.png]: /images/20220225/8a9aad7aa227402286dd1d54b68eb363.png
[20190403142605915.png]: /images/20220225/1de756dd7e9b4e9fb35ece1c7061c593.png
[20190403144942828.png]: /images/20220225/c5a7ba8416b34dfc953bf9a3b40bcca5.png
[20190403154020436.png]: /images/20220225/360449e8e53647ee954ab344693c96ed.png
[20190403160649941.png]: /images/20220225/2c20c5693353492a9225b541e7285700.png
[20190403183321759.png]: /images/20220225/9fdc054f345a48349b43fc8c3f1eba57.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 5]: /images/20220225/8bba2c098ba84b9a99ba5d471d554b66.png
[20190404092544366.png]: /images/20220225/2ff53ffbea984d5d9fd8b8160d960d96.png
[2019040410302031.png]: /images/20220225/2e42f347b38d4adc9c068c6440ad4902.png
[20190404103502847.png]: /images/20220225/67979d5746b64c148900d29e47eac3b0.png
[20190404104439591.png]: /images/20220225/5e0375e0fffd4491838d0d01795ba2d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 6]: /images/20220225/482f1cd52aa5471ab617b89b725df298.png
[20190404105650257.png]: /images/20220225/ad82a55e08a94194b1bed0ff414b85c2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 7]: /images/20220225/89a2cbd8fc294d49baf04c6dd7307de9.png
[2019040411063128.png]: /images/20220225/5fc21571cf2f4616878e4781f381edbc.png
[20190404112210109.png]: /images/20220225/9cf84f653ded4409800dbff133224265.png
[20190404230930885.png]: /images/20220225/5bf795688a4449f2ad9a46e2b7411153.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 8]: /images/20220225/0b9e8946e02d432da3a4c6abd0e79b95.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 9]: /images/20220225/58f95c7066de42bcb1b1a2c14ca5760d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 10]: /images/20220225/d09e8e4b8fd2479d94b51c5fc3625380.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 11]: /images/20220225/3bf11876183f45db8278813a606354f4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 12]: /images/20220225/5c8f88ab5f2642a2b8dd85d7123d832f.png
[20190405003647151.png]: /images/20220225/7eafbf24315a4d5a9fa568c283807754.png
[20190405002916487.png]: /images/20220225/ecb8fec3b0484df396db8c2577fefb72.png
[2019040500423967.png]: /images/20220225/7770d691964e4b04b55c71bcf222c87f.png
[20190405004349728.png]: /images/20220225/9b38abc4e529471196bcb3c400d7a0e5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 13]: /images/20220225/f87fcf73c9c442b784355eaf246a2910.png
[20190405005503347.png]: /images/20220225/39f004f1b01d4fdbbe9b88c81f80c72c.png
[20190405005754365.png]: /images/20220225/53728ef12c0b4b67ac102a36c8cd5755.png
[20190405100032892.png]: /images/20220225/2edf1638163c4b10a49b3a8700893d77.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppYWppa2FuZ19qams_size_16_color_FFFFFF_t_70 14]: /images/20220225/ffac0edd5ae2485dbdff422f0a96cba2.png
[20190405101730597.png]: /images/20220225/2eb1a5bfb2ce43baae1b7b7d1adbe95a.png
[20190405103707935.png]: /images/20220225/fe4075139bf2423b9995492182576aec.png