Opérateur de nouveaux initialise la mémoire à zéro

Il y a un tel code:

#include <iostream>

int main(){
  unsigned int* wsk2 = new unsigned int(5);
  std::cout << "wsk2: " << wsk2 << " " << *wsk2 << std::endl;
  delete wsk2;
  wsk2 = new unsigned int;
  std::cout << "wsk2: " << wsk2 << " " << *wsk2 << std::endl;
  return 0;
}

Résultat:

wsk2: 0x928e008 5
wsk2: 0x928e008 0

J'ai lu que new ne pas initialiser la mémoire avec des zéros. Mais ici, il semble qu'il n'. Comment ça fonctionne?

Il n'est pas le cas, vous devez utiliser le nouveau unsigned int(). La lecture de variables non initialisées UB, un 0 est certainement possible.
En aparté, dans la pratique, beaucoup de mémoire est nul de toute façon. Si vous faites une plaine malloc d'une grande partie de la mémoire, il est souvent tout à zéro sur certains systèmes, ou la plupart du zéro sur les autres.
Pour la plupart des systèmes, cela n'est vrai que lorsque la mémoire est venu directement à partir de l'OS (pour des raisons de sécurité). Quand il est venu à partir de la mémoire cache par l'allocateur, il est probable qu'il contient tout ce qu'il a fait avant c'était gratuit()d. C'est aussi une raison pour laquelle de tels bugs, parfois, ne se pose pas dans le cas de tests/tests unitaires, mais seulement après un certain temps de la "vraie" programme en cours d'exécution. Valgrind à la rescousse ici.
Oui. C'est le genre de mon point de vue. Si vous faites une nouvelle variable et de voir que c'est zéro, vous ne pouvez pas tout de suite supposer que quelque chose dans votre programme a mis à zéro. Depuis plus de mémoire est prêt à zéro, il est probablement non initialisée. Je pense que ma remarque est en fait plus proche pour répondre à la question que la plupart des réponses ci-dessous, parce que l'interlocuteur a voulu savoir pourquoi la mémoire non initialisée pourrait être de zéro.
Essayez de l'allocation d'un tableau, le réglage de tous les éléments pour certaines valeur différente de zéro, puis de les supprimer[] et le répartir de nouveau - seul le premier élément sera remis à zéro - autres conservent leurs valeurs - qui je pense est un pecurliarity de l'allocateur de mémoire (testé sous Linux).
Liées (demande pour les tableaux): stackoverflow.com/questions/2204176/...

InformationsquelleAutor scdmb | 2011-09-25

c++memory-management

166

Il y a deux versions:
```
wsk = new unsigned int;      //default initialized (ie nothing happens)
wsk = new unsigned int();    //zero    initialized (ie set to 0)
```
Fonctionne également pour les tableaux:
```
wsa = new unsigned int[5];   //default initialized (ie nothing happens)
wsa = new unsigned int[5](); //zero    initialized (ie all elements set to 0)
```
En réponse au commentaire ci-dessous.

Euh... vous êtes sûr que new unsigned int[5]() zéros entiers?

Apparemment oui:

[C++11: 5.3.4/15]: Une nouvelle expression qui crée un objet de type T initialise l'objet comme suit: Si le nouveau-initialiseur est omis, l'objet est par défaut-initialisé (8.5); si l'initialisation est effectuée, l'objet a une valeur indéterminée. Sinon, la nouvelle-initialiseur sont interprétés en fonction de l'initialisation des règles de 8,5 directe pour l'initialisation.
```
#include <new>
#include <iostream>


int main()
{
    unsigned int   wsa[5] = {1,2,3,4,5};

    //Use placement new (to use a know piece of memory).
    //In the way described above.
    //
    unsigned int*    wsp = new (wsa) unsigned int[5]();

    std::cout << wsa[0] << "\n";   //If these are zero then it worked as described.
    std::cout << wsa[1] << "\n";   //If they contain the numbers 1 - 5 then it failed.
    std::cout << wsa[2] << "\n";
    std::cout << wsa[3] << "\n";
    std::cout << wsa[4] << "\n";
}
```
Résultats:
```
> g++ --version
Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1
Apple LLVM version 5.1 (clang-503.0.40) (based on LLVM 3.4svn)
Target: x86_64-apple-darwin13.2.0
Thread model: posix
> g++ t.cpp
> ./a.out
0
0
0
0
0
>
```
- Et qu'en est surchargé new/new[] opérateurs? Va new unsigned int[5]() toujours de zéro-initialiser le tableau, même si il a un propriétaire, complètement sans rapport avec la mise en œuvre?
- Le operator new est un utilisateur (développeur) la fonction définie, il peut faire ce qu'il aime. La norme ne permet pas de mettre des contraintes sur ce que cette fonction n'. Tout comme operator== pouvez faire tout ce que l'utilisateur définit (il n'a même pas besoin de retourner bool laisser seul test d'égalité (même si c'est mauvais si ce n'est pas)).
- Voir: stackoverflow.com/questions/7194127/...
- Merci. Juste pour être clair: la mise en œuvre de mon propriétaire de l'allocateur n'a rien à voir avec zéro-initialisation et dans le cas de l'utilisation de la () syntaxe de la mémoire tampon sera initialisé à zéro sans aucun rapport avec le type de l'objet alloué et de son constructeur(s)? (Et je suppose que C++11 ne change rien à cet aspect)
- Je ne suis pas sûr. Mais je crois que vous aurez à zéro de la mémoire manuellement, je ne pense pas que la langue va faire quelque chose pour vous (mais je peux me tromper).
- Euh... vous bien que new unsigned int[5]() zéros entiers?
- J'étais à l'époque. N'ont pas regardé à la norme, comme beaucoup récemment. Mais j'ai ajouté le code qui a fortement suggéré il fonctionne comme décrit.
- href="http://stackoverflow.com/a/24248894/560648">stackoverflow.com/a/24248894/560648 🙂 Votre placement nouvel exemple est grand, bien, je devrais avoir utilisé.
- pourquoi est-asm modifié? il est passé par référence au nouvel opérateur? Vraiment, je ne pourrais pas trouver quelque chose sur les arguments passés à la nouvelle de l'opérateur de côté (nothrow), comment cela fonctionne?
- En passant un pointeur avec le nouvel appel est appelé le placement de nouvelles. Voir 8.3.4 New. Pourquoi elle a été modifiée. Parce que nous sommes en forçant la valeur d'initialisation. Voir 11.6 Initializers. Remarque on passe un pointeur vers le nouvel opérateur. La valeur de wsa n'est PAS changé, c'est l'adresse qui est pointé qui est changé.
- Ce qui me manque? Comment ce peut-être la réponse, si la ligne qui produit le zéro est new unsigned int et pas new unsigned int(). (Je sais que la lecture de la suite de la deuxième ligne est UB, je demande juste, pourquoi cette réponse, qui n'explique pas la question, il a été accepté et upvoted au lieu de, par exemple, CBBailey réponse)
- Vous devez demander aux gens qui ont voté. Mais je voudrais dire, c'est non seulement parce qu'il répond à la question (default initialized (ie nothing happens)) mais en plus, fournit des informations pertinentes et utiles à tous les programmeurs. Comment initialiser à zéro de la mémoire et comment il fonctionne avec les tableaux. Le point de la SORTE n'est pas juste pour répondre à la question posée, mais de fournir goo des informations supplémentaires.
- Mais votre réponse ne répond pas à la question (à savoir, "pourquoi la mémoire d'obtenir initialisé à zéro, même si aucune accolades sont utilisées") à tous.
- La question est basée sur une fausse prémisse (que la mémoire est en cours de modification) donc vous ne pouvez pas répondre à cette question. Vous devez expliquer ce qui se passe. Ce qui se passe est: default initialized (ie nothing happens). Elle n'a évidemment répondu à l'OP question comme il l'a marqué la réponse avec une tique (donc il a résolu à sa question).
- Mais pourquoi êtes-vous de poser des questions de ce genre. Si vous pensez qu'il y manque quelque chose dans la réponse, alors vous devriez être la modification de la réponse et en ajoutant les informations manquantes. Vous avez plus qu'assez de réputation pour ce faire. C'est un site collaboratif. Nous essayons et faire les réponses utiles à autant de personnes que possible. Si vous pouvez faire la réponse mieux que vous êtes censé le faire.
- Ma question était littéralement "ce qui me manque?" Avant de commencer à modifier un hautement cotés et a accepté de répondre parce que j'ai pense il manque le point, je suis en train de assurez-vous que ce n'est pas moi qui manque le point. Maintenant, l'op a écrit que j'ai lu, "les nouvelles ne pas initialiser la mémoire avec des zéros" et pourtant, c'est apparemment ce qui se passe selon ses tests, et il demande pourquoi. Votre réponse ne fait que répéter ce que l'OP sait déjà: la "bonne nouvelle" n'est pas censé faire quoi que ce soit, mais - aussi loin que je peux dire - vous ne répondez pas à la question de savoir pourquoi le programme se comportent de la façon dont il le fait?
- "La question est basée sur une fausse prémisse (que la mémoire est en cours de modification) donc vous ne pouvez pas répondre à cette question." Basé sur le programme de sortie, il est en cours de modification.
- Parce qu'il y a deux vaiants. Une variante (tel qu'utilisé par l'OP) ne change pas de mémoire: default initialized (ie nothing happens) et puis la deuxième variante qui vous permet de vous assurer que la mémoire est initialisée zero initialized (ie set to 0) (ce qui est une chose utile à savoir qu'ils ne sais pas, mais j'ai fourni les renseignements, en plus).
- N'hésitez pas à modifier. Pour autant que je suis concerné, la discussion est terminée.
InformationsquelleAutor Martin York
19

operator new n'est pas garanti pour initialiser la mémoire pour rien, et le nouvelle expression qui alloue un unsigned int sans nouvelle-initialiseur feuilles de l'objet avec une valeur indéterminée.

La lecture de la valeur d'un objet non initialisé résultats dans comportement indéfini. Comportement indéfini comprend l'évaluation à la valeur zéro sans les mauvais effets, mais pourrait entraîner chose se passe afin que vous devriez éviter de cause.

En C++11, le langage utilisé est que les objets alloués sont par défaut-initialisé qui pour les non-types de classe signifie qu'aucune initialisation est effectuée. Ceci est différent de la signification de par défaut-initialisé en C++03.

InformationsquelleAutor CB Bailey
4

Avec certains compilateurs, la version de débogage de nouveau va initialiser les données, mais il n'y a certainement rien de ce que vous pouvez compter sur.

Il est également possible que la mémoire juste eu 0 à partir d'une précédente utilisation. Ne présumez pas que rien de ce qui s'est passé à la mémoire entre les supprimer et de nouvelles. Il pourrait y avoir quelque chose dans l'arrière-plan que vous n'avez jamais remarqué. Aussi, la même valeur de pointeur peut ne pas être la même mémoire physique. Pages de mémoire se déplacé et paginées et dans. Un pointeur peut être mappé à un tout autre endroit que la précédente.

Bottom line: si vous n'avez pas spécifiquement l'initialisation d'un emplacement de mémoire, alors vous pouvez supposer rien sur son contenu. Le gestionnaire de mémoire peut même pas l'attribuer à une spécifiques emplacement de mémoire physique jusqu'à l'utilisation de la mémoire.

Moderne de gestion de la mémoire est étonnamment complexe, mais en tant que programmeur C++ vous n'avez pas vraiment (surtout‡). Les règles du jeu et vous n'aurez pas d'ennuis.

‡ Vous avez peut-être si vous êtes l'optimisation afin de réduire les défauts de page.

InformationsquelleAutor Michael J
3

Ce n'est pas operator new, c'est la new de l'opérateur. Il y a effectivement une grande différence! La différence est que operator new est une fonction qui renvoie la mémoire brute; lorsque vous utilisez le new opérateur, il appelle un constructeur pour vous. C'est le constructeur qui est le réglage de la valeur de la int, pas operator new.
- Je pense que le bon terme est "la nouvelle expression", qui appelle le correspondant nouvel opérateur.
InformationsquelleAutor Ernest Friedman-Hill

Vous devez vous connecter pour publier un commentaire.