Question: We can call destructor explicitly through class pointer, why not constructor? Any idea?

```
#include <iostream>

class Con {
public:
    Con( int x ) : x( x ) {

    }

private:
    int x;
};

int main() {
    Con* c = new Con( 1 );
    //c->Con( 2 ); //illegal
    c->~Con(); // ok!
    delete c;
}

```

Thanks,

Answer: 
You can actually call it, it is just that the syntax is not that of calling a member method (of which the destructor is an special case), so it is not done with the *member access* operators. Rather you have to resort to the *placement-new* syntax:

```
Con c;
c.~Con();        // destroy, now c is not a Con anymore
new (&c) Con();  // recreate, now c is a Con again

```

As a particular case, in the C++0x proposal, that is actually used in one of the code examples, providing means to reuse a `union` as a different type in the event of an union containing non-POD elements:

```
union U {
   int i;
   float f;
   std::string s;
};

int main() {
   U u;
   new (&u.s) std::string( "foo" );
   u.s.~string();
   u.i = 5;
}

```

}
A Constructor's intent is to be called when the object is created. Nothing else. If you had a reference counter to keep track of the number of objects, allowing the constructor to be called as a function would mess the counter up.

If you want to reinitialize or reset an object, you can add a function called Reset() or Initialize() and call it from the constructor. Then, you can also call Reset() or Initialize() from an object pointer.