C++ : Que signifie "nouveau" une collection qui va continuer à croître ?

Question

Je suis novice en C++. Que signifie exactement "nouveau" pour une collection ? Par exemple :

UnicodeStringList* tmp = new UnicodeStringList;
// where UnicodeStringList is typedef to std::list<UnicodeString>

Lorsque vous "créez" quelque chose, vous devez savoir exactement quelle taille il vous faut, n'est-ce pas ? Donc quand je utilise le constructeur d'affectation pour copier un objet, comment l'ordinateur saura-t-il quelle quantité de mémoire doit être allouée sur le tas ? Par exemple :

*tmp = another_string_list;

Une autre_string_list est copiée dans ma nouvelle UnicodeStringList dans la mémoire du tas, mais je n'ai jamais spécifié initialement la taille de cette mémoire du tas. Et le compilateur ne sait pas quelle est la taille d'une autre_string_list, donc combien de mémoire va dans le tas ?

Je suis confus et j'espère avoir suffisamment précisé ma question pour que quelqu'un puisse me comprendre, mais je ne suis pas sûr.

Veuillez m'aider

Merci,

Julian

Answer 1

La taille d'un std::list ne change pas lorsque vous y ajoutez des éléments. Je vais utiliser un std::vector car l'exemple est plus simple, mais le même concept s'applique : une std::vector contient un pointeur vers un tableau, qui est dynamiquement redimensionné si nécessaire pour contenir vos éléments. Le pointeur vers le tableau ne change pas de taille (c'est la taille d'un pointeur), même si le tableau vers lequel il pointe change

Answer 2

Tout ce que fait ce "nouveau" est d'allouer assez d'espace pour stocker toutes les variables membres pour votre std::list . Tout ce qui doit être fait en plus est l'affaire de l'entreprise. std::list Il devrait s'en occuper lui-même (via ses constructeurs et destructeurs).

Answer 3

Quand tu "nouvelles" quelque chose, tu dois savoir exactement quelle taille tu dois avoir, non ?

Pas exactement. Du moins, pas de la manière dont tu y penses.

Quand vous new un tableau brut, vous devez bien sûr fournir le nombre d'éléments du tableau. Mais std::list , std::vector et tels sont no des tableaux bruts.

En prenant std::list à titre d'exemple : De l'extérieur, on peut le considérer comme un objet qui contient tout ce qu'on y met. Cependant, dans le détail, c'est un objet qui ne contient directement que des pointeurs. Ces pointeurs pointent vers d'autres objets qu'il a alloués sur le tas (à l'aide de la fonction new ). Ainsi, une instance de std::list est toujours de la même taille, mais si vous y ajoutez des éléments, il finira par allouer plus d'éléments ailleurs sur le tas pour les gérer.

C'est également la raison pour laquelle vous pouvez utiliser une liste comme variable locale allouée à une pile et n'avoir aucun problème à y placer un nombre quelconque d'éléments.

UnicodeStringList MyList;
MyList.push_back(item1);
MyList.push_back(item2);

Pas besoin de new . La liste organise sa propre comptabilité interne (allouée par le tas) pour s'adapter à tous les éléments que je souhaite y ajouter.

Ainsi, lorsqu'une liste A est assignée à une liste B, tous les éléments (et tous les objets comptables gérés en interne) de la liste A sont copiés dans des éléments nouvellement alloués au tas et donnés à la liste B pour qu'elle les gère.

Answer 4

Le seul endroit où vous devez réellement connaître la taille d'un objet, c'est sur la pile. La pile doit croître d'une manière très statique pour satisfaire votre compilateur. Le tas, par contre, n'a pas de telles contraintes.

Quand vous new quelque chose, vous l'allouez sur le tas. Par conséquent, il peut être de n'importe quelle taille. Ce qui vous surprend plutôt, c'est que les collections peuvent également être allouée sur la pile. En effet, peu importe ce que contient une collection, sa taille est invariable. Au contraire, elle contient des informations (comme des pointeurs) vers le tas où la taille d'une allocation doit être variante.

Answer 5

Quand vous new et un objet, vous obtenez la mémoire requise pour cet objet dans son état initial. Cependant, vous devez réaliser qu'une classe peut implémenter une certaine complexité dans la façon dont elle gère son état interne.

Pour répondre spécifiquement à votre question, une classe (dans votre cas une list<> ) peut lui-même allouer et libérer dynamiquement de la mémoire au cours de ses opérations. Et c'est ce que votre list Lorsqu'un élément est ajouté à la liste, il alloue de la mémoire pour cet élément et effectue toutes les opérations nécessaires à la gestion de ce nouvel élément, en utilisant généralement des pointeurs ou des objets pointeurs intelligents. Ainsi, la mémoire utilisé par le list<> peut changer, mais l'objet liste "principal" lui-même reste de la même taille que lorsqu'il a été alloué à l'origine.