C++ c+的错误+；指向数组的指针：一元*（have'；int）的类型参数无效，赋值的左操作数需要左值

我有一个名为

transform

的函数，它将引用两个数组的第一个索引

a

和

b

b

是一个数组，它包含一系列数字，这些数字决定了数组

a

的重新排列顺序

void transform(int& a, int& b, const int max_size)
{
    int output[max_size];

    for(int i = 0; i < max_size; i++)
    {
      output[i] = a + (b+i);
    }

    for(int j = 0; j < max_size; j++)
    {
      (a + j) = output[j];
    }
}

void变换（int&a、int&b、const int max_size）
{
int输出[max_size]；
对于（int i=0；i

---

当我试图编译程序时，我在第一个for循环中的命令上得到错误invalid type参数unary*，第二个for循环的赋值左操作数需要左值。有人能解释一下如何正确使用指针来实现我在这里要做的事情吗？

a

是一个参考资料。如果您想写入

a

并使用指针算术运算，您应该首先创建一个指针

*(&a + j) = output[j]; // this assignment will work

<>但是在C++中做这种事情是不寻常的。传递指向此类函数的指针更为清晰（同时根据需要标记它们

const

，

b

）

---

如果使用固定的数组大小，最好使用

std:：array

。或

std:：vector

，如果您希望动态确定大小。

a

是一个参考。如果您想写入

a

并使用指针算术运算，您应该首先创建一个指针

*(&a + j) = output[j]; // this assignment will work

<>但是在C++中做这种事情是不寻常的。传递指向此类函数的指针更为清晰（同时根据需要标记它们

const

，

b

）

---

如果使用固定的数组大小，最好使用

std:：array

。或

std:：vector

，如果希望动态确定大小。

a

是一个数字，因此是表达式

a+j=输出[j]

不是C++，

---

您可能想传递一个指针（

int*

），而不是一个整数（

int&

）的引用。

a

是一个数字，因此是表达式

a+j=输出[j]

不是C++，

您可能想传递指针（

int*

），而不是整数（

int&

）的引用。

在

（a+j）=输出[j]

将

j

添加到

a

时，会得到一个临时值，它是

a

和

j

的值之和。您没有访问数组元素。指针算法仅在有指针时有效，因为引用会返回到它所引用的元素

为了让它工作，你可以把它翻译成一个指针，比如

*(&a + j) = output[j];

它将访问阵列。这也意味着

output[i] = a + (b+i);

需要成为

output[i] = *(&a + *(&b+i));

不过，所有这些都可以通过将数组传递给函数来避免。那会给你一些

void transform(int a[], int b[], const int max_size)
{
    int output[max_size];

    for(int i = 0; i < max_size; i++)
    {
      output[i] = a[b[i]];
    }

    for(int j = 0; j < max_size; j++)
    {
      a[j] = output[j];
    }
}

void变换（int a[]，int b[]，常量int max_size）
{
int输出[max_size]；
对于（int i=0；iIn
（a+j）=输出[j]
将
j
添加到
a
时，会得到一个临时值，它是
a
和
j
的值之和。您没有访问数组元素。指针算法仅在有指针时有效，因为引用会返回到它所引用的元素

为了让它工作，你可以把它翻译成一个指针，比如

*(&a + j) = output[j];

它将访问阵列。这也意味着

output[i] = a + (b+i);

需要成为

output[i] = *(&a + *(&b+i));

不过，所有这些都可以通过将数组传递给函数来避免。那会给你一些

void transform(int a[], int b[], const int max_size)
{
    int output[max_size];

    for(int i = 0; i < max_size; i++)
    {
      output[i] = a[b[i]];
    }

    for(int j = 0; j < max_size; j++)
    {
      a[j] = output[j];
    }
}

void变换（int a[]，int b[]，常量int max_size）
{
int输出[max_size]；
对于（int i=0；i
我使用的是std:：array，而不是C样式的数组。您的建议是否仍然有效或传递的std:array更贵？@cdn如果您使用的是
std:：array
，则只需通过引用传递数组即可。语法有点冗长，但还不错。这看起来像是
template void transform（std:：array&a，std:：array&b）
，然后您可以使用
N
作为
max_size
，因为
N
将是数组的大小。我使用的是std:：array，而不是C样式的数组。您的建议是否仍然有效或传递的std:array更贵？@cdn如果您使用的是
std:：array
，则只需通过引用传递数组即可。语法有点冗长，但还不错。这看起来像
template void transform（std:：array&a，std:：array&b）
，然后您可以对
max_size
使用
N
，因为
N
将是数组的大小。