错误：无法转换＆＃39; int（*）[3]＆＃39;到＆＃39; int（*）[100]＆＃39;争论＆＃39; 1＆＃39; to＆＃39; void repl（int（*）[100]，int，int）＆＃39;

Question

您好我试图编写这个程序，用-1替换每个负数，用1替换正数 但是错误：

  

[错误]无法转换＆＃39; int（）[3]＆＃39;到＆＃39; int（）[100]＆＃39;争论＆＃39; 1＆＃39; to＆＃39; void replace（int（*）[100]，int，int）＆＃39;

这意味着什么？

#include<iostream>
using namespace std;
void replace(int Arr[][100],int rsize, int csize)
{
  for(int r=0;r<rsize;r++)
  {
    for (int c=0;c<csize;c++)
    {
      if (Arr[r][c]>0) Arr[r][c]=1;
      else if (Arr[r][c]<0) Arr[r][c]=-1;
      else Arr[r][c]=0;
    }
  }

}

int main()
{
    int a[4][3]={
    {2,0,-5},
    {-8,-9,0},
    {0,5,-6},
    {1,2,3}};

    replace(a,4,3);

    for(int i=0;i<4;i++)
      for (int j=0;j<3;j++)
        cout<<a[i][j]<<" ";}cout<<endl;

    system ("pause");
    return 0;
}

Answer 1

你声明了函数void replace(int Arr[][100],int rsize, int csize) - 它期望2D数组，内部＆＃39;尺寸为100。 然后你传递给它int a[4][3]，它有内心的＆＃39;维度3.编译器无法转换它。这些维度用于在使用Arr[x][y]时计算内存位置偏移（它相当于*(Arr + x * 100 + y)。这就是为什么编译器不能将数组赋值为3到100的数组。

如果您希望replace使用任何维度，请将其更改为： void replace(int* Arr,int rsize, int csize)。然后使用*(Arr + r*csize + c)访问字段而不是Arr[r][c]

更好的解决方案：您将此问题标记为C ++ - 使用C ++库:) - std::vector<std::vector<int> >或std::array（C ++ 11）

Answer 2

你声明一个需要int[][100]的函数，然后你传递int[4][3]。 C ++并不像这样工作。实际上，你根本无法按值传递数组;他们含蓄地衰减指针。

如果你希望你的函数采用任意大小的数组，你可以让它指向指针：

void replace(int** Arr,int rsize, int csize)

然后你应该抛弃你的代码并改为使用std::vector：

void replace(std::vector<std::vector<int>> &Arr)

如果你想对数组的大小有一些编译时限制，你可以这样做：

template <std::size_t X, std::size_t Y>
void replace (std::array<std::array<int,Y>,X>& Arr)
{
    static_assert (Y <= 100, "Inner array is too large");
}

Answer 3

问题在于你将你的论证（Arr [] [100]）声明为有100个元素。但它不是100个元素，而是代码中的三个元素。我假设您真正想要的是能够传递不同大小的数组，并在其他参数中指定数组维度。如果是这种情况，您可以将数组声明为int *。所以像下面这样的东西会起作用：

#include "stdafx.h"
#include<iostream>
using namespace std;


void replace(int *Arr, int rsize, int csize);
void print(int *Arr, int rsize, int csize);

int _tmain(int argc, _TCHAR* argv[])
{
    int a[4][3] = {
        { 2, 0, -5 },
        { -8, -9, 0 },
        { 0, 5, -6 },
        { 1, 2, 3 } };

    print((int *)a, 4, 3);


    replace((int *)a, 4, 3);
    for (int i = 0; i<4; i++)
    {
        for (int j = 0; j<3; j++)
        {
            cout << a[i][j] << " ";
        }cout << endl;
    }


    system("pause");
    return 0;
}


void replace(int *Arr, int rsize, int csize)
{
    for (int r = 0; r<rsize; r++)
    {
        for (int c = 0; c<csize; c++)
        {
            int index = (r * (rsize - 1)) + c;
            if (Arr[index] > 0)
            {
                Arr[index] = 1;
            }
            else if (Arr[index] < 0)
            {
                Arr[index] = -1;
            }
            else
            {
                Arr[index] = 0;
            }
        }
    }
}

void print(int *Arr, int rsize, int csize)
{
    char str[256];

    for (int r = 0; r<rsize; r++)
    {
        sprintf(str, "");
        for (int c = 0; c<csize; c++)
        {
            int index = (r * (rsize - 1)) + c;
            if (strlen(str) > 0)
            {
                sprintf(str, "%s, ", str);
            }
            sprintf(str, "%s%d", str, Arr[index]);
        }

        cout << str;
        cout << endl;
    }
}

请不要使用我使用不安全字符串函数的示例。

这样做的原因是二维int数组只是堆叠在一起的一堆一维数组。因此int [4] [3]在内存中只有12个整数。这在功能上与int [12]相同。如果将函数的输入声明为int *，那么它是指向包含整数的内存块的指针，并不重要。所以你可以避免你得到的类型转换错误。

如果您不确定参数是否正确，那么这样做有很多风险。例如，如果使用相同的输入数组调用相同的替换函数，但声称它有5行，那么您将开始读取未初始化的内存。 （可能没有初始化...更准确地说，你至少会读到不像你想象的那样的记忆。）当然，你可以在没有指针的情况下做同样的事情，这是整个乐趣C ++的一部分。