C_Learning（2）

/指针

　　/指针变量指向一个变量的地址

　　/给指针变量赋的值只能是地址

　　/指针变量的赋值

　　　　/{ int a; int *p; p=&a; } or { int a; int *p=&a; }

　　　　/指针必须先定义后使用

　　　　/不能把一个具体的数赋给指针

　　

　　/ &是取地址运算符，&q 表示取变量 q 的地址

　　/ *是指针运算符，*p 表示返回指定地址内变量的值

　　/ 因此，p=&q 表示的是地址；scanf 中 &q 表示往该地址写入操作数；printf 中的 q 表示输出变量 q 地址中存放的操作数；*p 表示输出变量 p 指向的地址中存放的操作数

　　/ &* 和 *& 的区别

　　　　/ & * 的运算优先级相同，按自右向左方向结合

　　　　/ &* 表示先进行指针运算，再取地址；（&*p=&（*p）=&a）——是一个地址

　　　　/ *& 表示先取地址，再进行指针运算；（*&p=*（&p））——是地址中的操作数

　　/ 指针的自增自减（p++,p--）造成内存地址按照其所指向的数据类型的直接长度的增或减

　　/ 指针与数组

　　　　/ { int a[100],*p; p=a;}

　　　　/ p=a表示将数组 a[100] 的首地址赋给指针变量 p，即 p=&a[0]

　　　　/ *(p+n)=*(a+n) ,表示数组 a[100] 第n个元素

　　　　/ &a[i][j]、(a[i]+j) 表示第 i 行第 j 列的元素"地址"!

　　/ 指针与字符串

　　　　/ { char *str="hello"; printf ("%s",str); }

　　　　/ 这里不是将 hello 赋给指针变量 str ，而是把字符串 "hello" 的首字母地址赋给 str

　　　　

　　/ 指针数组

　　　　/ { char *str[]={"abc","def","ghi"} }

　　　　/ 一个数组，其元素均为指针类型数据，则称为指针数组

　　　　/ 由于字符型数组的长度必须大于最长元素的长度，因此，使用指针数组可以大大减少这样的存浪费

　　/ 指向指针的指针

　　　　/ 这种问题只有在实战当中才能得到深刻理解，实例参见：count_even.c / count_even_2.c / count_even_3.c

 // 统计数组中偶数的个数

 #include <stdio.h>

 int main()
 {
         int a[], *p, **q, i, n=;
         printf ("Please input:");
         for (i=; i<; i++)
                 scanf ("%d",&a[i]);
         p=a;
         q=&p;
         printf ("The array is :");
         for (i=; i<; i++)
         {
                 if (*(*q+i)%==)
                 {
                         n++;
                         printf ("%5d",*(*q+i));
                 }
         }
         printf ("\n");
         printf ("The number is :%d.\n",n);

         return ;
 }

count_even.c

 // 统计数组元素中偶数的个数(2)

 #include <stdio.h>

 int main()
 {
     int a[], *p, **q, n=;
     printf ("Please input:\n");
     for (p=a; p-a<; p++)
     {
         q=&p;
         scanf ("%d",*q);
     }
     printf ("The array is:");
     for (p=a; p-a<; p++)
     {
         q=&p;
         if (**q%==)
         {
             printf ("%5d",**q);
             n++;
         }
     }
     printf ("\n");
     printf ("The number is:%d.\n",n);

     return ;
 }

count_even2.c

 // 统计数组元素中的偶数个数(3)

 #include <stdio.h>

 int main()
 {
     int a[], *p, n=;
     printf ("Please input:\n");
     for (p=a; p-a<; p++)
     {
         scanf ("%d",p);
     }
     printf ("The array is:\n");
     for (p=a; p-a<; p++)
     {
         if (*p%==)
         {
             printf ("%5d",*p);
             n++;
         }
     }
     printf ("\n");
     printf ("The number is:%d.",n);

     return ;
 }

count_even3.c

　　

　　/ 指针变量作函数参数

　　　　/ 实例参见swap.c / swap2.c

 // 交换两个数swap.c

 #include <stdio.h>

 // 定义交换函数swap
 int swap(int *a, int *b);

 // 主函数
 int main()
 {
     int x, y, *p_x, *p_y;
     printf ("Please input two number:\n");
     scanf ("%d,%d", &x, &y);
     p_x=&x;
     p_y=&y;
     swap(p_x, p_y);
     printf ("x=%d or *p_x=%d", x, *p_x);
     printf ("y=%d or *p_y=%d", y, *p_y);

     return ;
 }

 // 交换函数swap定义区域
 int swap(int *a, int *b)
 {
     int tmp;
     tmp=*a;
     *a=*b;
     *b=tmp;

     return ;
 }

 // 为什么不能使用如下源程序swap2.c？
 /*
 #include <stdio.h>

 int swap(int a, int b)；

 int main()
 {
     int x, y;
     printf ("please input two number:\n");
     scanf ("%d%d", &x, &y);
     swap(x,y);
     printf ("x=%d.\n", x);
     printf ("y=%d.\n", y);

     return 0;
 }

 int swap(int a. int b)
 {
     int tmp;
     tmp=a;
     a=b;
     b=tmp;
 }
 */
 // 在函数调用过程中，主调用函数与被调用函数之间的数值传递是单向的，即只能把实参的值传递给形参，而不能把形参传递给实参。因此，如果使用swap2.c，形参的值会发生改变，但实参的值却不会发生任何变化。
 // 而使用指针来传递参数，既可以减少值传递带来的开销，也可以使函数调用不产生值传递，即只要保证指针指向的地址是正确的即可。

swap.c

 // 交换两个数swap2.c

 #include <stdio.h>

 int swap(int a, int b);

 int main()
 {
     int x, y;
     printf ("please input two number:\n");
     scanf ("%d%d", &x, &y);
     swap(x,y);
     printf ("x=%d.\n", x);
     printf ("y=%d.\n", y);

     return ;
 }

 int swap(int a. int b)
 {
     int tmp;
     tmp=a;
     a=b;
     b=tmp;
 }

swap2.c

　　/ 指向函数的指针

　　　　/ 指针可以指向函数，一个函数在编译时被分配给一个入口地址，这个函数的入口地址就称为函数的指针

　　　　/ 一个函数可以返回一个整型值、字符值、实型值等，也可以返回指针型的数据，即地址

　　　　/ 实例见 perimeter.c

 // 根据指针函数的概念，使用指针函数计算长方形周长

 #include <stdio.h>

 int *per(int a, int b);
 int perimeter;

 int main()
 {
     int width, lenth;
     int *result;
     printf ("please input width and lenth:");
     scanf ("%d%d", &width, &lenth);
     result=per(width, lenth);
     printf ("\nthe perimeter is :%d", *result);

     return ;
 }

 int *per(int a, int b)
 {
     int *p;
     p=&perimeter;
     perimeter=*(a+b);
     return p;
 }

perimeter.c

　　/ 指针数组作 main 函数的参数

　　　　/ main 函数可以是无参函数，也可以是有参函数

　　　　/ main 函数的带参形式：main(int argc, char *argv[])

　　　　/ argc 记录了命令和参数的个数，指针数组 argv[] 的大小由命令和参数的个数决定

　　　　/ 实例见main_pointer.c

 // main 函数的有参实例

 #include <stdio.h>

 main(int argc, char *argv[])
 {
     printf ("the list of parameter:\n");
     printf ("command:\n");
     printf ("%s\n",*argv);
     printf ("the number of parameter:");
     printf ("%d",argc);
 }

 // 运行的结果如下：
 the list of parameter:
 command:
 C:\Administrator\Desktop\jan5\main_parameter.exe
 the number of parameter:

main_parameter.c