堆棧變量''在C++中損壞

Question

當我嘗試調用構造函數時出現運行時錯誤，並且我認爲我沒有正確執行內存刪除操作。這裏是我的construcor：

const int id_ferma; 
int suprafata; 
int nr_produse; 
char* produse[]; 

Ferma(int id_ferma, int suprafata, int nr_produse, char* produse[]) :id_ferma(id_ferma){ 
     this->suprafata = suprafata; 
     this->nr_produse = nr_produse; 
     for (int i = 0; i < nr_produse; i++){ 
      this->produse[i] = new char[strlen(produse[i]) + 1]; 
      strcpy(this->produse[i], produse[i]); 
      cout << produse[i] << endl; 
     } 
    } 

這裏是我的析構函數：

~Ferma(){ 
    for (int i = 0; i < nr_produse; i++){ 
      if (this->produse[i] != NULL) 
       delete produse[i]; 
    } 
} 

而且主：

int main(){ 
     char* produse1[] = { "Lapte oaie", "Branza vaca", "Muschi de porc", "Oua de gaina" }; 
     for (int i = 0; i < 4; i++){ 
      cout << produse1[i]; 
     } 
     Ferma f1(14, 1500, 4, produse1); 
    } 

Answer 1

你沒有初始化的produse領域。

如果你想使用C++慣用，你應該使用vector而不是原始數組，string而不是char*。

Answer 2

既然你new[]分配內存，你需要delete[]釋放它：

int *p = new int[10]; 
... 
delete[] p; 

int* p[1] = {new int[10]}; 
... 
delete[] p[0]; 

而且由於produse爲char **，你應該設法取消對它的引用之前produse分配內存：

char **produse = new char *[10]; 
produse[0] = new char [10]; 
... 
delete[] produse[0]; 
delete[] produse; 

Answer 3

在嘗試填充this->produse之前，您沒有分配任何內存。另外，由於您手動管理動態分配的內存，因此您還需要手動實施Rule of Three。

試試這個：

#include <algorithm> 

class Ferma 
{ 
private: 
    int m_id_ferma; 
    int m_suprafata 
    int m_nr_produse; 
    char** m_produse; // <-- change this to char**! 

public: 
    Ferma(int id_ferma, int suprafata, int nr_produse, char* produse[]) 
     : m_id_ferma(id_ferma), m_suprafata(suprafata), m_nr_produse(nr_produse) 
    { 
     m_produse = new char*[nr_produse]; // <-- add this! 

     for (int i = 0; i < nr_produse; ++i) 
     { 
      m_produse[i] = new char[strlen(produse[i]) + 1]; 
      strcpy(m_produse[i], produse[i]); 
     } 
    } 

    Ferma(const Ferma &src) // <-- add this! 
     : m_id_ferma(src.m_id_ferma), m_suprafata(src.m_suprafata), m_nr_produse(src.m_nr_produse) 
    { 
     m_produse = new char*[m_nr_produse]; 

     for (int i = 0; i < m_nr_produse; ++i) 
     { 
      m_produse[i] = new char[strlen(src.m_produse[i]) + 1]; 
      strcpy(m_produse[i], src.m_produse[i]); 
     } 
    } 

    ~Ferma() 
    { 
     for (int i = 0; i < m_nr_produse; ++i) 
      delete[] m_produse[i]; // <-- change this to delete[]! 

     delete[] m_produse; // <-- add this! 
    } 

    Ferma& operator=(const Ferma &rhs) // <-- add this! 
    { 
     Ferma tmp(rhs); 
     std::swap(m_id_ferma, tmp.m_id_ferma); 
     std::swap(m_suprafata, tmp.m_suprafata); 
     std::swap(m_nr_produse, tmp.m_nr_produse); 
     std::swap(m_produse, tmp.m_produse); 
     return *this; 
    } 
}; 

話雖這麼說，你應該停止使用手動內存管理。使用std::vector和std::string代替，讓STL處理所有的內存管理爲您提供：

#include <vector> 
#include <string> 

class Ferma 
{ 
private: 
    int m_id_ferma; 
    int m_suprafata; 
    std::vector<std::string> m_produse; 

public: 
    Ferma(int id_ferma, int suprafata, int nr_produse, char* produse[]) 
     : id_ferma(id_ferma), m_suprafata(suprafata) 
    { 
     m_produse.reserve(nr_produse); 

     for (int i = 0; i < nr_produse; ++i) 
      m_produse.push_back(produse[i]); 

     // alternatively: 
     // std::copy(produse, produse+nr_produse, std::back_inserter(m_produse)); 
    } 

    // no destructor, copy constructor, or copy assignment operator needed! 
};