c++ 的一个问题 高手帮帮忙

Question

程序代码如下

#include <iostream>
using namespace std;
int main()
{
int arr0[3][4];
float arr1[3];
int i,j,k,L;
for(i=0;i<=2;i++)
{
for(j=0;j<=3;j++)
{cin>>arr0[i][j];
}
}

int DD(int arr2[3][4]);

int Di(int arr3[3][4],int iNo);
L=DD(arr0);

cout<<L<<endl;
for (k=0;k<=2;k++)
{
arr1[k]=Di(arr0,k);
cout <<arr1[k]<<endl;
}
return 0;
}
int DD(int arr2[3][4])
{
int arr4[3]={1,1,1},arr5[3]={1,1,1};
int i,j,k,m=0,n=0,a,b,l,h;

for (j=0;j<=2;j++)
{
for (i=0;i<=2;i++)
{ k=i+j;
if(i+j>2)
k=i+j-3;
arr4[j]=arr2[i][k]*arr4[j];
}
m=arr4[j]+m;
}
for (b=2;b>=0;b--)
{
for(a=0;a<=2;a++)
{l=b-a;
if(b-a<0)
l=b-a+3;
arr5[b]=arr2[a][l]*arr5[b];
}
n=arr5[b]+n;
}
h=m-n;
return (h);
}

int Di(int arr3[3][4],int iNo)
{
int i,j,k,iDi;
int arr6[3];
for (i=0;i<=2;i++)
{ arr6[i]=arr3[i][iNo];
arr3[i][iNo]=arr3[i][3];
arr3[i][3]=arr6[i];

}

for (j=0;j<=2;j++)
{
for (k=0;k<=2;k++)
{
cout<<arr3[j][k]<<" ";
}
cout<<endl;
}

int DD(int arr2[3][4]);
iDi=DD(arr3);

return (iDi);
}

我输入进行测试的数组是
2 -1 1 0
3 2 -5 1
1 3 -2 4

本意是想用
for (k=0;k<=2;k++)
{
arr1[k]=Di(arr0,k);
cout <<arr1[k]<<endl;
}
这段代码和
for (i=0;i<=2;i++)
{ arr6[i]=arr3[i][iNo];
arr3[i][iNo]=arr3[i][3];
arr3[i][3]=arr6[i];

}
这段代码一起实现 数组列的对换，也就是
k=0 时 数组为
0 -1 1 2
1 2 -5 3
4 3 -2 1
k=1时 数组为
2 0 1 -1
3 1 -5 2
1 4 -2 3
k=2 时 数组为
2 -1 0 1
3 2 1 -5
1 3 4 -2
但实际结果却是
k=0 时 数组为
0 -1 1 2
1 2 -5 3
4 3 -2 1
k=1 时数组为
0 2 1 -1
1 3 -5 3
4 1 -2 3
k=2时数组为
0 2 -1 1
1 3 2 -5
4 1 3 -2
也就是说 执行这段
for (k=0;k<=2;k++)
{
arr1[k]=Di(arr0,k);
cout <<arr1[k]<<endl;
}
代码时 ，每次循环时arr0 的值不是重新付值的 而是由arr3 决定的
为什么会这样？ 有什么改进方法吗？
谢谢
程序能运行 只是有点小错误
希望大家能指点下

Answer 1

你这200分可不好赚啊，程序写得很乱，又没有任何注释，看了半个小时才看明白你的程序。问题主要是你还没有理解数组作为函数传值的本质。其实数组的传值是跟普通变量的传值不同的，普通变量传值只是把实参的值赋给了函数形参，函数内对形参的修改并不会影响到实参的值，但数组的传值本质就是把数组的首地址传给函数，函数内对数组形参的修改就是对数组实参的修改，类似于普通变量的指针传参的效果。所以你把arr0传给Di函数，在函数中对数组形参arr3的修改就是对arr0的修改了，那k=2,k=3时的结果当然就是由arr3决定了，但归根到底还是由被修改后的arr0决定的。解决问题的方法是，在Di函数内设一临时变量数组arr3，每次开始时用函数形参arr去初始化它，函数结束后，arr3随函数消失，不会修改到arr的值，自然就不会修改到arr0的值了，下次再调用Di时，又是用原来的arr0去初始化新的arr3了。
修改过的可以得到你预期的结果的代码如下：
#include <iostream>
using namespace std;
int DD(int arr2[3][4])
{
int arr4[3]={1,1,1},arr5[3]={1,1,1};
int i,j,k,m=0,n=0,a,b,l,h;
for (j=0;j<=2;j++)
{
for (i=0;i<=2;i++)
{
k=i+j;
if(i+j>2)
k=i+j-3;
arr4[j]=arr2[i][k]*arr4[j];
}
m=arr4[j]+m;
}
for (b=2;b>=0;b--)
{
for(a=0;a<=2;a++)
{
l=b-a;
if(b-a<0)
l=b-a+3;
arr5[b]=arr2[a][l]*arr5[b];
}
n=arr5[b]+n;
}
h=m-n;
return (h);
}
int Di(int arr[3][4],int iNo)
{
int i,j,k,iDi;
int temp;
int arr3[3][4];//arr3为函数内局部变量，每次执行Di函数都会从新生成并用arr赋值
for(i=0;i<3;i++)
for(j=0;j<4;j++)
arr3[i][j]=arr[i][j];

for (i=0;i<=2;i++) //把第i列和第3列值互换，i=0，1，2，3.
{
temp=arr3[i][iNo];
arr3[i][iNo]=arr3[i][3];
arr3[i][3]=temp;
}
for (j=0;j<=2;j++) //输出数组
{
for (k=0;k<=3;k++)
{
cout<<arr3[j][k]<<" ";
}
cout<<endl;
}
return DD(arr3);
}
int main()
{
int arr0[3][4];
float arr1[3];
int i,j,k,L;
for(i=0;i<=2;i++)
for(j=0;j<=3;j++)
cin>>arr0[i][j];

L=DD(arr0);
cout<<L<<endl;
for (k=0;k<=2;k++)
{
arr1[k]=Di(arr0,k);
cout <<arr1[k]<<endl;
}
return 0;
}

Answer 2

在函数调用的写法完全不对，调用竟然写成了定义的写法，整个程序无法运行，希望你能把代码整理好以后再发上来。

Answer 3

看的晕~ 可惜我不是绝顶高手。。看不习惯这种写法

还有~“数组列的对换？”不就是每一行都向前移动一位么？设定一个和数组行数一样的临时空间做temp，第0列放在temp[0]里，依次1放temp[1]....n列放temp[n]然后根据需要对换的次数，去递归调用交换的函数，出口就是次数自减为零。。。 我大概就这个想法，给您做参考吧，我不要分，只不过这么简单的程序写这么长有点麻烦，况且随着规模的增大您的程序的执行效率会很低下，我也是新手，大家一起努力吧！

Answer 4

我第一次遇到这样的难题！！！

Answer 5

很简单的问题，为什么搞那么复杂...

全部按一维数组处理，我写了列向右移、向左移、以及指定列之间的交换的3个函数，可以处理不定行、列数的二维数组，你可以参考下：

#include <iostream>
#include <algorithm>
using namespace std;

// beg: 数组首地址 x: 行数 y: 列数 k: 移动次数
void MoveRight(int* const beg, int x, int y, int k)
{
k = k % y;
if(k == 0)
return;

while(k > 0)
{
int i = 1;
while(i < y)
{
for(int* p = beg + y - i, j = 1; p != beg + (x * y) + y - i; p += y)
{
if(p == (beg + y * j - 1))
{
swap(*p, *(p-(y-1)));
++j;
}
else
swap(*p, *(p+1));
}
++i;
}
--k;
}
}

// beg: 数组首地址 x: 行数 y: 列数 k: 移动次数
void MoveLeft(int* const beg, int x, int y, int k)
{
k = k % y;
if(k == 0)
return;

while(k > 0)
{
int i = 1;
while(i < y)
{
for(int* p = beg + i - 1, j = 1; p != beg + (x * y) + i - 1; p += y)
{
if(p == (beg + y * (j - 1)))
{
swap(*p, *(p+(y-1)));
++j;
}
else
swap(*(p), *(p-1));
}
++i;
}
--k;
}
}

// beg: 数组首地址 x: 行数 y: 列数 a、b: 要交换的2列
void exchange(int* const beg, int x, int y, int a, int b)
{
if(a == b)
return;

for(int* p = beg + a; p != beg + (x * y) + a; p += y)
{
swap(*p, *(p+b-a));
}
}

// 打印方阵
void print(int* const beg, int x, int y, const char* msg = "")
{
cout << msg << '\n';
for(int* p = beg, i = 1; p != beg + x * y; ++p)
{
if(p == beg + y * i)
{
cout << '\n';
++i;
}
cout.width(2);
cout.setf(ios_base::left);
cout << *p;
}
cout << '\n' << endl;
}

int main()
{
const int X = 9;
const int Y = 9;

int a[X][Y] =
{
{0,1,1,2,4,6,9,5,4},
{1,2,5,3,3,6,6,9,2},
{4,3,2,1,7,8,1,4,3},
{2,1,6,9,8,5,3,5,4},
{8,3,6,5,4,1,2,6,9},
{5,6,2,1,2,5,5,4,2},
{7,1,2,3,6,9,5,4,7},
{3,0,4,5,6,2,2,6,5},
{6,8,3,6,8,6,5,4,1},
};
int* beg = reinterpret_cast<int*>(a);
print(beg, X, Y, "Origin: ");

MoveLeft(beg, X, Y, 1);
print(beg, X, Y, "Move towards lhs for 1 times the first time: ");

MoveLeft(beg, X, Y, 1);
print(beg, X, Y, "Move towards lhs for 1 times the second time: ");

MoveRight(beg, X, Y, 1);
print(beg, X, Y, "Move towards rhs for 1 times the first time: ");

MoveRight(beg, X, Y, 1);
print(beg, X, Y, "Move towards rhs for 1 times the second time: ");

exchange(beg, X, Y, 0, 1);
print(beg, X, Y, "Exchange col 1 and col 2: ");

exchange(beg, X, Y, 8, 7);
print(beg, X, Y, "Exchange col 9 and col 8: ");

}

测试结果：

Origin:
0 1 1 2 4 6 9 5 4
1 2 5 3 3 6 6 9 2
4 3 2 1 7 8 1 4 3
2 1 6 9 8 5 3 5 4
8 3 6 5 4 1 2 6 9
5 6 2 1 2 5 5 4 2
7 1 2 3 6 9 5 4 7
3 0 4 5 6 2 2 6 5
6 8 3 6 8 6 5 4 1

Move towards lhs for 1 times the first time:
1 1 2 4 6 9 5 4 0
2 5 3 3 6 6 9 2 1
3 2 1 7 8 1 4 3 4
1 6 9 8 5 3 5 4 2
3 6 5 4 1 2 6 9 8
6 2 1 2 5 5 4 2 5
1 2 3 6 9 5 4 7 7
0 4 5 6 2 2 6 5 3
8 3 6 8 6 5 4 1 6

Move towards lhs for 1 times the second time:
1 2 4 6 9 5 4 0 1
5 3 3 6 6 9 2 1 2
2 1 7 8 1 4 3 4 3
6 9 8 5 3 5 4 2 1
6 5 4 1 2 6 9 8 3
2 1 2 5 5 4 2 5 6
2 3 6 9 5 4 7 7 1
4 5 6 2 2 6 5 3 0
3 6 8 6 5 4 1 6 8

Move towards rhs for 1 times the first time:
1 1 2 4 6 9 5 4 0
2 5 3 3 6 6 9 2 1
3 2 1 7 8 1 4 3 4
1 6 9 8 5 3 5 4 2
3 6 5 4 1 2 6 9 8
6 2 1 2 5 5 4 2 5
1 2 3 6 9 5 4 7 7
0 4 5 6 2 2 6 5 3
8 3 6 8 6 5 4 1 6

Move towards rhs for 1 times the second time:
0 1 1 2 4 6 9 5 4
1 2 5 3 3 6 6 9 2
4 3 2 1 7 8 1 4 3
2 1 6 9 8 5 3 5 4
8 3 6 5 4 1 2 6 9
5 6 2 1 2 5 5 4 2
7 1 2 3 6 9 5 4 7
3 0 4 5 6 2 2 6 5
6 8 3 6 8 6 5 4 1

Exchange col 1 and col 2:
1 0 1 2 4 6 9 5 4
2 1 5 3 3 6 6 9 2
3 4 2 1 7 8 1 4 3
1 2 6 9 8 5 3 5 4
3 8 6 5 4 1 2 6 9
6 5 2 1 2 5 5 4 2
1 7 2 3 6 9 5 4 7
0 3 4 5 6 2 2 6 5
8 6 3 6 8 6 5 4 1

Exchange col 9 and col 8:
1 0 1 2 4 6 9 4 5
2 1 5 3 3 6 6 2 9
3 4 2 1 7 8 1 3 4
1 2 6 9 8 5 3 4 5
3 8 6 5 4 1 2 9 6
6 5 2 1 2 5 5 2 4
1 7 2 3 6 9 5 7 4
0 3 4 5 6 2 2 5 6
8 6 3 6 8 6 5 1 4

Answer 6

问题出在你给函数传参数的时候，你的原意应该是想把你的二位数组传给函数，可是你做的是什么呢，你的形参定义的是 int a[3][4] 这个是一个具体的int变量，是二位数组中的元素。要想传输组形参请用int * 比如DD(int *p)，调用的时候使用 数组名，比如DD(a)，这样便能实现你的原意而不是只传了一个数组元素了