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[10], *p, **q, i, n=0;
        printf ("Please input:");
        for (i=0; i<10; i++)
                scanf ("%d",&a[i]);
        p=a;
        q=&p;
        printf ("The array is :");
        for (i=0; i<10; i++)
        {
                if (*(*q+i)%2==0)
                {
                        n++;
                        printf ("%5d",*(*q+i));
                }
        }
        printf ("
");
        printf ("The number is :%d.
",n);
        
        return 0;
}

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

#include <stdio.h>

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

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

#include <stdio.h>

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

    return 0;
}

　　

　　/ 指针变量作函数参数   

　　　　/ 实例参见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:
");
    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 0;
}

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


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

int swap(int a, int b)；

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

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

// 交换两个数swap2.c

#include <stdio.h>

int swap(int a, int b);

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

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

　　/ 指向函数的指针   

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

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

　　　　/ 实例见 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 ("
the perimeter is :%d", *result);
    
    return 0;
}

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

　　/ 指针数组作 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:
");
    printf ("command:
");
    printf ("%s
",*argv);
    printf ("the number of parameter:");
    printf ("%d",argc);
}

// 运行的结果如下：
the list of parameter:
command:
C:AdministratorDesktopjan5main_parameter.exe
the number of parameter:1