nouveau sur pile au lieu de tas (comme alloca vs malloc)

Est-il un moyen d'utiliser le new mot-clé à allouer sur la pile (ala alloca) au lieu de tas (malloc) ?

Je sais que je peut pirater mon propre mais je préfère ne pas.

source d'informationauteur

  1. 23

    À allouer sur la pile, soit déclarer votre objet, comme une variable locale en valeurou vous pouvez réellement utiliser alloca pour obtenir un pointeur, puis l'utilisation de la nouvelle l'opérateur:

    void *p = alloca(sizeof(Whatever));
new (p) Whatever(constructorArguments);

    Cependant, tout en utilisant des alloca et en place de nouveaux assure que la mémoire est libérée sur le retour, vous donner automatique destructeur de l'appelant. Si vous êtes juste essayer de s'assurer que la mémoire est libérée lors de la sortie de l'application, pensez à utiliser std::auto_ptr<T> ou quelque autre type pointeur intelligent.

  2. 12

    Jeffrey Hantin est tout à fait exact que vous pouvez utiliser le placement de nouvelles d'en créer un sur la pile avec les alloca. Mais, sérieusement, pourquoi?! Au lieu de cela, il suffit de faire:

    class C { /* ... */ };

void func() {
    C var;
    C *ptr = &var;

    //do whatever with ptr
}

    Vous avez maintenant un pointeur vers un objet alloué sur la pile. Et, il va bien être détruits lors de votre fonction existe.

  3. 5

    Que vous pouvez faire:

    Whatever* aWhatever = new ( alloca(sizeof(Whatever)) ) Whatever;

    Vous pourriez utilise un RAII classe pour faire de la destruction, je suppose (EDIT: voir Aussi cette autre réponse pour plus d'informations sur les problèmes potentiels de cette approche):

    template <class TYPE>
class RAII
    {
    public:
        explicit RAII( TYPE* p ) : ptr(p) {}
        ~RAII() { ptr->~TYPE(); }
        TYPE& operator*() const { return *ptr; }
    private:
        TYPE* ptr;
    }

void example()
    {
    RAII<Whatever> ptr = new ( alloca(sizeof(Whatever)) ) Whatever;
    }

    Vous pouvez utiliser une macro pour masquer l'alloca.

    Ce qui concerne
    DaveF

  4. 2

    Être prudent lors de l'utilisation de _alloca() avec GCC

    GCC a un bug qui fait _alloca() incompatible avec SJLJ la gestion des exceptions en C++ (Dwarf2 fonctionne correctement). Lorsqu'une exception est levée de la fonction de l'allocation de la mémoire, le bug provoque une altération de la pile avant de la destructeurs d'arriver à courir. Cela signifie que toute RAII classe de travail sur l'objet alloué(s) a pour exécuter dans une autre fonction pour fonctionner correctement. La façon correcte de le faire, il ressemble à ceci:

    void AllocateAndDoSomething()
{
  Foo* pFoo = reinterpret_cast<Foo*>(_alloca(sizeof(Foo)));
  new (pFoo) Foo;

  //WARNING: This will not work correctly!
  //ScopedDestructor autoDestroy(pFoo);
  //pFoo->DoSomething();

  //Instead, do like this:
  DoSomething(pFoo);
}

void DoSomething(Foo* pFoo)
{
  //Here, destruction will take place in a different call frame, where problems
  //with _alloca() automatic management do not occur.
  ScopedDestructor autoDestroy(pFoo);
  pFoo->DoSomething();
}