Question

这是我在Java中所做的事情，但我很难用C ++来解决这个问题。

基本上，我有两个数组，我想将第二个数组的内容复制到第一个数组中。而不是在一个循环中浪费时间，从第二个数组到第一个数组一次一个地复制每个数组元素的内容，我只想把我的第一个数组变量指向存储第二个数组的位置。

以下是一个例子：

void modify(int[]);

int main (){
  // foo points to (for example) memory location 123
  int foo[5] = { 16, 2, 77, 40, 12071 };

  modify(foo);
  // foo now contains the modified data

  return 0;
}

void modify(int bar[]){
// bar points to memory location 123
// (ie, bar points to the same location as foo)

  // baz points to (for example) memory location 4567
  int baz[5];

  // this loop can't modify my data in-place,
  // so it uses baz temporarily
  for(int i = 0; i < 5; i++){
    int j;
    if(i == 0) j = 4;
    else j = i - 1;
    baz[i] = bar[i] + bar[j];
  }
  // baz now contains the modified data

  // now, I would like to put the data located in 4567 (baz) into foo
  // I know I could loop through each element one at a time like:
  // for(int i; i < 5; i++)
  //   bar[i] = baz[i];
  // but I feel that for large arrays, this could be unnecessarily slow
  // it would be more efficient to say:
  // "ok, now foo points to memory location 4567"
  // but I don't know how to say that in C++
  bar = baz; // this doesn't work :-(
  foo = baz; // neither does this :'(
}

我如何在C ++中执行此操作？

- 布赖恩

Answer 1

使用std::vector。

你可以使用其swap成员函数，但这只是通过引用（或指针）传递参数的C风格代码所必需的。

只需返回本地创建的结果向量，其缓冲区将自动移入函数结果。

#include <vector>
using namespace std;

auto modified( vector<int> const& v )
    -> vector<int>
{
    int const n = v.size();
    vector<int> result( n );
    for( int i = 0; i < n; ++i )
    {
        int const j = (i == 0? n - 1 : i - 1);
        result[i] = v[i] + v[j];
    }
    return result;
}

auto main()
    -> int
{
    vector<int> const   foo = { 16, 2, 77, 40, 12071 };
    vector<int> const   baz = modified( foo );
}

这很像烹饪。

你干预越少，你让编译器完成它的工作就越多，通常用更少的努力就能获得更好的结果。

Answer 2

在C ++中，您无法交换混凝土阵列。您可以做的是改为使用std::vector，特别是使用std::vector::swap成员函数来交换它们，如下例所示：

#include <iostream>
#include <vector>

void modify(std::vector<int> &v);

int main () {
  std::vector<int> foo {16, 2, 77, 40, 12071};

  modify(foo);

  for(auto i : foo) std::cout << i << " ";
  std::cout << std::endl;

  return 0;
}

void modify(std::vector<int> &bar) {
  // baz points to (for example) memory location 4567
  std::vector<int> baz(bar.size());

  // this loop can't modify my data in-place,
  // so it uses baz temporarily
  for(int i(0), sz(bar.size()); i < sz; ++i){
    int j;
    if(i == 0) j = 4;
    else j = i - 1;
    baz[i] = bar[i] + bar[j];
  }
  bar.swap(baz);
}

LIVE DEMO

Answer 3

在C ++中，数组不指向。不可能在某处创建数组“点”，两个数组也不可能共享内存空间。只有指针指向。

此外，baz是modify内的自动变量。它在modify完成时被销毁，因此返回指向baz的指针是个坏主意。

要执行您所描述的内容，需要调用者和被调用者同意内存分配技术（因为被调用者必须分配新内存，然后在完成时释放旧内存）。内存分配和释放几乎肯定比复制5个整数要慢。

如果你真的想这样做，那么要做的是使用vector而不是数组（这包装动态分配）;通过引用你的函数传递它，并在函数中有另一个vector，然后当你完成后，执行swap，它将在恒定时间内交换两个向量的内容。

Answer 4

如果您只想将数组分配给新变量，可以制作指针。指针是一个存储另一个变量地址的变量。所以你可以简单地做：

int bar[3] = {1, 2, 3};
int* baz = bar;

这将有效。

但是你没有能够将新数组发送到静态数组。您应该尝试创建这样的动态数组：

int* foo = new int[3];

现在，如果您希望变量foo指向另一个数组，则必须删除现有数组：

delete []foo;
foo = baz;

（它会在不删除它的情况下工作，但由于没有垃圾收集器，你会有内存泄漏）

P.S。

Here is more on pointers

Here is more on dynamic memory

如何使数组变量指向不同的数组，有效地将第二个数组的内容复制到第一个？

4 个答案: