calling constructor of the class in the destructor of the same class

Answer 1

When the following runs

test();

you construct a temporary (new) object that is immediately destroyed when control "passes by the semicolon", the destructor for that temporary object is invoked, which constructs another temporary object, etc., so you get a death spiral of endless recursive calls which leads to a stack overflow and crashes your program.

Prohibiting the destructor from creating temporary objects would be ridiculous - it would severely limit you in what code you could right. Also it makes no sense - the destructor is destroying the current object, and those temporary object are completely irrelevant to it, so enforcing such constrains on them is meaningless.

Answer 2

As far as I understand you're simply instantiate new test object in the destructor and leave it intact.

Answer 3

Static analysis tools are the things which should complain. For me your case is not very different from the following:

void foo();
void bar()
{
   foo();
}
void foo()
{
   bar();
}

I don't know are there any compilers which will complain about above code, but this example is much simpler than yours and there can be many others.

EDIT: In your case the problem is much simpler. It's an ordinary infinite recursion, because the idea of your destructor is somewhat like that:

   ~test()
   {
      cout<<"DTOR"<<endl;
      test tmp();
      tmp.~test(); // infinite recursion.
   }

Answer 4

I see no reason why it should be illegal, but I admit I'm struggling to come up with a decent example of why I'd do this. To make it "work" you'd need to conditionally call the c'tor rather than unconditionally.

Answer 5

This code, which gives the test instances a large size, actually produces a stack overflow very quickly, because of the infinite recursion:

#include <iostream>
using namespace std;
class test{
   public:
    int a[10000];
    test(){
     }

~test() {
 test();
 }};

int main() {
    test t;
}

C++ does not require that a warning be issued for infinite recursion, and in general it is very difficult to detect.