Quand est #include <nouveau> bibliothèque nécessaire en C++?

Selon cette entrée de référence de l'opérateur new
( http://www.cplusplus.com/reference/std/new/operator%20new/ ) :

Dynamique globale de stockage de l'opérateur
les fonctions spéciales sont dans la norme
bibliothèque:

  • Les trois versions du nouvel opérateur sont déclarés dans l'espace de noms global,
    pas dans l'espace de noms std.
  • La première et deuxième versions sont déclarées implicitement dans tous les
    l'unité de traduction d'un programme C++: La
    l'en-tête n'a pas besoin d'être
    inclus pour eux d'être présents.

Il me semble que cela implique que la troisième version de l'opérateur new (placement nouveau) n'est pas déclarée implicitement dans chaque unité de traduction d'un programme C++ et de l'en-tête <new> ne doivent être inclus pour elle d'être présent. Est-ce exact?

Si oui, comment est-ce que l'utilisation des deux g++ et MS VC++ Express compilateurs il semble que je peux compiler du code en utilisant la troisième version de la nouvelle, sans #include <new> dans mon code source?

Aussi, le MSDN Bibliothèque C++ Standard de référence d'entrée sur le panneau de nouvelle donne quelques exemples de code pour les trois formes de l'opérateur new qui contient le #include <new> déclaration, cependant l'exemple semble compiler et exécuter tout de même pour moi, sans que cela comprend?

//new_op_new.cpp
//compile with: /EHsc
#include<new>
#include<iostream>

using namespace std;

class MyClass 
{
public: 
   MyClass( )
   {
      cout << "Construction MyClass." << this << endl;
   };

   ~MyClass( )
   {
      imember = 0; cout << "Destructing MyClass." << this << endl;
   };
   int imember;
};

int main( ) 
{
   //The first form of new delete
   MyClass* fPtr = new MyClass;
   delete fPtr;

   //The second form of new delete
   char x[sizeof( MyClass )];
   MyClass* fPtr2 = new( &x[0] ) MyClass;
   fPtr2 -> ~MyClass();
   cout << "The address of x[0] is : " << ( void* )&x[0] << endl;

   //The third form of new delete
   MyClass* fPtr3 = new( nothrow ) MyClass;
   delete fPtr3;
}

Quelqu'un pourrait jeter quelque lumière sur ce et quand, et pourquoi, vous pourriez avoir besoin pour #include <new> - peut-être un exemple de code qui ne compile pas sans #include <new> ?

Grâce.

InformationsquelleAutor Paul Caheny | 2010-05-07
  1. 11

    Rien en C++ empêche la norme en-têtes, y compris d'autres en-têtes standard. Donc, si vous incluez tout en-tête standard, vous pourriez peut-être indirectement inclure tous d'entre eux. Toutefois, ce comportement est totalement dépendant de l'implémentation, et si vous avez besoin des fonctionnalités d'un en-tête spécifique, vous devez toujours inclure explicitement par vous-même.

    • Ainsi, avec le code et les compilateurs, j'ai essayé (voir la question d'origine), l'explication la plus probable pour elle la compilation ok sans l'include <nouveau>, c'est que les autres en-têtes, j'ai inclus ont eux-mêmes inclus le <nouveau> bibliothèque? Si je suis la compréhension de votre réponse correctement alors que permettrait de résoudre mon désarroi et semble plausible.
    • ~Czarak Yup. Par exemple, dans le CCAG mise en œuvre-je utiliser l'en-tête <functional> comprend <new> - il peut y en avoir d'autres.
    • Merci Neil, très concis réponse à ma question centrale.
    • -1 Ce n'est pas la réponse à la question dans le titre, “Quand est - #include <nouveau> bibliothèque nécessaire en C++?”. Je suppose que ce serait OK avec les OP. Mais c'est le problème lorsque cette question est utilisé comme référent pour un proche,-dupliquer de quelque autre question.
    InformationsquelleAutor
  2. 13

    La Norme C++ verset 3.7.4.2 dit :-

    La bibliothèque fournit des définitions par défaut pour le mondial de l'allocation et de désallocation de fonctions. Certains globale de l'allocation et de désallocation de fonctions sont remplaçables (18.6.1). Un programme C++ doit fournir au plus une définition d'un remplaçable d'allocation et de désallocation de la fonction. Une telle définition de la fonction remplace la version par défaut fournis dans la bibliothèque (17.6.3.6).
    La suite de l'allocation et la libération des fonctions (18.6) sont déclarées implicitement dans la portée globale dans chaque unité de traduction d'un programme. 

    void* operator new(std::size_t) throw(std::bad_alloc); 
void* operator new[](std::size_t) throw std::bad_alloc); 
void operator delete(void*) throw(); 
void operator delete[](void*) throw();

    Ces implicite déclarations de présenter uniquement les noms des fonctions de nouvel opérateur, l'opérateur new[], suppression de l'opérateur, l'opérateur delete[]. [ Note: l'implicite déclarations ne présentons pas les noms std std::bad_alloc, et std::size_t, ou tout autre nom de la bibliothèque utilise pour déclarer ces noms. Ainsi, un newexpression, supprimez-expression ou un appel de fonction qui renvoie à l'une de ces fonctions, sans y compris l'en-tête est bien formé. Toutefois, se référant à std std::bad_alloc, et std::size_t est mal formé, à moins que le nom a été déclarée en incluant l'en-tête approprié. —fin de la remarque ]

    Aussi, le std::nothrow version de la operator new exige l'inclusion de l'en-tête.
    La référence, mais ne précise pas inclusion implicite de l'en-tête des fichiers dans d'autres fichiers d'en-tête. Donc, il est sûr et portable pour suivre la norme lorsque les noms std::bad_alloc etc sont visés.

    • Merci pour votre réponse - je suis tout, sauf les deux dernières phrases de votre réponse - pouvez-vous développer ou préciser?
    • Cela signifie, si vous voulez que votre code soit portable, ne comptez pas sur l'implicite de l'en-tête comprend de votre mise en œuvre. Vérifiez auprès de sources fiables (comme la Norme) pour l'en-tête exact qui déclare les fonctions. l'essentiel, c'est que Si tout vous avez besoin de prendre votre défaillance de la mémoire des erreurs, vous devez inclure <new> parce que both std::bad_alloc et std::nothrow sont définis il y!
    • je vous remercie pour votre entrée, il a été très utile.
    InformationsquelleAutor Abhay
  3. 5

    Sur la question dans le titre,

    ” Quand est #include <new> bibliothèque nécessaire en C++?

    Le mot-clé new peut être utilisé de diverses façons. Usage ordinaire et ne pas exiger l'inclusion de tous les en-têtes. Mais un moyen possible d'utiliser ce mot-clé est de lancer le particulier de la “mise en place de la nouvelle” fonction définie par la <new> en-tête. Avec cette utilisation, vous devez directement ou indirectement inclure la <new> en-tête. Ne pas inclure cet en-tête, ou tout autre en-tête, à moins que vous en avez besoin; ne pas inclure les en-têtes par défaut. En revanche, ne comptez pas sur une mise en œuvre de la version spécifique d'un en-tête, y compris une autre: toujours inclure ce que vous avez besoin, conformément à la norme (ou d'autres) les spécifications de ce qu'ils fournissent.

    Sur la question dans le corps,

    ” l'exemple semble compiler et exécuter tout de même pour moi, sans que cela comprend?

    En C++ de la bibliothèque standard les en-têtes sont autorisés à inclure d'autres de la bibliothèque standard les en-têtes (ou les trucs fournis par d'autres de la bibliothèque standard en-têtes), à la mise en œuvre de la discrétion.

    InformationsquelleAutor Cheers and hth. - Alf
  4. 2

    Opérateur new défini dans <new> en-tête de lance bad_alloc exception (ce qui est déclaré dans le même en-tête) au lieu de retourner la valeur NULL lorsque l'allocation de la mémoire n'est pas possible. <new> en-tête définit également

    void* operator new (std::size_t size, const std::nothrow_t& nothrow_constant) throw();

    variante qui n'est pas de lancer des exceptions et le placement de la nouvelle variante. Sans <new> vous obtenez seulement âgé de plaine, NULL-retour operator new. Tous les trois la surcharge de l'opérateur:

    void* operator new (std::size_t size) throw (std::bad_alloc);
void* operator new (std::size_t size, const std::nothrow_t& nothrow_constant) throw();
void* operator new (std::size_t size, void* ptr) throw();

    sont déclarées dans <new> en-tête. Cependant, certains compilateurs peuvent les rendre disponibles de façon implicite, mais ce n'est pas standard, et vous ne devriez pas compter sur elle.

    • C'est l'inverse. Le lancement de nouvelles est la valeur par défaut, nothrow faut inclure <nouveau>.
    • Je pense que c'est l'inverse. Si vous n'incluez pas <new>, vous obtenez l'exception de la version de la nouvelle (qui est la valeur par défaut, selon la norme). Vous n'avez pas besoin de la déclaration de std::bad_alloc pour appeler de nouveaux, seulement si vous voulez attraper l'exception. Si vous voulez le nothrow version, vous devez inclure <new>, depuis std::nothrow est définie dans cet en-tête.
    • Il s'avère que vous avez raison. Mais, comment se fait-il travailler quand le C++ n'ont pas des exceptions?
    • étrange choix par défaut, de sorte que si je veux le lancer, afin de ne pas inclure <new> mais il est inclus par inadvertance par le biais de certains autres éléments?
    • aussi, il semble que std::bad_array_new_length nous oblige à inclure <new>
    InformationsquelleAutor el.pescado