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\n",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("\n");
- }
- //这里用的是冒泡排序(起泡排序)
- 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 \n",num1,sizeof(p),sizeof(p[0]));
- sortArray(p,num1);
- printf("单一元素排序之后：");
- printArray(p,num1);
- printf("a:%d ,a+1:%d,&a:%d,&a+1:%d\n",a,a+1,&a,&a+1) ;
- printf("sizeof(num1):%d\n",sizeof(num1));
- printf("sizeof(a):%d\n\n",sizeof(a));
- printf("sizeof(int):%d sizeof(double):%d sizeof(char):%d \n",sizeof(int),sizeof(double),sizeof(char)) ;
- printf("sizeof(int *):%d sizeof(double*):%d sizeof(char*):%d \n",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 \n",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)[], 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)