c语言操作一维数组-3

C语言选择题
#include
main()
{double a[15],k;
k=fun(a);
}

则以下选项中错误的fun函数首部是 ( D)
A.double fun(double a[15]) B.double fun(double *a)
C.double fun(double a[]) D.double fun(double a)
------------------------------------------------

http://blog.csdn.net/jin13277480598/article/details/51891816

：a[n]时等价于*(a+n)，即寻址到内存的a，然后移动n个单元，再取出数组。故p[0]等价于*(p+0),该值的类型为int型。

   num1=sizeof(p)/sizeof(p[0]) 等价于 num1=sizeof(p)/sizeof(int );

该语句在语法上面没有任何错误，但是在32机器和64位机器运行结果不同，在32机器出现正常结果，64位机器出现错误结果，原因见本文最后。

3、声明数组参量

前提：实际参数是一个数组名。C对于int a  [ ] 和 int * a作了同样解释，即a是指向int的指针。 

由于原型允许省略名称，因此下列4种原型都是等价的。

/**   函数原型声明4中等价形式
int sum (int *a , int n)
int sum (int * , int )
int sum (int a[] , int n)
int sum (int [] , int )   //可能略微不熟悉的一种
*/

       定义函数时，名称是不可以省略的，以下两种形式是等价的。

/**   函数原型声明4中等价形式
int sum (int *a , int n)
{}
int sum (int a[] , int n)
{}
*/

4、a与&a的区别

int num =0 ;                       //在32机器中告诉C编译器分配4个字节的内存
int a [] = {1,3,5,12,6,7,54,32};   //告诉C编译器分配32个字节的内存

printf("a:%d ,a+1:%d,&a:%d,&a+1:%d
",a,a+1,&a,&a+1) ;

//a+1 和 &a+1 结果不一样
//虽然输出结果上面，a和&a一样 。 但是a 和 &a所代表的数据类型不一样

/*重要*/
//a 代表的数据首元素的地址 (首元素)，同时与整个数组地址重合，但其不能代表整个数组，只能代表起始个体的地址
//&a代表的是整个数组的地址   （特别特别的注意） 它的加1是以整块数组所占字节数总数为单位1

输出结果：a:1638176 ,a+1:1638180,&a:1638176,&a+1:1638208

5、指针所占字节数

              指针所占用的字节数和操作系统和编译器有关。

/**
2016-7-12 Jason Gel
**/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

//void printArray(int * a ,int num ) 和  void printArray(int a[] ,int num )是等价的

//函数定义时候，名称是不可以省略的。函数原型容许省略名称。
/**   函数原型声明4中等价形式
int sum (int *a , int n)
int sum (int * , int )
int sum (int a[] , int n)
int sum (int [] , int )   //可能略微不熟悉的一种
*/

void printArray(int * a ,int num )
{
    int i ;
    for(i = 0; i< num; i++)
    {
        printf("%3d",a[i]);
    }
    printf("
");
}
//这里用的是冒泡排序(起泡排序)
void sortArray(int *a ,int num )
{
    int i ,j ,temp;
    for(i =0 ;i <num;i++)              //外层：每次选定出需要排序的一个元素，依次向后
    {
        for( j=i+1; j<num; j++ )  //内层：外层选定的一个元素与其后所有元素依次比较，找出最小的元素
        {
            if(a[i]>a[j])     //交换类代码
            {
                temp = a[i];
                a[i]=a[j];
                a[j]=temp;
            }
        }
    }

}

int main ()
{
    int num =0 ;                       //在32机器中告诉C编译器分配4个字节的内存
    int a [] = {1,3,5,12,6,7,54,32};   //告诉C编译器分配32个字节的内存

    int test =5;
    int *p = &test;
    int num1 = 0;

    num1 = sizeof(p)/sizeof(p[0]);

    printf("num1:%d, sizeof(p):%d,sizeof(p[0]):%d 
",num1,sizeof(p),sizeof(p[0]));
    sortArray(p,num1);
    printf("单一元素排序之后：");
    printArray(p,num1);

    printf("a:%d ,a+1:%d,&a:%d,&a+1:%d
",a,a+1,&a,&a+1) ;
    printf("sizeof(num1):%d
",sizeof(num1));
    printf("sizeof(a):%d

",sizeof(a));
    printf("sizeof(int):%d sizeof(double):%d sizeof(char):%d 
",sizeof(int),sizeof(double),sizeof(char)) ;

    printf("sizeof(int *):%d sizeof(double*):%d sizeof(char*):%d 
",sizeof(int *),sizeof(double*),sizeof(char*)) ;

    //a+1 和 &a+1 结果不一样
    //虽然输出结果上面，a和&a一样 。 但是a 和 &a所代表的数据类型不一样

    /*重要*/
    //a 代表的数据首元素的地址 (首元素)，同时与整个数组地址重合，但其不能代表整个数组，只能代表起始个体的地址
    //&a代表的是整个数组的地址   （特别特别的注意） 它的加1是以整块数组所占字节数总数为单位1


//  num =sizeof(a);//这个是获取的整个数组的字节数，为32个字节
    printf("实参a的数据类型为整个数组，所占字节为：%d 
",sizeof(a)) ;
//    num = sizeof(a)/sizeof(int);
    num = sizeof(a)/sizeof(a[0]); //注意规范
    printf("排序之前：");
    printArray(a,num);
    sortArray(a,num);
    printf("排序之后：");
    printArray(a,num);
    return 0;
}

VC 32位编译器 运行截图：

64位编译器运行截图：

核心：

可以看出在64位机器中，int*的指针为8个字节，在32位中int*为 4个字节，由于：

sizeof(p)/sizeof(p[0]) //等价于sizeof（int * ） /sizeof( int )

所以在64位机器上面原本应该为1的现在变成了2，导致程序出现错误。

      从程序输出结果我们可以看出：实参a的数据类型为整个数组，所占字节为32。虽然实参a表示的是数组名，但是它实际的数据类型不是int *,而是表示的整个数组所占字节数。这里不要与前文的a与&a表示地址时候弄混淆。

-----------------------------------------------

#include <stdio.h>
void printArray(double *p,int n);
void printArray2(double a[], int n);
void printArray3(double (*p)[5], int n);
int main(int argc, char *argv[])
{
    double a[] = { 1.0, 2.0, 3.0, 5.0, 6.0 };
    double b[][3] = { { 1, 2, 3 }, { 4, 5, 6 }, {7,8,9} };
    printArray(a, sizeof(a) / sizeof(double));//a 传递的是a数组首元素的首地址
    printArray2(a, sizeof(a) / sizeof(double));
    printArray3(&a, sizeof(a) / sizeof(double));//&a 传递的是整个数组的首地址
    //虽然传递a和&a时传过去的值是相同的，但是意义不同，接受他的形参也要不同，
    //数组名a传过去的就是首元素首地址，可以用一个double类型指针接受
    printf("a的地址：%d", a);//正确
    printf("&a的地址：%d", &a);//正确

        /*char s1[] = "hello rupeng.com";
        char *p = s1;
        p = p + 2;//char是一个字节，向后移动2*1 个字节
        printf("%s
", s1);
        printf("%s
", p);

        char *p2 = s1;
        p2 += 5;
        int i = p2 - p;
        printf("%d
", i);

        int nums[] = { 11, 22, 33, 44, 55 };
        int *iP1 = nums;
        int *iP2 = nums;
        iP2 = iP2 + 3;
        printf("%d
", *iP2);
        printf("%d
", iP2 - iP1);
        //同类型指针相减，得出的是相距的数据类型的长度

        //int aaa = iP2-p2;
        */
        getchar();
    return 0;
}
void printArray(double *p, int n)//一维数组首元素首地址传过来后指针p和数组名可以同样使用
{
    printf("printArray_a:
");//正确
    for (int i = 0; i < n; i++)
    {
        printf("%lf ", *(p + i));
    }
    printf("
");
    printf("printArray_b:
");//正确
    for (int i = 0; i < n; i++)
    {
        printf("%lf ", p[i]);
    }
    printf("
");
}

void printArray2(double a[], int n)
{
    printf("printArray2_a:
");//正确
    for (int i = 0; i < n; i++)
    {
        printf("%lf ", a[i]);
    }
    printf("
");
    printf("printArray2_b:
");
    for (int i = 0; i < n; i++)
    {
        printf("%lf ", *(a+i));// a+i不正确
    }
    printf("
");
}

void printArray3(double(*p)[5], int n)//传过来整个数组的首地址&a，接受指针为(*p)[5]，*p相当于数组名
{

    printf("printArray3_a:
");//正确
    printf("(*p)[5]的地址：%d
", (*p)[5]);//
    printf("(*p)的地址：%d
", (*p));
    for (int i = 0; i < n; i++)
    {
        printf("%lf ", (*p)[i]);
    }
    printf("
");
    printf("printArray3_b:
");//错误
    for (int i = 0; i < n; i++)
    {
        printf("%lf ", (*p)+i);//(*p)[5]、*p[i]、*(p+i)、(*p)+i不正确
    }
    printf("
");
}
//给一维数组传指针时通常使用a而不是&a，接受的指针可以为同类型的指针*p，p和a的使用方法相同，可以p[i]和*(p + i)