C++ 成员覆盖内存时指向对象数组的指针

这是交易。我们有两个不同的等级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(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);
    }

---

for（int i=0；i您正在声明数组，但从未为它们分配内存。您看到的只是代码在堆栈中的运行方式

更恰当的做法：

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;
};

结构X{}；结构Y{}；
P类{
公众：
P（）：xs（新X*[10]），ys（新Y*[10]）{init（）；}
~P（）{
//删除所有对象
对于（标准：：尺寸i=0；i<10；++i）
删除xs[i]；
对于（标准：：尺寸i=0；i<10；++i）
删除[i]；
删除[]x；
删除[]项；
}
私人：
void init（）{
//初始化
对于（标准：：尺寸i=0；i<10；++i）
xs[i]=新的X（）；
对于（标准：：尺寸i=0；i<10；++i）
ys[i]=新的Y（）；
}
//防止分配和复制
P&operator=（常数P&other）；
P（常数P&）；
X**xs；
Y**ys；
};

当然，如果你只是使用

---

std:：vector

来存储数据。

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

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

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

O **o;
F **f;

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

如果您在编译时知道要使用的大小，则应该在声明中指定该大小，这将给您一个适当大小的数组。否则，请考虑使用<代码> STD:：vector < /C> > /<

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));
}

std:：向量o；
对于（inti=0；iit不是你的问题，但是你是否为你的随机函数应用了种子？srand（time（NULL））；在询问有关StackOverflow的问题时，如果您发布实际代码，这将非常有帮助。例如，这里的
F
构造函数是小写的
F
-但您编译和运行的实际代码中不太可能是这种情况。如果您发布真实代码，我们可以更好地帮助您。数组真的声明为
O吗*o[]；
（无尺寸）或
o*o[10]
你的代码需要哪一个？你能把你的Prog构造函数放在问题中吗？编辑：nvm，你没有。你需要初始化o和f。@Laurence是的，我做了随机函数的种子。由于对它的解释，这是关于如何继续的非标准和很好的建议。我希望我能喜欢这个答案时代。