指針作爲成員覆蓋內存

Question

這裏是處理對象陣列。我們有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(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被秒的對象替換。恰好從分別randx和randy（第二對）的100和50（第一對）。

Answer 1

您聲明數組，但你從來沒有爲它們分配內存。你所看到的僅僅是你的代碼如何遍佈整個堆棧。

更合適些：

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存儲數據的所有這種神奇的變得沒有必要。

Answer 2

的問題是由於你的方式宣告你的陣列：

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

既然你不聲明數組的大小，這相當於

O **o; 
F **f; 

因此，您聲明類型兩名成員「指針指向○」和「指針指向F」分別，但這些未初始化的並且尚未分配的任何內存爲他們指向。也就是說，你居然沒有任何陣列，公正的指針可能被用來指你想要陣列的類型。

如果您在編譯時知道您要使用的大小，您應該在聲明中指定該大小，這將爲您提供該大小的正確分配的數組。否則，請考慮使用std::vector。

Answer 3

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

我也會建議存儲對象，或者可能是智能指針，而不是數組中的原始指針。如果由於某種原因確實需要原始指針，請記得在完成後刪除對象，因爲這些對象不會自動發生，並且不要忘記Rule of Three。