Question

C ++新手，希望复制C＃中可用的一些功能，包括用新构造的数组替换对象数组成员。

class Car {
    int id;
    Car() {}
};
class Garage {
    Car cars[1];
    Garage() {}
    void addCars(Car crs[]) {
        //...do update here
    }
};

在C＃中我可以做类似的事情：

addCars(Car[] crs){
    Car[] temp = new Car[cars.Length + crs.Length];
    for(int i = 0; i < cars.length; i++){
        temp[i] = cars[i];
    }
    for(int i = 0; i < crs.Length; i++){
        temp[i + cars.Length] = crs[i];
    }
    cars = temp;
}

或Array.Resize，Array.Copy。

我可以声明一个数组并替换现有的对象实例成员数组吗？

如果不可能：C ++中的数组有多实用？我可以看到Excel使用它们（如果它们不可修改），但似乎它真的有限。我可以看到为什么内存分配可能会限制这一点，但显然我来自C栅栏更容易的一面。

感谢。

Answer 1

作为一个例子，这里将是某种类似于你的例子的C ++。它可能与C＃等价物有一些模糊的外表。

#include <initializer_list>
#include <iostream>
#include <ostream>
#include <vector>

using std::vector;
using std::cout;
using std::endl;
using std::ostream;
using std::initializer_list;

struct Car {
  int id;
  Car(int newId) : id{newId} {}
};

ostream& operator<<(ostream& o, Car const& car) {
  o << car.id;
  return o;
}

struct Garage {
  vector<Car> cars;
  Garage() {}

  void addCars(initializer_list<Car> l) {
    cars.insert(cars.end(), l.begin(), l.end());
  }
};

ostream& operator<<(ostream& o, Garage const& garage) {
  char const* sep = "";
  for (auto const& car : garage.cars) {
    o << sep << car;
    sep = ", ";
  }
  return o;
}

int main() {
  Garage garage;
  garage.addCars({7, 8, 99, 1000});
  cout << garage << endl;
  return 0;
}

Answer 2

C ++数组和std::array在编译时是固定大小的。它们的大小不能在运行时改变。您可以将std::array复制到另一个std::array（＆＃34;替换＆＃34;）。但是你不能为C ++内置数组这样做：这些需要逐个元素地复制，例如std::copy()。

如果您需要动态调整容器大小，则应考虑使用std::vector。这些更加灵活。你当然可以复制或移动它们作为一个整体。

Answer 3

我可以声明一个数组并替换现有的对象实例成员数组吗？

不，std::array和type[]数组大小在编译时是已知的。如果新数组与现有数组具有相同的大小，则需要副本（例如，memcpy）

理论上你可以改用指针，例如

Car cars* = nullptr;
// ...
cars = new Car[size];
// ...
delete[] cars;

然而，这会给你带来内存跟踪的负担（我不得不手动调用delete[]）。相反，请使用std::vector，它为您包装所有逻辑。

std::vector<Car> cars;
Car c;
// ...
cars.push_back(c);

C ++中的数组有多实用？

非常实用。许多高性能计算都依赖于数组，这些数据的大小在编译时是出于性能原因而闻名。

可以替换类成员数组/ std ::数组吗？

3 个答案: