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种原型都是等价的。

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

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

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

4、a与&a的区别

1. int num =0 ;                       //在32机器中告诉C编译器分配4个字节的内存
2. int a [] = {1,3,5,12,6,7,54,32};   //告诉C编译器分配32个字节的内存
3. printf("a:%d ,a+1:%d,&a:%d,&a+1:%d\n",a,a+1,&a,&a+1) ;
4. //a+1 和 &a+1 结果不一样
5. //虽然输出结果上面，a和&a一样 。 但是a 和 &a所代表的数据类型不一样
6. /*重要*/
7. //a 代表的数据首元素的地址 (首元素)，同时与整个数组地址重合，但其不能代表整个数组，只能代表起始个体的地址
8. //&a代表的是整个数组的地址   （特别特别的注意） 它的加1是以整块数组所占字节数总数为单位1

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

5、指针所占字节数

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

1. /**
2. 2016-7-12 Jason Gel
3. **/
4. #include<stdio.h>
5. #include<stdlib.h>
6. #include<string.h>
7. //void printArray(int * a ,int num ) 和  void printArray(int a[] ,int num )是等价的
8. //函数定义时候，名称是不可以省略的。函数原型容许省略名称。
9. /**   函数原型声明4中等价形式
10. int sum (int *a , int n)
11. int sum (int * , int )
12. int sum (int a[] , int n)
13. int sum (int [] , int )   //可能略微不熟悉的一种
14. */
15. void printArray(int * a ,int num )
16. {
17. int i ;
18. for(i = 0; i< num; i++)
19. {
20. printf("%3d",a[i]);
21. }
22. printf("\n");
23. }
24. //这里用的是冒泡排序(起泡排序)
25. void sortArray(int *a ,int num )
26. {
27. int i ,j ,temp;
28. for(i =0 ;i <num;i++)              //外层：每次选定出需要排序的一个元素，依次向后
29. {
30. for( j=i+1; j<num; j++ )  //内层：外层选定的一个元素与其后所有元素依次比较，找出最小的元素
31. {
32. if(a[i]>a[j])     //交换类代码
33. {
34. temp = a[i];
35. a[i]=a[j];
36. a[j]=temp;
37. }
38. }
39. }
40. }
41. int main ()
42. {
43. int num =0 ;                       //在32机器中告诉C编译器分配4个字节的内存
44. int a [] = {1,3,5,12,6,7,54,32};   //告诉C编译器分配32个字节的内存
45. int test =5;
46. int *p = &test;
47. int num1 = 0;
48. num1 = sizeof(p)/sizeof(p[0]);
49. printf("num1:%d, sizeof(p):%d,sizeof(p[0]):%d \n",num1,sizeof(p),sizeof(p[0]));
50. sortArray(p,num1);
51. printf("单一元素排序之后：");
52. printArray(p,num1);
53. printf("a:%d ,a+1:%d,&a:%d,&a+1:%d\n",a,a+1,&a,&a+1) ;
54. printf("sizeof(num1):%d\n",sizeof(num1));
55. printf("sizeof(a):%d\n\n",sizeof(a));
56. printf("sizeof(int):%d sizeof(double):%d sizeof(char):%d \n",sizeof(int),sizeof(double),sizeof(char)) ;
57. printf("sizeof(int *):%d sizeof(double*):%d sizeof(char*):%d \n",sizeof(int *),sizeof(double*),sizeof(char*)) ;
58. //a+1 和 &a+1 结果不一样
59. //虽然输出结果上面，a和&a一样 。 但是a 和 &a所代表的数据类型不一样
60. /*重要*/
61. //a 代表的数据首元素的地址 (首元素)，同时与整个数组地址重合，但其不能代表整个数组，只能代表起始个体的地址
62. //&a代表的是整个数组的地址   （特别特别的注意） 它的加1是以整块数组所占字节数总数为单位1
63. //  num =sizeof(a);//这个是获取的整个数组的字节数，为32个字节
64. printf("实参a的数据类型为整个数组，所占字节为：%d \n",sizeof(a)) ;
65. //    num = sizeof(a)/sizeof(int);
66. num = sizeof(a)/sizeof(a[0]); //注意规范
67. printf("排序之前：");
68. printArray(a,num);
69. sortArray(a,num);
70. printf("排序之后：");
71. printArray(a,num);
72. return 0;
73. }

VC 32位编译器 运行截图：

64位编译器运行截图：

核心：

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

1. 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)[], int n);
 int main(int argc, char *argv[])
 {
     double a[] = { 1.0, 2.0, 3.0, 5.0, 6.0 };
     double b[][] = { { , ,  }, { , ,  }, {,,} };
     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\n", s1);
         printf("%s\n", p);

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

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

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

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

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

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