Tableau de structures et de new / delete

J'ai une structure comme ceci:

class Items 
{
private:
    struct item
    {
        unsigned int a, b, c;
    };
    item* items[MAX_ITEMS];
}

Dire que je voulais supprimer un élément, comme suit:

items[5] = NULL;

Et j'ai créé une nouvelle rubrique sur ce même emplacement plus tard:

items[5] = new item;

Ai-je toujours besoin d'appeler delete[] pour nettoyer ça? Ou ce ne sera pas nécessaire étant donné les limites de la matrice de items[] sont connus avant la compilation?

Est le paramètre le pointeur à NULL valide ou devrais-je appeler en supprimer?

OriginalL'auteur Daniel Sloof | 2009-01-12

arrays c++memory-management new-operator struct

15

Vous devez appeler delete avant de le mettre à NULL. (Le réglage de la valeur NULL n'est pas nécessaire, qu'il aide à réduire les bugs si vous avez accidentellement essayer de déréférencer le pointeur après la suppression.)

Rappelez-vous que chaque fois que vous utilisez new, vous aurez besoin d'utiliser delete plus tard sur le même pointeur. N'utilisez jamais l'un sans l'autre.

Aussi, new [] et delete [] aller ensemble dans la même façon, mais vous ne devez jamais mélanger new [] avec delete ou new avec delete []. Dans votre exemple, depuis la création de l'objet avec new (plutôt que new [] qui permettrait de créer un tableau d'objets de), vous devez supprimer l'objet avec delete (plutôt que delete []).

OriginalL'auteur Jeremy Ruten
6

Que Kluge a souligné, vous feriez fuite de l'objet à l'index 5 comme ça. Mais celui-ci sonne vraiment comme vous ne devriez pas le faire manuellement, mais l'utilisation d'une classe de conteneur à l'intérieur de Item. Si vous n'avez pas réellement besoin de stocker ces item objets comme des pointeurs, l'utilisation std::vector<item> à la place de ce tableau de MAX_ITEMS pointeurs. Vous pouvez toujours insérer ou effacer les éléments du vecteur dans le milieu ainsi si vous en avez besoin.

Dans le cas où vous avez besoin de stocker des objets comme des pointeurs (généralement si struct item est en réalité polymorphe, à la différence dans votre exemple), vous pouvez utiliser boost::ptr_vector<item> à partir de Coup de pouce.PtrContainer à la place.

Exemple:
```
class Items {
private:
    struct item {
        unsigned int a, b, c;
    };
    std::vector<item> items;
}

if (items.size() > 5) //(just to ensure there is an element at that position)
    items.erase(items.begin() + 5); //no need to use operator delete at all
```
OriginalL'auteur Pyry Jahkola
1

Pour supprimer un élément à utiliser:

supprimer des éléments[5];

après la suppression de l'élément, il est recommandé de définir la supprimé pointeur à NULL, donc vous n'aurez pas une erreur si vous supprimez par erreur.

éléments[5] = NULL

J'accepte cette réponse

OriginalL'auteur Joao Vilaca
1

Dire que je voulais supprimer un élément, comme suit:

éléments[5] = NULL;

Je sais peu de Visual Basic, mais qui sent comme un langage de programmation Visual Basic, depuis "a = None" (ou Nulle, je ne suis pas sûr) aurait pour effet de supprimer l'objet pointé par un (ou plutôt de décrémentation son compte de référence, pour les objets COM).

Que quelqu'un d'autre l'a noté, vous devez utiliser:
```
delete items[5];
items[5] = newContent;
```
ou:
```
delete items[5];
items[5] = NULL;
```
Après delete[5], la seule utilisation possible de le pointeur stocké dans items[5] est l'origine de vos ennuis. Ce qui est pire, c'est que cela pourrait arriver à travailler au début, et de commencer à défaut uniquement lorsque vous allouer quelque chose d'autre sur l'espace déjà utilisé par *items[5]. Ceux sont les causes qui font de programmation C/C++ "intéressant", c'est à dire vraiment ennuyeux (même pour qui aime C comme moi).

L'écriture delete items[5]; sauve ce qui peut être une inutile d'écrire, mais c'est une optimisation prématurée.

OriginalL'auteur Blaisorblade
1

Juste pour être clair: vous vous référez à l'appel de "delete[]". Je pense que tu veux dire delete.

Je mentionne cela parce que le C++ dispose de deux opérateurs distincts, operator delete et operator delete[]. Ce dernier est utilisé pour supprimer des ensembles d'objets alloués avec operator new[], et ne pas s'appliquent dans ce cas. Vous disposez d'un tableau de des pointeurs vers objets, vous devez avoir initialisé avec des appels répétés à la operator new plutôt qu'un seul appel à operator new[].

Tout ce que je suis vraiment en train de dire est: votre utilisation de delete[] est confuse et ambiguë; changer à delete.

OriginalL'auteur j_random_hacker
1

Il y a quelques liés, à des questions ici:
1. Selon le code que vous avez posté, le tableau lui-même n'est pas alloué sur le tas, à moins que le struct est, de sorte que vous n'avez pas besoin de delete[] le tableau. Si vous avez créé un tableau avec new[] vous auriez à delete[].
2. Le code affiché ne dit pas comment les objets pointus à partir de la matrice sont alloués. Si vous répartir ces objets sur la pile, vous ne doit pas les supprimer (là encore, c'est très peu probable parce que votre pointeurs devient caduque lorsque les objets qu'ils le point de tomber hors de portée). Si vous avez alloué sur le tas (à nouveau), puis vous doit les supprimer quand ils tombent hors de portée.
3. Comme d'autres l'ont déjà suggéré, la vie est beaucoup plus facile si vous utilisez un récipient -- surtout un conteneur STL -- et des pointeurs intelligents -- ce qui signifie que les pointeurs de Boost.
OriginalL'auteur
0

C++ n'est pas mon fort, mais je suis sûr que vous seriez fuite de la mémoire si vous réglez le pointeur de NULL.

EDIT: La mémoire de la fuite serait la mémoire pointé par le pointeur dans le tableau.

OriginalL'auteur Hank Gay
0

Éléments de réglage[5] à la valeur NULL n'est pas de supprimer la mémoire associée à l'élément, il suffit simplement de définir le pointeur sur l'élément en question à NULLE, donc les fuites de mémoire.

Vous pouvez supprimer l'élément en appelant le:
```
delete items[5];
```
Depuis C++ a pas de collecte des ordures automatique, vous devez le supprimer de la mémoire, vous n'avez plus besoin.

OriginalL'auteur Kluge

Vous devez vous connecter pour publier un commentaire.