Quel est le C++ opérateur de nouveau faire d'autre que de l'allocation et un ctor appel?

Quelles sont toutes les autres choses de la new opérateur n'est autre que l'allocation de mémoire et d'appel à un constructeur?

OriginalL'auteur yesraaj | 2008-12-18

c++new-operator

16

La norme C++ a ceci à dire à propos de l'objet sur la forme (la forme habituellement utilisée) de l'opérateur de nouveau à partir de la <new> en-tête:

Comportement requis:

Retourner un pointeur non null pour correctement alignés de stockage (3.7.3), ou encore jeter un
exception bad_alloc. Cette exigence est obligatoire pour un remplacement de la version de cette fonction.

Comportement par défaut:

— Exécute une boucle: à l'Intérieur de la boucle, la fonction première tente d'allouer de la demande de stockage. Si
la tentative implique un appel à la bibliothèque Standard C de la fonction malloc est indéterminé.

— Retourne un pointeur vers le stockage alloué si la tentative est couronnée de succès. Sinon, si le dernier argument
set_new_handler() est un pointeur null, jeter bad_alloc.

— Dans le cas contraire, les appels de fonction de l'actuel new_handler (18.4.2.2). Si la fonction appelée retourne, la boucle
les répétitions.

— La boucle s'arrête quand une tentative d'allouer de la demande de stockage est réussie ou lorsque que l'on appelle le
new_handler fonction ne retourne pas.

Le standard a beaucoup d'autres choses à dire sur le nouvel opérateur et de l'allocation dynamique de la mémoire (énormément de choses à dire), mais je pense que le "comportement par Défaut de la liste des" résume les principes de base de l'opérateur de nouveau assez bien.

Est-il quelque chose comme la façon dont la taille de l'objet est stocké avec la nouvelle.Donc, qui peut être utilisé lors de la suppression de l'objet à l'aide du pointeur de la
C'est sûrement à gauche pour la mise en œuvre et seront différentes entre les plates-formes.
Ce n'est pas spécifiée par la norme. Généralement malloc() ou quelque chose de similaire sera utilisé et la taille du bloc de mémoire sera conservée en utilisant le même type de techniques (ou identiques si la fonction malloc() est utilisée).
Et si vous êtes en train de faire un tableau de new/delete, les techniques utilisées peuvent être l'une de celles abordées dans le C++ FAQ Lite: parashift.com/c++-faq-lite/freestore-mgmt.html#faq-16.14
Il n'y a pas besoin de stocker la taille du bloc alloué pour seul objet de nouvelles depuis la suppression de la déclaration connaît la taille de l'objet et peut ainsi libérer de l'espace.

OriginalL'auteur Michael Burr
9

J'ai écrit une explication de ce qu'il fait dans cette réponse. Il explique comment
- new obtient la mémoire
- new poignées de défaillance de la mémoire
- new poignées constructeur exceptions
- new poignées de placement spécial et nothrow versions
Michael a expliqué comment la valeur par défaut de l'allocateur de fonction (::operator new) obtient la mémoire bien et la façon dont il traite l'échec. J'ai vu votre question sur l'endroit où la taille d'un objet est stocké dans ses commentaires. La réponse est, il n'y a pas de taille stockées si pas necassary. Rappelez-vous que C n'a pas besoin de la taille pour free (et ::operator new pouvez simplement utiliser malloc):
```
void * memory = malloc(x);
free (memory); //no need to tell it the size
```
Voici un exemple où l'on voit comment le stockage de la taille a un impact sur la taille de la répartition de la forme matricielle d'une nouvelle expression (non couvert par mon autre réponse):
```
#include <cstddef>
#include <iostream>

struct f {
    //requests allocation of t bytes
    void * operator new[](std::size_t t) throw() {
        void *p = ::operator new[](t);
        std::cout << "new    p: " << p << std::endl;
        std::cout << "new size: " << t << std::endl;
        return p;
    }

    //requests deleting of t bytes starting at p
    void operator delete[](void *p, std::size_t t) throw() {
        std::cout << "delete p: " << p << std::endl;
        std::cout << "size    : " << t << std::endl;
        return ::operator delete[](p);
    }
};

int main() {
    std::cout << "sizeof f: " << sizeof (f) << std::endl;

    f * f_ = new f[1];
    std::cout << "&f_     : " << f_ << std::endl;
    delete[] f_;
}
```
Il permet d'imprimer quelque chose comme ceci:
```
sizeof f: 1
new    p: 0x93fe008
new size: 5
&f_     : 0x93fe00c
delete p: 0x93fe008
size    : 5
```
Un octet pour l'objet lui-même et de 4 octets pour le comte qui est stocké juste avant la répartition de la zone de l'objet. Maintenant, si nous utilisons la fonction de libération sans un paramètre de taille (juste de l'enlever de l'opérateur delete), on obtient ce résultat:
```
sizeof f: 1
new    p: 0x9451008
new size: 1
&f_     : 0x9451008
delete p: 0x9451008
```
Le C++ runtime ici ne se soucie pas de la taille, afin de ne pas stocker plus. Notez que c'est très mise en œuvre spécifique, et c'est ce que gcc ne ici pour être en mesure de vous dire la taille du membre de la suppression de l'opérateur. D'autres implémentations peut toujours stocker la taille, et sera très probablement si il est un destructeur d'invoquer pour la classe. Par exemple, juste l'ajout de ~f() { } ci-dessus permet de gcc pour stocker la taille, quelque soit ce que la fonction de libération nous écrire.

Pourriez-vous expliquer la syntaxe de cette operator delete[] avec la taille lors de la mise en œuvre d'un pool de mémoire, c'est à dire pourriez-vous m'aider avec stackoverflow.com/questions/2322742? Merci!

OriginalL'auteur Johannes Schaub - litb
0

Dépend si c'est en surcharge ou pas, si vous avez construit l'application à des fins de débogage, si vous êtes à l'aide d'un détecteur de fuite de mémoire, si vous avez une sorte de mémoire de mise en commun, si vous avez quelque chose comme l'Boehm garbage collector qui est de marquage/absence de marquage bits, etc., etc. Il pourrait faire beaucoup d'affaires à l'intérieur, ou rien de spécial à tous.

Je pense qu'il a couvert en disant "Standard"

OriginalL'auteur Michel

Vous devez vous connecter pour publier un commentaire.