2. ## 总结
  4. ==为什么num2会是1==
  6. - 结论1：正确的做法应是把数组的内存首地址和数组的有效长度传给被调用函数  
  7. - 结论2：为什么是1 实参的a（数组）和形参a（指针） 的数据类型本质不一样  ；
  8. - 既使形参传递数组a arraySort2(int a[], int num)编译器会把它当成指针处理 这是C语言的特色  
  9. - 本质剖析3：
  10. 形参（int *a）写在函数上和写在函数内是一样的，只不过写在函数上是具有对外的属性而已

include

include

int main2() { int i = 0, j = 0; int a[10] = { 3, 1, 44, 2, 3, 44, 5, 5,6, 67 }; int tmp = 0;

  1. for (i = 0; i < 10; i++) {//外层循环 行
  3.     for (j = i + 1; j < 10; j++) { // 内层循环
  5.         if (a[i] > a[j]) { //如果小就交互换位置
  6.             tmp = a[i];
  7.             a[i] = a[j];
  8.             a[j] = tmp;
  9.         }
  10.     }
  11. }
  13. for (i = 0; i < 10; i++) {
  14.     printf("%d ,", a[i]);
  15. }
  17. system("pause");
  18. return 0;

}

int arraySort(int a[], int num) { int i = 0, j = 0; int tmp = 0;

  1. for (i = 0; i < num; i++) {//外层循环 行
  3.     for (j = i + 1; j < num; j++) { // 内层循环
  5.         if (a[i] > a[j]) { //如果小就交互换位置
  6.             tmp = a[i];
  7.             a[i] = a[j];
  8.             a[j] = tmp;
  9.         }
  10.     }
  11. }
  13. for (i = 0; i < 10; i++) {
  14.     printf("%d ,", a[i]);
  15. }
  17. return 0;

}

int arraySort2(int a, int num) { // int a; //写在函数上和写在函数内是一样的，只不过写在函数上是具有对外的属性而已

  1. int i = 0, j = 0;
  2. int tmp = 0;
  4. int num2 = 0;
  5. num2 = sizeof(a) / sizeof(*a);
  6. printf("%d,%d,%d\n", sizeof(a), sizeof(*a), num2);//4 4 1
  8. /*
  9. 为什么num2会是1
  11. 数组做函数参数的退回问题 退回为一个指针
  12. 结论1：正确的做法应是把数组的内存首地址和数组的有效长度传给被调用函数
  13. 结论2: 为什么是1 实参的a（数组）和形参a（指针） 的数据类型本质不一样
  14.              既使形参传递数组a arraySort2(int a[], int num)编译器会把它当成指针处理 这是C语言的特色
  15. 本质剖析3：
  16. 形参（int *a）写在函数上和写在函数内是一样的，只不过写在函数上是具有对外的属性而已
  17. */
  19. for (i = 0; i < num; i++) {
  20.     for (j = i + 1; j < num; j++) {
  21.         if (a[i] > a[j]) {
  22.             tmp = a[i];
  23.             a[i] = a[j];
  24.             a[j] = tmp;
  25.         }
  26.     }
  27. }
  29. for (i = 0; i < 10; i++) {
  30.     printf("%d ,", a[i]);
  31. }
  33. return 0;

}

int main() { int a[10] = { 3, 1, 44, 2, 3, 44, 5, 5,6, 67 };

  1. int num = 0;
  2. num = sizeof(a) / sizeof(a[0]);
  3. printf("num=%d\ta=%d\ta[0]=%d\n", num, sizeof(a), sizeof(a[0])); //num=10  a=40    a[0]=4
  5.                                                                                                                                  //arraySort(a, num);
  6. arraySort2(a, num);
  8. printf("\n");
  9. for (int i = 0; i < 10; i++) {
  10.     printf("%d ,", a[i]);
  11. }
  14. system("pause");
  15. return 0;

}

总结

为什么num2会是1

  • 结论1：正确的做法应是把数组的内存首地址和数组的有效长度传给被调用函数
  • 结论2：为什么是1 实参的a（数组）和形参a（指针） 的数据类型本质不一样 ；
  • 既使形参传递数组a arraySort2(int a[], int num)编译器会把它当成指针处理 这是C语言的特色
  • 本质剖析3：
    形参（int *a）写在函数上和写在函数内是一样的，只不过写在函数上是具有对外的属性而已