Comment nettoyer (destructeur) un tableau dynamique de pointeurs?

Question

Est-ce que Destructeur est suffisant ou dois-je itérer pour supprimer les nouveaux nœuds ??

#include "stdafx.h" 
#include<iostream> 
using namespace std; 
struct node{ 
    int row; 
    int col; 
    int value; 
    node* next_in_row; 
    node* next_in_col; 
}; 

class MultiLinkedListSparseArray { 
private: 
    char *logfile; 
    node** rowPtr; 
    node** colPtr; // used in constructor 
    node* find_node(node* out); 
    node* ins_node(node* ins,int col); 
    node* in_node(node* ins,node* z); 
    node* get(node* in,int row,int col); 
    bool exist(node* so,int row,int col); 
    //add anything you need 
public: 
    MultiLinkedListSparseArray(int rows, int cols); 
    ~MultiLinkedListSparseArray(); 
    void setCell(int row, int col, int value); 
    int getCell(int row, int col); 
    void display(); 
    void log(char *s); 
    void dump(); 
}; 

MultiLinkedListSparseArray::MultiLinkedListSparseArray(int rows,int cols){ 
    rowPtr=new node* [rows+1]; 
    colPtr=new node* [cols+1]; 
    for(int n=0;n<=rows;n++) 
     rowPtr[n]=NULL; 
    for(int i=0;i<=cols;i++) 
     colPtr[i]=NULL; 
} 

MultiLinkedListSparseArray::~MultiLinkedListSparseArray(){ // is that destructor enough?? 
    cout<<"array is deleted"<<endl; 
    delete [] rowPtr; 
    delete [] colPtr; 
} 

Answer 1

Si vous insérez des pointeurs d'objets sur ces tableaux (vous d'abord les initialisez à NULL), vous devez les itérer pour supprimer chaque objet unique.

Comme toujours, une suppression pour chaque nouveau.

Answer 2

La règle d'or est que vous devez appeler supprimer une fois pour chaque fois que vous avez appelé nouveau. Si vous appelez new une fois pour construire le tableau, vous n'avez qu'à appeler delete une fois pour le détruire.

Si vous appelez nouveau sur un élément avant de l'ajouter à la liste et d'oublier l'élément que vous devez appeler supprimer sur ceux-ci aussi bien dans le destructeur. Ci-dessus, vous initialisez un tableau de pointeurs, et les 4 octets par pointeur seulement seront libérés correctement.

Habituellement, je surveille la responsabilité de chaque élément de mon code, si vous ajoutez un élément à la liste, la liste assume-t-elle la responsabilité de l'objet? Si vous avez quelque chose comme nouveau l'élément, ajoutez-le à la liste et détruisez le pointeur vers le nouvel objet, en ne laissant que la liste avec une référence, alors la liste doit prendre en charge la responsabilité de nettoyer la mémoire et il devrait itérer les objets et les libérer un par un.

Answer 3

Utilisez un conteneur standard pour les tableaux qui gèrent des pointeurs. Il y a rarement besoin de rouler les vôtres, et si par hasard il y en a, alors généralisez-le pour qu'il puisse être réutilisé.