Is it *legal* (as opposed to sensible) to explicitly destruct anobject and deallocate the memory?

[Stuart Golodetz]

Hi all,

Just feeling curious -- I know the following is ill-advised, but is it
actually formally illegal?

#include <iostream>

struct X
{
~X()
{
std::cout << "~X()\n";
}
};

int main()
{
X *x = new X;
//delete x;
x->~X();
:perator delete(x);
return 0;
}

It would certainly be legal in the context of *placement* new, but is
there a requirement in the standard that all "new"s are matched by
"delete"s, rather than "operator delete"s?

Cheers,
Stu

 

[Öö Tiib]

Hi all,

Just feeling curious -- I know the following is ill-advised, but is it
actually formally illegal?

#include <iostream>

struct X
{
        ~X()
        {
                std::cout << "~X()\n";
        }

};

int main()
{
        X *x = new X;
        //delete x;
        x->~X();
        :perator delete(x);
        return 0;

}

It would certainly be legal in the context of *placement* new, but is
there a requirement in the standard that all "new"s are matched by
"delete"s, rather than "operator delete"s?

It feels legal. It is doing all same things in same order what simple
'delete x;' is doing by standard.

 

[Stuart Golodetz]

It feels legal. It is doing all same things in same order what simple
'delete x;' is doing by standard.

Thanks -- I think I'd expect it to work, just curious because it's the
sort of thing that might be formally undefined for some reason that I
haven't come across.

Stu

 

[Stuart Golodetz]

<snip -- sorry, hit the quoted lines limit>

The following might be a consideration:

struct foo
{
foo()
{
std::cout << "foo ctor called\n";
}
~foo()
{
std::cout << "foo dtor called\n";
}
void* operator new(std::size_t aSize)
{
std::cout << "overloaded operator new called\n";
return :perator new(aSize);
}
void operator delete(void* p)
{
std::cout << "overloaded operator delete called\n";
return :perator delete(p);
}
};

int main()
{
foo *x = new foo;
delete x;
//x->~foo();
//:perator delete(x);

foo *y = new foo;
//delete y;
y->~foo();
:perator delete(y);

return 0;
}

outputs:

overloaded operator new called
foo ctor called
foo dtor called
overloaded operator delete called
overloaded operator new called
foo ctor called
foo dtor called

/Leigh

That certainly seems to add one more reason why it's not a sensible
thing to do, at any rate

Cheers!
Stu

 

[Armel]

Hi all,

Just feeling curious -- I know the following is ill-advised, but is it
actually formally illegal?

#include <iostream>

struct X
{
~X()
{
std::cout << "~X()\n";
}
};

int main()
{
X *x = new X;
//delete x;
x->~X();
:perator delete(x);
return 0;
}

It would certainly be legal in the context of *placement* new, but is
there a requirement in the standard that all "new"s are matched by
"delete"s, rather than "operator delete"s?

Cheers,
Stu

destructing "by hand" that way is particularly useful when
constructing/destructing objects cannot use standard new/delete operators,
for example to implement classes like the "any" concept and using some
memory place over time to store different objects of classes A then B then
C.
in these constructions the 'placement' new is as well generally used (i.e.
new (x_ptr) X; )

Regards