汗,因为K函数的第一个参数是指针类型,在你调用时,实参也必须为指针类型!

score可以看成是一个 float **类型
所谓的二维指针 就是指向指针的指针
就是这个是一个指针(暂时叫做指针1)指向一个另外的一个指针(暂时叫做指针2)
指针2指向一个float数据的指针
*score 就是score指针指向的内容 也就是 一个指向float类型的指针
....  >_< 好复杂的
我有时也不太弄得清楚

链表那一章常用到二级指针  
祝你好运

这样给你说吧```不要以为2维数组是2维的``其实它就是一个一维的数组``

就是有那么点点复杂而已``你还没见过更头痛的``

score[2][4]={{65,67,68,69},{45,1,2,6},{7,9,7,4}};

上面的就是一个score[3]``

score指向这3个元素score ==》score[0]
                   ++后 ==》score[1]
                   ++后 ==》score[2]

score[0]这个元素是什么呢？``它和一般的不一样``它有4个东西``

所以score[0] == {65,67,68,69}
同理score[1] == {45,1,2,6}
    score[2] == {7,9,7,4}

所以score[0]指向 {65,67,68,69} 中的第一个元素 65
同理score[1]指向 {45,1,2,6}    中的第一个元素 45
    score[2]指向 {7,9,7,4}     中的第一个元素 7

所以你可以这样去理解``

score[0]是一个我们通常理解的一个一维数组的名字比如a``它指向4个元素
所以是a[4]，能理解吧``再把名字换过来就是score[0][4]```

数组名是指针``都知道``所以a是一个指针``也就是说``
score[0],score[1]，score[2]都是指针``
各指向一个有4个单独元素的一维数组`

因为数组名是指针``所以score也是一个指针``

各指score[0],score[1]，score[2]，

score是指针``指向score[0],score[1]，score[2]
而score[0],score[1]，score[2]又是指针``各指向一个一维数组`

所以score是一个指向指针的指针``也就是2级指针``是一个**

所以``LZ定义的数组的名字的类型是 float**

如果传给函数``那么形式参数也应该是float**``而不是float*


顺便说下```

在看看LZ的程序``参数接受的是float*

传递的是*score``*score是什么呢``通过我上面说的``

就可以知道*score就是 score[0]

score[0]  就是一个指向 有3个元素的一维数组 即{65,67,68,69}

当然score[0]``指向这个一维数组``所以也就指向这个数组的第一个元素``

也就是65``所以*score[0]``就可以得到65``也就是说**score就是65了``

所以：

**score == 65
**（score + 1）== 45
**（score + 2）== 7

*（*score +0 + 0 ）== 65
*（*score +0 +1 ）== 67
*（*score +0 +2 ）== 68
*（*score +0 +3 ）== 69

*（*score +1 + 0 ）== 45
*（*score +1 + 1 ）== 1
*（*score +1 + 2 ）== 2
*（*score +1 + 3 ）== 6

*（*score +2 +0 ）== 7
*（*score +2 +1 ）== 9
*（*score +2 +2 ）== 7
*（*score +2 +3 ）== 4


好像大得有点多了```表达能力不强``可能说得有点模糊``
不好意思啊```

```恩``再给LZ一点建议``

#include "stdio.h"  改  #include <stdio.h>

库的用<>``临时或自己的用""

你的数组是float所以``里面的元素要有小数点`比如65.0


如果采用LZ的数组```score[0][0] / 2 不知道是32``还是32.5``

主函数也换下吧

int main(void)
{
    ....

    return 0 ;
}

呵呵！其实你这里的问题与二级指针一点关系都没有。错误的原因应该是类型不匹配。
不能用score，因为你定义的score的类型是float [2][4],而函数k的形参要求的是float *型，所以编译的时候会出现类型不匹配的错误。而用*score可以，是因为此时你把数组当成了指针来应用（这是允许的），于是形参和实参的类型就匹配了！其实还有很多办法可以解决这个问题。
譬如：
1：

#include "stdio.h"
void main()
{
      void k(float *p,int n);
     float score[2][4]={{65,67,68,69},{45,1,2,6},{7,9,7,4}};
      k(&score[0][0],12);   //直接将数组第一个元素的地址传给形参
}

2：

#include "stdio.h"
void main()
{
      void k(float *p,int n);
     float score[2][4]={{65,67,68,69},{45,1,2,6},{7,9,7,4}};
     float *tmp=(float *)score; //取数组的首地址，为了类型匹配进行了强制转换。
      k(tmp,12);   //直接将数组第一个元素的地址传给形参
}

从上面两个解决途径都可以很明显的看出来，lz的问题与二及指针没有关系！

另外，楼主的数组也定义错了把？
 float score[2][4]={{65,67,68,69},{45,1,2,6},{7,9,7,4}};//3x4个整形元素怎么成了2x4个float元素了？

LS的做法``我支持第一个``第2个我是绝对不会用的（因为很不喜欢）``

对于LS解决问题的说话``我没异议``你说的也不错``

但是说和2级指针没关系``我就不太喜欢了```

毕竟2维数组的名字就是一个2级指针``

虽然通过LS的``LZ可以得到解决问题的办法``

但是如果LZ通过``2维数组来``理解1级针和2级指针``

对LZ的帮助是很大的``

只要多加理解了``对于LZ提的问题也完全没有问题了``

并且可以引申到理解多维数组``比如a[][][]``(虽然比较少见)

而且见到这个东西```float (*pf)[4]``也不回难懂了```

to ls:
      sorry!