C语言 基础七 指针

一、指针的定义
指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。
例：

int    *ip;    /* 一个整型的指针 */
double *dp;    /* 一个 double 型的指针 */
float  *fp;    /* 一个浮点型的指针 */
char   *ch;     /* 一个字符型的指针 */

其中*星号是用来指定一个变量是指针，所有实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，对应指针的值的类型都是一样的，都是一个代表内存地址的长的十六进制数。
不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。

实例

#include <stdio.h>

int main ()
{
    int var = 20;   /* 实际变量的声明 此时的 VAR 这个变量是存在某个地址的，
                       地址对应某个内存单元，该单元中存储了数据20 */
    int *ip;        /* 指针变量的声明 定义了一个指针 即一个内存单元的地址变量 */
    ip = &var;      /* 在指针变量中存储 var 的地址 就是将地址值赋值给指针这个变量*/
    /* 在指针变量中存储的地址 利用&符号直接输出了var所存储的数据的内存单元的地址*/
    printf("Address of var variable: %p\n", &var );
  
    /* 在指针变量中存储的地址 ip代表的是这个赋值到的地址的值 所以输出的是地址值 */
    printf("Address stored in ip variable: %p\n", ip );
    
    /* 使用指针访问值 *ip代表的是定义到这个内存单元之后，
    内存单元中所存储的数据的值也就是将20赋值给var中20这个值 */
    printf("Value of *ip variable: %d\n", *ip );
    return 0;
}

结果

Address of var variable: bffd8b3c
Address stored in ip variable: bffd8b3c
Value of *ip variable: 20

指针的复杂说明

二、 指针的算术运算

指针是一个用数值表示的地址。因此可以对指针执行算术运算。可以对指针进行四种算术运算：++、–、+、-。

• 假设 ptr 是一个指向地址 1000 的整型指针，是一个 32 位的整数，我们对该指针执行下列的算术运算： ptr++
  在执行完上述的运算之后，ptr 将指向位置 1004，因为 ptr 每增加一次，它都将指向下一个整数位置，即当前位置往后移 4 字节。这个运算会在不影响内存位置中实际值的情况下，移动指针到下一个内存位置。
• 假设 ptr 指向一个地址为 1000 的字符，上面的运算会导致指针指向位置 1001，因为下一个字符位置是在 1001。

总结一下：

• 指针的每一次递增，它会指向下一个元素的存储单元。
• 指针的每一次递减，它会指向前一个元素的存储单元。
• 指针在递增和递减时跳跃的字节数取决于指针所指向变量数据类型长度，比如 int 就是 4 个字节。

我们习惯于在程序中使用指针代替数组，因为变量指针可以递增，而数组不能递增，数组可以看成一个指针常量。下面的程序递增变量指针，以便顺序访问数组中的每一个元素：

实例

#include <stdio.h>
 
const int MAX = 3;
 
int main ()
{
   int  var[] = {10, 100, 200};
   int  i, *ptr;
 
   /* 指针中的数组地址 */
   ptr = var;   //var代表数组的第一个元素所在地址，所以不需要在var前面加&
   for ( i = 0; i < MAX; i++)
   {
 
      printf("存储地址：var[%d] = %x\n", i, (unsigned int)ptr );
      printf("存储值：var[%d] = %d\n", i, *ptr );
 
      /* 移动到下一个位置 */
      ptr++;
   }
   return 0;
}

结果：

存储地址：var[0] = bf882b30
存储值：var[0] = 10
存储地址：of var[1] = bf882b34
存储值： var[1] = 100
存储地址：of var[2] = bf882b38
存储值：var[2] = 200

对指针进行递减运算，即把值减去其数据类型的字节数。

实例

#include <stdio.h>
 
const int MAX = 3;
 
int main ()
{
   int  var[] = {10, 100, 200};
   int  i, *ptr;
 
   /* 指针中最后一个元素的地址 */
   ptr = &var[MAX-1];
   for ( i = MAX; i > 0; i--)
   {
 
      printf("存储地址：var[%d] = %x\n", i-1, (unsigned int)ptr );
      printf("存储值：var[%d] = %d\n", i-1, *ptr );
 
      /* 移动到下一个位置 */
      ptr--;
   }
   return 0;
}

结果：

存储地址：var[2] = 518a0ae4
存储值：var[2] = 200
存储地址：var[1] = 518a0ae0
存储值：var[1] = 100
存储地址：var[0] = 518a0adc
存储值：var[0] = 10

指针的比较
指针可以用关系运算符进行比较，如 ==、< 和 >。如果 p1 和 p2 指向两个相关的变量，比如同一个数组中的不同元素，则可对 p1 和 p2 进行大小比较。例：

#include <stdio.h>
 
const int MAX = 3;
 
int main ()
{
   int  var[] = {10, 100, 200};
   int  i, *ptr;
 
   /* 指针中第一个元素的地址 */
   ptr = var;
   i = 0;
   while ( ptr <= &var[MAX - 1] )
   {
 
      printf("Address of var[%d] = %p\n", i, (unsigned int)ptr );
      printf("Value of var[%d] = %d\n", i, *ptr );
 
      /* 指向上一个位置 */
      ptr++;
      i++;
   }
   return 0;
}

结果：

Address of var[0] = bfdbcb20
Value of var[0] = 10
Address of var[1] = bfdbcb24
Value of var[1] = 100
Address of var[2] = bfdbcb28
Value of var[2] = 200

三、指针数组和数组指针
1、指针数组
想要让数组存储指向 int 或 char 或其他数据类型的指针。下面是一个指向整数的指针数组的声明：

int *ptr[MAX];

在这里，把 ptr 声明为一个数组，由 MAX 个整数指针组成。因此，ptr 中的每个元素，都是一个指向 int 值的指针。

实例

#include <stdio.h>
 
const int MAX = 3;
 
int main ()
{
   int  var[] = {10, 100, 200};
   int i, *ptr[MAX];
 
   for ( i = 0; i < MAX; i++)
   {
      ptr[i] = &var[i]; /* 赋值为整数的地址 */
   }
   for ( i = 0; i < MAX; i++)
   {
      printf("Value of var[%d] = %d\n", i, *ptr[i] );
   }
   return 0;
}

结果：

Value of var[0] = 10
Value of var[1] = 100
Value of var[2] = 200

2、数组指针
数组的指针，实际是一个指针，长度固定(32 位系统下占 4 个字节)，这个指针指向数组，但指向的数组占多少个字节不确定。

#include <stdio.h>
 
int main ()
{
	int a[5] = { 1,2,3,4,5 };    //定义一个一维数组 a
	int (*prt)[5];      // 步长为 5 的数组指针，即 prt 指向的数组里有 5 个元素  
	prt = &a;    // 把数组 a 的地址付给 prt，则 prt 为数组 a 的地址，*prt 表示数组 a 本身
	prt[ 0 ];    //表示数组首元素的地址
	*prt[ 0 ]；  //表示数组的首元素的值，即为数组 a 的 1
	**prt;       //表示数组的首元素的值，即为数组 a 的 1
	*prt[ 1 ] ;  //表示指向数组的下一行元素的首元素的值，但是a是一维数组，只有一行，所以指向的地址中的值不确定
	return 0;
}

注意：数组指针加 1，步长为所指向数组的列数，即为下一行的首地址，只在二维及以上维度的数组中有意义，一维数组只有一行，无意义。

四、指向指针的指针

指向指针的指针是一种多级间接寻址的形式，或者说是一个指针链。通常，一个指针包含一个变量的地址。当我们定义一个指向指针的指针时，第一个指针包含了第二个指针的地址，第二个指针指向包含实际值的位置。
一个指向指针的指针变量必须如下声明，即在变量名前放置两个星号。

int **var;

当一个目标值被一个指针间接指向到另一个指针时，访问这个值需要使用两个星号运算符
实例

#include <stdio.h>
 
int main ()
{
   int  var;
   int  *ptr;
   int  **pptr;

   var = 3000;

   /* 获取 var 的地址 */
   ptr = &var;

   /* 使用运算符 & 获取 ptr 的地址 */
   pptr = &ptr;

   /* 使用 pptr 获取值 */
   printf("Value of var = %d\n", var );
   printf("Value available at *ptr = %d\n", *ptr );
   printf("Value available at **pptr = %d\n", **pptr);

   return 0;
}

结果

Value of var = 3000
Value available at *ptr = 3000
Value available at **pptr = 3000

五、传递指针给函数

C 语言允许传递指针给函数，只需要简单地声明函数参数为指针类型即可。
实例

#include <stdio.h>
#include <time.h>
 
void getSeconds(unsigned long *par);

int main ()
{
   unsigned long sec;

   getSeconds( &sec );

   /* 输出实际值 */
   printf("Number of seconds: %ld\n", sec );

   return 0;
}

void getSeconds(unsigned long *par)
{
   /* 获取当前的秒数 */
   *par = time( NULL );
   return;
}

结果

Number of seconds :1294450468

也可以接受数组指针作为参数。
实例

#include <stdio.h>
 
/* 函数声明 */
double getAverage(int *arr, int size);
 
int main ()
{
   /* 带有 5 个元素的整型数组  */
   int balance[5] = {1000, 2, 3, 17, 50};
   double avg;
 
   /* 传递一个指向数组的指针作为参数 */
   avg = getAverage( balance, 5 ) ;
 
   /* 输出返回值  */
   printf("Average value is: %f\n", avg );
   
   return 0;
}

double getAverage(int *arr, int size)
{
  int    i, sum = 0;      
  double avg;          
 
  for (i = 0; i < size; ++i)
  {
    sum += arr[i];
  }
 
  avg = (double)sum / size;
 
  return avg;
}

结果

Average value is: 214.40000

六、函数指针（指向函数的指针）

一个函数在编译之后，会占据一部分内存，而它的函数名，就是这段函数的首地址。

可以把一个指针声明成为一个指向函数的指针。

C 语言规定函数名会被转换为指向这个函数的指针，除非这个函数名作为 & 操作符或 sizeof 操作符的操作数(注意：函数名用于 sizeof 的操作数是非法的)。也就是说 f = test; 中 test 被自动转换为 &test，而 f = &test; 中已经显示使用了 &test，所以 test 就不会再发生转换了。因此直接引用函数名等效于在函数名上应用 & 运算符，两种方法都会得到指向该函数的指针。

指向函数的指针必须初始化，或者具有 0 值，才能在函数调用中使用。

与数组一样：

（1）禁止对指向函数的指针进行自增运算++。
（2）禁止对函数名赋值，函数名也不能用于进行算术运算。

例1

int fun1(int,int);
int fun1(int a, int b){ 
    return a+b;
}
int main(){
    int (*pfun1)(int,int); 
    pfun1=fun1;//这里&fun1和fun1的值和类型都一样，用哪个无所谓 
    int a=(*pfun1)(5,7); //通过函数指针调用函数。
    return 0;
}

例2

#include <stdio.h>​ ​
void test( )​{​
    printf("test called!/n");​
}​ ​
int main( )​{​   
    void (*f) ( );​   
    f = test; ​    
    f ( );​ 
    (*f)( );​    
    //test++;             // error，标准禁止对指向函数的指针进行自增运算​          
    //test = test + 2;    // error，不能对函数名赋值，函数名也不能用于进行算术运算​          
    printf("%p/n", test);​          
    printf("%p/n", &test);​          
    printf("%p/n", *test);​  
    return 0;
​}

结果

test called!
​test called!
test called!

*test 为什么能和上面两个之前介绍过的输出一样的值？

首先来看函数名 test，是一个符号用来标识一个函数的入口地址，在使用中函数名会被转换为指向这个函数的指针，指针的值就是函数的入口地址，&test 在前面已经说了：显示获取函数的地址。*test 可以认为由于 test 已经被转换成了函数指针, 指向这个函数，所以 *test 就是取这个指针所指向的函数名，而又根据函数名会被转换指向该函数的指针的规则，这个函数也转变成了一个指针，所以 *test 最终也是一个指向函数 test 的指针。也就是说:*test --> *(&test) --> test --> &test

七、指针函数（返回值为指针的函数）

C 允许您从函数返回指针。为了做到这点，您必须声明一个返回指针的函数。

int * myFunction()
{
}

实例

#include <stdio.h>
#include <time.h>
#include <stdlib.h> 
 
/* 要生成和返回随机数的函数 */
int * getRandom( )
{
   static int  r[10];
   int i;
 
   /* 设置种子 */
   srand( (unsigned)time( NULL ) );
   for ( i = 0; i < 10; ++i)
   {
      r[i] = rand();
      printf("%d\n", r[i] );
   }
 
   return r;
}
 
/* 要调用上面定义函数的主函数 */
int main ()
{
   
   int *p;/* 一个指向整数的指针 */
   int i;
 
   p = getRandom();
   for ( i = 0; i < 10; i++ )
   {
       printf("*(p + [%d]) : %d\n", i, *(p + i) );
   }
 
   return 0;
}

结果

1523198053
1187214107
1108300978
430494959
1421301276
930971084
123250484
106932140
1604461820
149169022
*(p + [0]) : 1523198053
*(p + [1]) : 1187214107
*(p + [2]) : 1108300978
*(p + [3]) : 430494959
*(p + [4]) : 1421301276
*(p + [5]) : 930971084
*(p + [6]) : 123250484
*(p + [7]) : 106932140
*(p + [8]) : 1604461820
*(p + [9]) : 149169022

注：
C 不支持在调用函数时返回局部变量的地址，除非定义局部变量为 static 变量。

因为局部变量是存储在内存的栈区内，当函数调用结束后，局部变量所占的内存地址便被释放了，因此当其函数执行完毕后，函数内的变量便不再拥有那个内存地址，所以不能返回其指针。

除非将其变量定义为 static 变量，static 变量的值存放在内存中的静态数据区，不会随着函数执行的结束而被清除，故能返回其地址。