在C++中設計一個多維數組

Question

我想爲多維數組設計一個C++類。通過多維我的意思是1d，2d，3d等。該類支持按元素加法和標量乘法運算符。假設A和B是類的實例（尺寸相同的尺寸爲&）。我想使用的對象在表達這樣的：

C = A * 2 + B

我想知道的事情是如何管理內存。在上面的表達式中，A * 2將創建該類的臨時對象，稍後將其添加到B.反正，臨時對象在添加完成後是垃圾。我寫了下面的類，它很好地工作，但我很確定它泄漏了內存。現在我的問題是，

1. 我該如何解決內存問題？什麼是設計課程的最佳方式？

2. 是否可以在堆棧而不是堆上分配所需的內存？

   class XArray 
   { 
       int num_dim; 
       int *dims; 
       int *index_helper; 
       int table_size; 
       double *table; 
   
   
   public: 
       XArray(const int n, const int *d):num_dim(n), dims(d) 
       { 
        int size = 1; 
        for (int i = 0; i < n; i++) { 
         size *= d[i]; 
        } 
        table_size = size; 
        table = new double[size]; 
        index_helper = new int[n]; 
       }; 
   
       ~XArray() 
       { 
        delete[] table; 
        delete[] index_helper; 
       }; 
   
       int dim(int d) 
       { 
        return dims[d]; 
       } 
   
       double& operator()(int i) 
       { 
        index_helper[0] = i; 
        return get_helper(1, index_helper); 
       } 
   
       double& operator()(int i, int j) 
       { 
        index_helper[0] = i; 
        index_helper[1] = j; 
        return get_helper(2, index_helper); 
       } 
   
       double& operator()(int i, int j, int k) 
       { 
        index_helper[0] = i; 
        index_helper[1] = j; 
        index_helper[2] = k; 
        return get_helper(3, index_helper); 
       } 
   
       XArray operator*(double m) 
       { 
        XArray *xa = new XArray(num_dim, dims); 
        for (int i = 0; i < table_size; i++) { 
         xa->table[i] = this->table[i] * m; 
        } 
   
        return *xa; 
       } 
   
       XArray operator+(const XArray &that) 
       { 
        if (num_dim != that.num_dim) { 
         char *msg = new char[100]; 
         sprintf(msg, "XArray::dimensions do not match in + operation, expected %d, found %d", num_dim, that.num_dim); 
         throw msg; 
        } 
   
        for (int i = 0; i < num_dim; i++) { 
         if (this->dims[i] != that.dims[i]) { 
          char *msg = new char[100]; 
          sprintf(msg, "XArray::dimension %d not mached, %d != %d", i, dims[i], that.dims[i]); 
          throw msg; 
         } 
        }  
   
        XArray *xa = new XArray(num_dim, dims); 
        for (int i = 0; i < table_size; i++) { 
         xa->table[i] = this->table[i] + that.table[i]; 
        } 
   
        return *xa; 
       } 
   
   private: 
       double& get_helper(int n, int *indices) 
       { 
        if (n != num_dim) { 
         char *msg = new char[100]; 
         sprintf(msg, "XArray::dimensions do not match, expected %d, found %d", num_dim, n); 
         throw msg; 
        } 
   
        int multiplier = 1; 
        int index = 0; 
   
        for (int i = 0; i < n; i++) { 
         if (indices[i] < 0 || indices[i] >= dims[i]) { 
          char *msg = new char[100]; 
          sprintf(msg, "XArray::index %d out of range, %d not in (0, %d)", i, indices[i], dims[i]); 
          throw msg; 
         } 
   
         index += indices[i] * multiplier; 
         multiplier *= dims[i]; 
        } 
   
       return table[index]; 
   } 
   

   };

Answer 1

這個問題應該可能在Code Review而不是在這裏。但在設計上有一些東西：

手動管理內存通常不是一個好主意，您應該更喜歡使用現有的容器而不是動態分配的數組。構造函數獲取傳入指針的所有權並不常見，並可能導致用戶代碼出現問題。目前您禁止某些用途，如：

int dims[3] = { 3, 4, 5 }; 
XArray array(3, dims); // or use sizeof(dims)/sizeof(dims[0]), or other trickery 

這是比簡單的用戶代碼：

int ndims = 5; 
int *dims = new int[ndims] 
XArray array(ndims, dims); 

這也意味着用戶必須意識到，dims所有權已經被收購，他們不能delete指針。

在內部，我會使用std::vector來維護動態內存，因爲這會免費爲您提供正確的語義。因爲您需要實現複製構造函數和賦值運算符（或禁用它們），因爲當前代碼不會泄漏，但可能會嘗試將某些內存加倍釋放。請記住三者的規則：如果您提供拷貝構造函數,賦值運算符或析構函數中的任何一個，那麼您應該提供全部三種。

你operator*和operator+泄漏內存（XArray對象本身的內部存儲器實際上是由於沒有拷貝構造函數的處理，但不認爲這是一個理由不創造拷貝構造函數，對相反你必須創建它）

投擲char*是允許的，但我會建議你不要因爲不同的原因。異常的類型應提供有關發生的情況的信息，否則，您的用戶代碼將不得不解析異常的內容以確定發生了什麼問題。即使您決定使用單一類型，請注意，在重載解析中使用的相同規則不適用於異常處理，尤其是您可能在轉換未發生時遇到問題。這也是設計中存在內存泄漏的另一個潛在可能，如拋出一個指向動態分配內存的指針，如果用戶不釋放內存，或者如果用戶沒有真正將內存釋放給用戶，則釋放內存的責任關心異常並抓住一切（catch (...) {}）你會泄漏錯誤。

如果在你的程序中可能有這種情況，那麼它可能會更好，如果這是可能的話（這是一個設計決定：錯誤的尺寸有多糟糕，即使例外情況也會發生，或者應該沒有發生？）。

index_helper不屬於該類的成員，它是由不同operator()和get_helper()方法只共享一個實現細節，則應該從類中刪除它，並且可以在每個operator()靜態分配它。這也有點奇怪，你提供單獨的operator() 1,2和3維度，而代碼是通用的，以處理任何維度，並且您還實際上要求用戶知道表示出公共接口，其中兩項作業被禁止，這也不是一個很好的設計。

Answer 2

我想念複製構造函數和賦值操作符。你將需要這些來創建內部緩衝區的副本，而不僅僅是複製指針，否則你最終將釋放相同的內存兩次。

如果您要支持C++ 0x，您還可能需要實現移動語義以獲得最佳性能。

像你一樣投擲動態分配的對象是一個非常糟糕的主意。

在您的運營商*您在堆上創建對象：

XArray operator*(double m) 
{ 
    XArray xa(num_dim, dims); 
    for (int i = 0; i < table_size; i++) { 
     xa->table[i] = this->table[i] * m; 
    } 

    return xa; 
} 

但是隻要你不寫你（移動）拷貝構造函數，這將崩潰。因爲return語句會創建一個指向與xa相同的內部數據的副本。 xa將被銷燬，並且它的析構函數將銷燬它的內部數據。所以正在返回的臨時對象在內部指向已銷燬的數據。

編輯：

鏈接信息關於Move semantics or rvalue references

Answer 3

我建議以下，以避免內存泄漏：

1. 讓拷貝構造函數和operator =()private和未執行，以避免table和index_helper被覆蓋（並導致內存泄漏意外）。如果你希望你使用它們，那麼確保，你做delete[] table和delete[] index_helper;之前重新分配，以避免泄漏。
2. 對於錯誤消息，使用std::string 而不是char *msg = new char[100];。它更清潔，並且可維護。
3. 請勿使用XArray *xa = new XArray(num_dim, dims);;而不是 只是聲明它爲XArray xa;。 這將是在棧和自動清盤 （如果你的C++ 0x的支持，那麼你可以選擇完美轉發，以消除不必要的副本）

與問候

現在你剩下class設計，答案非常主觀，需要詳細的代碼分析。所以，我會留給你決定。