0

这是交易。我们有 2 个不同的类 F 类和 O 类

class F {
    private:
        int x;
        int y; 
    public:
        int getXf(){ return x; }
        int getYf(){ return y; }
        f(int ,int);
};

class O {
    private:
        int n;
        int k;
        int x;
        int y;
        char type;
        int id;
        int t;
    public:
        O(int ,int ,int ,int ,int);
        int getX(){ return x; }
        int getY(){ return y; }
};

我们有第三个类 P，我们在其中初始化值。在类中，我们创建了两个对象数组。

class Prog {                                                                   
    public:
        int count;
        int fcount;
        O *o[]; //here we are declaring the arrays of objects
        F *f[];           
    public :
        //void init(); Here is the function where we initializing the values
};

现在我们在其中创建对象的 2 个 for 语句。

for(int i=0;i<10;i++){
        randx = rand() % 10;
        randy = rand() % 20;

        o[i] = new O(100,50,i,randx,randy);
    }


    for(int i=0;i<3;i++){
        randx = rand() % 10;
        randy = rand() % 10;

        f[i] = new F(randx, randy);
    }

当我们打印时，所有的对象都在这里，但第一类的前 3 个被秒的对象替换。分别是100和50(1st for) fromrandx和randy(2nd for)。

4

3 回答 3

6 
O *o[];

这声明了一个未知大小的数组，这是一个不完整的类型。C++ 不允许将其用作类成员，尽管一些编译器将允许它作为扩展，将其解释为大小为零的数组。无论哪种情况，这都不是您想要的。

如果您知道在编译时绑定的数组，那么您应该指定它：

O *o[10];

否则，您需要在运行时动态分配一个数组：

std::vector<O*> o;

for(int i=0;i<10;i++){
    randx = rand() % 10;
    randy = rand() % 20;

    o.push_back(new O(100,50,i,randx,randy));
}

我还建议在数组中存储对象，或者可能是智能指针，而不是原始指针。如果您出于某种原因确实需要原始指针，请记住在完成对象后删除它们，因为这不会自动发生，并且不要忘记三法则。

于 2013-01-10T14:48:35.480 回答
5

您正在声明数组，但您从不为它们分配内存。您所看到的只是您的代码在整个堆栈中的运行方式。

更合适的东西：

struct X {}; struct Y {};

class P {
public:
  P() : xs(new X*[10]), ys(new Y*[10]) { init(); }

  ~P() {
    // delete all objects
    for(std::size_t i = 0; i < 10; ++i)
      delete xs[i];
    for(std::size_t i = 0; i < 10; ++i)
      delete ys[i];

    delete[] xs;
    delete[] ys;
  }
private:
  void init() {
    // initialize
    for(std::size_t i = 0; i < 10; ++i)
      xs[i] = new X();
    for(std::size_t i = 0; i < 10; ++i)
      ys[i] = new Y();
  }

  // prevent assignment and copy
  P& operator=(const P& other);
  P(const P&);

  X** xs;
  Y** ys;
};

当然，如果您只是 std::vector用来存储数据，那么所有这些魔法都变得不必要了。

于 2013-01-10T14:40:06.370 回答
1

问题在于您声明数组的方式：

O *o[/*No size here*/];
F *f[/*No size here*/];

由于您没有说明数组的大小，因此这相当于

O **o;
F **f;

因此，您分别声明了两个类型的成员“指向 O 的指针”和“指向指​​向 F 的指针”，但它们未初始化，并且您没有为它们分配任何内存来指向。也就是说，您实际上没有任何数组，只有可用于引用所需数组类型的指针。

如果您在编译时知道要使用的大小，则应在声明中指定该大小，这将为您提供正确分配的该大小的数组。否则，请考虑使用std::vector.

于 2013-01-10T14:47:44.123 回答