I hate that you can't take a pointer to constructors and destructors. Also a lot of the time there's a huge separation between allocation and initialization, though constructors attempt to package this into a single piece of code. Lastly C++ sucks when you define a constructor and yet want to create an array of your object on the stack and you get the error saying that's not possible without a trivial default constructor.
It seems like the moment you start really using constructors and destructors you have to subscribe to a bunch of other OO nonsense. At least, this is my own opinion.
You appear to have several fundamental misunderstandings about constructors.
1. Constructors have little to nothing to do with allocation.
You allocate something when you define a variable (of that type) or call an appropriate allocation function. As a consequence of defining a variable of a particular type, the constructor for said type will be called. As that is, after all, what you asked it to do. Calling new implicitly invokes the constructor of the type you are attempting to instantiate because that's what you asked it to do "Please allocate enough memory for this type (aligned for the type using fundamental alignment rules) and then construct this type in that memory block."
Should you desire a random blob of memory, you can do that too. malloc and ::operator new both return pointers to blocks of memory aligned to the largest fundamental type it can store.
2. If you define a type and attempt to create an array of said type, guess what? It has to be able to call the constructors of said type. As you attempted to create an array of said type, the assumption is that you would like the constructors to be called. Otherwise you should have just asked for a blob of bytes. If there is no default constructor available then you need to brace initialize it (C++11 and above) and supply the appropriate copy or move constructors.
IE issues - things you don't want to do for some reason in a custom constructor or destructor?
Avoid complex behaviors, substantial allocations, or long tasks. A constructor should be a fairly trivial thing that gets the object in sound working order, ready to be used. Anything that can fail, unless you're writing exception safe code should, generally speaking, not be done in the constructor.
Destructors should be fail safe, same deal as with constructors, but a greater emphasis on "do not do stupid things here that will fail."
Use initializer lists. Avoid overly long parameter lists (prefer passing in structures or pointer/references to structures. Avoid having output parameters on constructors (it's confusing, and see above about errors).