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

巴特西

C_Learning（2）

最新文章

热门文章