指针用法专题

概述：     C程序设计中使用指针可以使程序简洁、紧凑、高效

                有效地表示复杂的数据结构

                动态分配内存

                得到多于一个的函数返回值

一、指针的基本用法

        1.在计算机内存中，每一个字节单元(1Byte = 8bit;)，都有一个编号，称为地址。

                short i;//2个字节        float k;//4个字节

                编译或函数调用时为其分配内存单元；

                变量是对程序中数据存储空间的抽象。

        2.在C语言中，内存单元的地址称为指针，专门用来存放地址的变量，称为指针变量（在不影响理解的情况中，有时对地址、指针和指针变量不区分，通称指针）

        指针变量的说明        一般形式：<存储类型>        <数据类型>    *     <指针变量名>

        例如：char *pName;

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

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

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

   一般形式是：

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

                       例如：int  a,  *pa=&a;

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

                int a = 3;   //int a; a = 3;

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

例子：

#include <stdio.h>
int main()
{
    int a =10;//a是一个变，占四个字节
    int *p;//p也是一个变，占四个字节
    p = &a;
    printf("&p: %p %d\n",&p, sizeof(p));
    printf( "%p %p\n", p, &a);
    return 0;
}

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

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

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

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

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

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

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

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

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

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

        double  x=15,  *px;

                             px=&x;

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

                                float  a, *px, *py;

                                px = &a;

                                py = px;

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

                                int  a[20],  *pa;

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

二、指针的运算

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

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

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

        注意

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

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

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

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

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

        2.两指针相减运算

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

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

        3.指针关系运算

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

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

       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

注意指针的当前值

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++;
   }
}

三、指针与数组

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

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

        例如：double   x[8];因此，x为x数组的起始地址

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

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

        注意：指针变量和数组在访问数组中元素时，一定条件下其使用方法具有相同的形式，因为指针变量和数组名都是地址量。但指针变量和数组的指针（或叫数组名）在本质上不同，指针变量是地址变量，而数组的指针是地址常量 

        3.多维数组就是具有两个或两个以上下标的数组，在C语言中，二维数组的元素连续存储，按行优先存

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

                比如int a[3][3]，含有三个元素：a[0]、a[1]、a[2]

                                    元素a[0]、a[1]、a[2]都是一维数组名

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

        5.行指针（数组指针）

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

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

                例如，int a[2][3];  int (*p)[3];

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

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

四、字符指针与字符串

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

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

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

                        char  str[] = “Hello World”;

                        char  *p = str;

                        可以通过指针改变字符串的内容

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

                        char  *  p = “Hello World”;

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

五、指针数组

        1.所谓指针数组是指由若干个具有相同存储类型和数据类型的指针变量构成的集合

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

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

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

        2.声明一个指针数组：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.多级指针的定义

        把一个指向指针变量的指针变量，称为多级指针变量，对于指向处理数据的指针变量称为一级指针变量，简称一级指针，而把指向一级指针变量的指针变量称为二级指针变量，简称二级指针

        二级指针变量的说明形式如下：<存储类型>  <数据类型>  ** <指针名> ；

        2.多级指针的运算

        指针变量加1，是向地址大的方向移动一个目标数据。类似的道理，多级指针运算也是以其目标变量为单位进行偏移。

        比如，int **p；p+1移动一个int *变量所占的内存空间。再比如int ***p，p+1移动一个int **所占的内存空间。

        3.多级指针和指针数组

        指针数组也可以用另外一个指针来处理

                例如：有一个一维字符指针数组ps[5]，

                        char *ps[5]= {  "Beijing city",……"London city"  } ;

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

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

        多级指针在内存中占四个字节，二级指针加一移动四个字节。

六、void指针和const修饰符

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

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

        对于void指针，在没有强制类型转换之前，不能进行任何指针的算，赋值的时候正常赋值，使用时必须强置转换；

例：

#include <stdio.h>

int main()
{
    int m = 10;
    double n = 3.14;
    void *p,*q;
    p = &m;
    //p = (void *)&m;
    printf("%d %d\n", m, *(int *)p);//(int *)强制转化
    
    q = &n;
    //q = (void *)&n;//
    printf("%lf %.2lf\n", n, *(double *)q);
    
}

        2.const变量（常量化变量的值）

                一般说明形式如下： const <数据类型> 变量名 = [<表达式>] ;

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

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

        3.const修饰指针

        （1）常量化指针目标表达式，一般说明形式如下：

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

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

        （2）常量化指针变量，一般说明形式如下：

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

        const在指针变量名的前面，说明const修饰的是指针变量，表示不能改变指针变量的指向，但是可以修改指向的内存空间的数据。

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

        （3）常量化指针变量及其目标表达式，一般说明形式如下：

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

        const在指针类型的前面，说明const修饰的指针所指向的内存空间，不能通过指针去修改；但是指针的指向是可以修改的。

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

main函数可以带参数

#include <stdio.h>

int main(int argc, const char *argv[])
{   //const char *argv[] = {"./a.out", "192.168.1.5", "9999"}; 
    int i;
    printf("argc=\n", argc);

    for(i=0;i < argc; i++){
            printf("%s\n", argv[i]);
    }
    return 0;
}