C语言指针与数组知识点

来源：互联网发布：python局域网嗅探编辑：程序博客网时间：2024/06/05 19:48

一.指针常量与常量指针

1. 指针常量

指针本身为常量且有const属性

特点：指针指向的地址不变，指向的值可以改变（这里的改变指通过指针进行改变）。
格式：类型 * const 变量1=&变量2
      变量的数据类型—类型*
/*test1.c*/
#include<stdio.h>
main()
{
int i=2;
int j=3;
int * const p=&i;
*p = 8;              /*正确，指针指向的值可以改变*/
p=&j;                /*错误，指针指向的地址不变*/
   }

2. 常量指针

指针指向的变量为常量且有const属性
   特点：指针指向的值不变，指向的地址可以改变。
   格式：const 类型 * 变量1=&变量2
   变量的数据类型—const 类型 *
     /*test2.c*/
     #include<stdio.h>
     main()
     {
       int i=2;
       int j=3;
      const int * p=&i;
       *p=8;                /*错误，指针指向的值不变*/
       p=&j;                /*正确，指针指向的地址可以改变*/
   }

错误1：消除const属性
inta=6;
const int *p=&b;     正确

constint a=6；
int *p=&a；          错误，消除了const的属性

3. 指向常量的常量指针

特点：指针指向的值和地址都不变。
格式：const 类型 * const 变量1=&变量2

二.按值传递和按地址传递

1.按值传递

在实参和形参之间以值的形式传递，改变形参值对实参无影响。
在调用函数时，将实参的值进行拷贝传递给形参，对形参的任何操作本质上是在对拷贝进行操作。

注意：在调用过程中，实参的地址不会改变

   /*test.c*/
   #include<stdio.h>
   void fun(int q)
   {
        q=25;
   }
    main()
    {
       int i=10;
           fun(i);
           printf(“%d\n”,i);        /*实参i的值不变*/
      }

2.按地址传递

在实参和形参之间以地址形式传递，可以通过改变形参值今进而改变实参值。
在调用函数时，将实参的地址传递给形参，对形参操作本质上是对实参地址的值进行操作（即间接寻址）。
注意：在调用过程中，实参的地址可能发生改变（空调用地址不变），用const防止其地址改变。
   /*test2.c*/
   #include<stdio.h>                      #include<stdio.h>
   void fun(int * q)                                     void fun(int *const q)
   { *q=25；                                  { int j=0；
    }                                               *q=25；
    main()                                                    q=&j;   /*错，q指针为只读*/
   {                                               }
      int i=10;
      fun(&i);
      printf(“%d\n”,i); /* 实参i的值改变*/
    }
函数调用期间，修改主调函数中的数组，被调函数需要的参数：
（1）数组第一个元素的地址(即第一个字节的地址)
（2）数组的长度

三.指针数组与数组指针

1.指针数组（存储指针的数组）

首先它是一个数组，然后是指针，是i个具有指针类型的数组元素。

int *p[i] p(数组名)

int *

arry[0] arry[1] arry[3] arry[4]

一维数组：

   如int arry[i],int *p[i]。p[i]是一个数组，数组中的每个元素(不是元素的值)又是一个指针；p[i]中每个元素的值是arry数组元素的地址(如p[2]=&arry[2])。
   在int *p[i]中，p是p[i]数组的数组名（即指针常量），因此有:
   *(p+k)=p[k]=&a[k]，*(*(p+k))=a[k]。
   *p=p[0]=a, **p=a[0],

二维数组：

p[k]=a[k]=&a[j][k]，*p[k]=a[j][k]；
*p=a[k],p=&p[0]=&a[0]。

注意：

1.p和a都是数组名，但p=a错误，因为p=&p[k],a=&a[k]；*(p+k)=&a[k]。
2.在计算p[k]=&a[k]时，一定要用循环使每一项相对应，否则只是对第一项处理。
     /*test1.c*/
#include<stdio.h>
main()
{
    int i=0;
    inta[5]={10,11,12,13,14};
    int *p[5];
    for(i=0;i<5;++i)            /*使p和a中每一项相对应*/
   p[i]=&a[i];
   for(i=0;i<5;++i)
       printf("%p\n",p[i]);
    for(i=0;i<5;++i)
       printf("%d\n",*p[i]);
}

2.数组指针

一般用于二维数组。首先它是一个数组，指针指向整个数组，int (*p)[i].
int (*p)[i] p(指针变量名

   int a[i][j];
   int (*p)[i].
   p=a=&a[0]；a[0]=&a[0][0]；
   *(*p+k)=a[k][0];
p++，；该语句执行后，p=p+1，此时p=a[1]。以此类推……
   注意：p没有p[i]形式，p是以p的增量访问数组的。

0 0