学习指针的笔记

指针

在C语言中，内存单元的地址称为指针，专门用来存放地址的变量，称为指针变量

在不影响理解的情况中，有时对地址、指针和指针变量不区分，通称指针

指针的基本用法

指针变量的说明

一般形式如下：

<存储类型>   <数据类型>   * <指针变量名>; 

例如，

char  *pName ;

指针的存储类型是指针变量本身的存储类型。

指针说明时指定的数据类型不是指针变量本身的数据类型，而是指针目标的数据类型。简称为指针的数据类型。

指针在说明的同时， 也可以被赋予初值，称为指针的初始化

一般形式是：

<存储类型>  <数据类型>  *<指针变量名> = <地址量> ; 

​ 例如：

int a,  *pa=&a;

​ 在上面语句中，把变量a的地址作为初值赋予了刚说明的int型指针pa。

int a  3;   //int a; a = 3;
int *pa = &a; //int * pa; pa = &a;

指针的目标

指针指向的内存区域中的数据称为指针的目标

如果它指向的区域是程序中的一个变量的内存空间，则这个变量称为指针的目标变量。 简称为指针的目标。

px、*px 和 &px 三种表示方法的不同意义

引入指针要注意程序中的px、*px 和 &px 三种表示方法的不同意义。设px为一个指针，则:

• px — 指针变量，它的内容是地址量

• *px — 指针所指向的对象， 它的内容是数据

• &px— 指针变量占用的存储区域的地址，是个常量

  ​

指针的运算

指针运算

概念：

指针运算是以指针变量所存放的地址量作为运算量而进行的运算

指针运算的实质就是地址的计算

指针运算的种类是有限的，它只能进行赋值运算、算术运算和关系运算

指针的赋值运算

指针的赋值运算指的是通过赋值运算符向指针变量送一个地址值

向一个指针变量赋值时，送的值必须是地址常量或指针变量，不能是普通的整数(除了赋零以外)

指针赋值运算常见的有以下几种形式:

把一个普通变量的地址赋给一个具有相同数据类型的指针

double  x=15, *px;
 px=&x;

把一个已有地址值的指针变量赋给具有相同数据类型的另一个指针变量.例如：

float  a, *px, *py; 
px = &a;
py = px;

​ 把一个数组的地址赋给具有相同数据类型的指针。例如:

int  a[20],  *pa;
pa = a;   //等价 pa = &a[0]

指针的算术运算

运算符	计算形式	意义
+	px+n	指针向地址大的方向移动n个数
-	px-n	指针向地址小的方向移动n个数
++	px++或++px	指针向地址大的方向移动1个数
–	px–或--px	指针向地址小的方向移动1个数
-	px-py	两个指针之间相隔数据元素的个数

注意

• 不同数据类型的两个指针实行加减整数运算是无意义的

• px+n表示的实际位置的地址量是：

• (px) + sizeof(px的类型) *n

• px-n表示的实际位置的地址量是：

• (px) - sizeof(px的类型) *n

两指针相减运算

• px-py 运算的结果是两指针指向的地址位置之间相隔数据的个数因.此，两指针相减不是两指针持有的地址值相减的结果。

• 两指针相减的结果值不是地址量，而是一个整数值，表示两指针之间相隔数据的个数。

指针的关系运算

• 两指针之间的关系运算表示它们指向的地址位置之间的关系。指向地址大的指针大于指向地址小的指针。

• 指针与一般整数变量之间的关系运算没有意义。但可以和零进行等于或不等于的关系运算，判断指针是否为空。

举例

       int  main()
       {   
             int   a[]={5,8,7,6,2,7,3};
             int y,*p=&a[1];

             y=(*--p)++;

             printf(“%d  ”,y);
             printf(“%d”,a[0]);
         } 
//输出5 6，演示过程见PPT指针（二）

int  main()
{ 
    int i, *p, a[7];
    p = a;
    for(i = 0; i<7; i++)
       scanf("%d", p++);
    printf("\n");

    p = a;
    for(i=0;i<7;i++) {
       printf("%d",*p);
       p++;
   }
}

指针与数组

• 在C语言中，数组的指针是指数组在内存中的起始地址，数组元素的地址是指数组元素在内存中的起始地址

• 一维数组的数组名为一维数组的指针（起始地址）

例如

double   x[8];

因此，x为x数组的起始地址

设指针变量px的地址值等于数组指针x（即指针变量px指向数组的首元数），则：

• x[i] 、(px+i)、(x+i) 和px[i]具有完全相同的功能：访问数组第i+1个数组元素

int a[10], * p; p=a;

• 注意：指针变量和数组在访问数组中元素时，一定条件下其使用方法具有相同的形式，因为指针变量和数组名都是地址量

• 但指针变量和数组的指针（或叫数组名）在本质上不同，指针变量是地址变量，而数组的指针是地址常量

例：int a[]={1,2,3,4,5,6,7,8,9,10}, *p = a, i;数组元素地址的正确表示是：

• （A）&(a+1) （B）a++ （C）&p D）&p[i]

数组名是地址常量

• p++,p-- (对)

• a++,a-- (错)

• a+1, *(a+2) (对)

  程序举例

  编写一个函数，将整形数组中n个数按反序存放

  #include<stdio.h>
  int main()
  {
  	void inv(int *x,int n);
  	int i;
  	int arr[10];
  	int *p = arr;
  	printf("the original array:");
  	for(i = 0;i < 10;i++,p++)
  	{
  		scanf("%d",p);
  	}
  	printf("\n");
  	p = arr;
  	inv(p,10);
  	printf("the array has been inverted:\n");
  	for(p = arr;p < arr+10;p++)
  	{
  		printf("%5d",*p);
  	}
  	printf("\n");
  	return 0;
  }
   
  void inv(int *x,int n)
  {
  	int temp;
  	int *p;
  	int *i;
  	int *j;
  	int m = (n-1)/2;
  	i = x;
  	j = x+n-1;
  	p = x+m;
  	for(;i <= p;i++,j--)
  	{
  		temp = *i;
  		*i = *j;
  		*j = temp;
  	}
  	return;
  }
  

  ​

指针与二维数组

多维数组就是具有两个或两个以上下标的数组

在C语言中，二维数组的元素连续存储，按行优先存

一级指针遍历二维数组

/**
使用1级指针访问二维数组
因为数组本身在地址空间中就是连续排列的，根据行数和列数，
    计算出访问单元的 地址偏移量 就可以用一级指针遍历二维数组中的所有数据。
*/
#include<stdio.h>
int main()
{
    int array[2][3] ={{1,2,3},{4,5,6}};
    int *pArray = NULL;
    pArray = array;
    printf("array[0][0] = %d\n", *pArray);
    printf("array[1][2] = %d\n", *(pArray + 1 * 3 + 2));//访问1行2列的二维数组
    printMatirx(array,2,3);//打印2行3列的数组
    return 0;
}
void printMatirx(int *pArray,int rows,int cols)
{
    int i;
    int j;
    for(i=0;i<rows;i++)
    {
        for(j=0;j< cols;j++)
        {
            printf("%d\t",*(pArray+i*cols+j));//访问i行j列的二维数组元素
        }
        printf("\n");
    }
}

行地址

可把二维数组看作由多个一维数组组成。

• 比如int a[3][3]，含有三个元素：a[0]、a[1]、a[2]
  元素a[0]、a[1]、a[2]都是一维数组名
  

二维数组名代表数组的起始地址，数组名加1，是移动一行元素。因此，二维数组名常被称为行地址

行指针（数组指针）

存储行地址的指针变量，叫做行指针变量。形式如下：

• <存储类型> <数据类型> (*<指针变量名>)[表达式] ;

例如，

int a[2][3];  int (*p)[3];

方括号中的常量表达式表示指针加1，移动几个数据。

当用行指针操作二维数组时，表达式一般写成1行的元素个数，即列数。

//编程实现，使用行指针表示二维数组int a[2][4]的元素a[1][1]
int (*p)[5];

字符指针与字符串

• C语言通过使用字符数组来处理字符串

• 通常，我们把char数据类型的指针变量称为字符指针变量。字符指针变量与字符数组有着密切关系，它也被用来处理字符串。

• 初始化字符指针是把内存中字符串的首地址赋予指针，并不是把该字符串复制到指针中

     char  str[] =“Hello World”;
     char  *p = str;
  

  • 在C编程中，当一个字符指针指向一个字符串常量时，不能修改指针指向的对象的值

  • char * p =“Hello World”;

  • *p = ‘h’; // 错误， 字符串常量不能修改

  不利用任何字符串函数，编程实现字符串连接函数的功能。
  

  ​

指针数组

所谓指针数组是指由若干个具有相同存储类型

和数据类型的指针变量构成的集合

指针数组的一般说明形式：

• <存储类型> <数据类型> *<指针数组名>[<大小>]；

• 指针数组名表示该指针数组的起始地址

  声明一个指针数组：

  double  * pa[2] ，a[2][3];
  

  把一维数组a[0]和a[1]的首地址分别赋予指针变量数组的数组元数pa[0]和pa[1]：

   pa[0]=a[0];       // 等价pa[0] = &a[0][0];
   pa[1]=a[1];        // 等价pa[1] = &a[1][0];
  

  此时pa[0]指向了一维数组a[0]的第一个元素a[0][0],而pa[1]指向了一维数组a[1]的第一个元素a[1][0]。
  

编程：利用指针数组处理一个二维数组，要求求出二维数组所有元素的和。

多级指针

• 把一个指向指针变量的指针变量，称为多级指针变量

• 对于指向处理数据的指针变量称为一级指针变量，简称一级指针

• 而把指向一级指针变量的指针变量称为二级指针变量，简称二级指针

• 二级指针变量的说明形式如下

    <存储类型>  <数据类型>  ** <指针名>； 
  

  多级指针的运算

  • 指针变量加1，是向地址大的方向移动一个目标数据。类似的道理，多级指针运算也是以其目标变量为单位进行偏移。
    
    比如，int **p；p+1移动一个int *变量所占的内存空间。再比如int ***p，p+1移动一个int **所占的内存空间。
    

  指针数组也可以用另外一个指针来处理。
   例如：有一个一维字符指针数组ps[5]，
  char *ps[5]= {  "Beijing city",
                 	……
                 	"London city"  } ; 
  
  

  定义另一个指针变量pps，并且把指针数组的首地址赋予指针pps

  char *ps[5]={……};char ** pps = ps;

  

void指针和const

void指针

void指针是一种不确定数据类型的指针变量，它可以通过强制类型转换让该变量指向任何数据类型的变量

一般形式为： void   * <指针变量名称>;

对于void指针，在没有强制类型转换之前，不能进行任何指针的算术运算

编程实现：使用void指针遍历一维数组
void * malloc(size_t size);
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine)(void *), void *arg);
void qsort(void *base,  size_t nmemb,  size_t size,   int(*compar)(const void *, const void *));

const变量

常量化变量的值

一般说明形式如下：

const <数据类型> 变量名 = [<表达式>] ;

常量化变量是为了使得变量的值不能修改

变量有const修饰时，若想用指针间接访问变量，指针也要有const修饰。const放在指针声明的什么位置呢？

常量化指针目标表达式

一般说明形式如下：

const<数据类型>* <指针变量名称>[=<指针运算表达式>];

常量化指针目标是限制通过指针改变其目标的数值 ，但<指针变量>存储的地址值可以修改

常量化指针变量

一般说明形式如下：

<数据类型>* const  <指针变量名称>[=<指针运算表达式>];

使得<指针变量>存储的地址值不能修改。但可以通过 *<指针变量名称> 可以修改指针所指向变量的数值

常量化指针变量及其目标表达式

一般说明形式如下：

const<数据类型>* const <指针变量名>= <指针运算表达式>; 

#### const变量

常量化变量的值

一般说明形式如下：

const <数据类型> 变量名 = [<表达式>] ;

常量化变量是为了使得变量的值不能修改

变量有const修饰时，若想用指针间接访问变量，指针也要有const修饰。const放在指针声明的什么位置呢？

##### 常量化指针目标表达式  

一般说明形式如下： 

const<数据类型>* <指针变量名称>[=<指针运算表达式>];

常量化指针目标是限制通过指针改变其目标的数值 ，但<指针变量>存储的地址值可以修改

##### 常量化指针变量

一般说明形式如下： 

<数据类型>* const <指针变量名称>[=<指针运算表达式>];

使得<指针变量>存储的地址值不能修改。但可以通过 *<指针变量名称> 可以修改指针所指向变量的数值

##### 常量化指针变量及其目标表达式 

一般说明形式如下： 

const<数据类型>* const <指针变量名>= <指针运算表达式>;

常量化指针变量及其目标表达式，使得既不可以修改<指针变量>的地址，也不可以通过*<指针变量名称>修改指针所指向变量的值