Quote:Original post by Basiror
I know you can easily overload them but how do they call the constructor of a class?

When you invoke new/delete normally the constructor/destructor is invoked automataically, when redefining or overloading operator new/delete you just deal with uninitialized memory you don't need to worry about construction/destruction.

If you explicitly invoke new/delete they will only allocate/de-allocate uninitialized memory, if you need to invoke the constructor later on you would use the placement new operator its sole purpose is to invoke the construtor. Afterwoods for user-defined types only you must explicitly invoke destructor yourself when using placement new :

#include <cstddef>	// size_t#include <algorithm>	// copy, for_each#include <iterator>	// ostream_iterator#include <new>		// global operators new/delete, placement new#include <memory>	// uninitialized_fill#include <iostream>	// cout, basic_ostreamstruct foo {  int j;  foo(int i): j(i) {}};template < typename CharT, typename Traits >inline std::basic_ostream<CharT, Traits>&operator<<(std::basic_ostream<CharT, Traits>& out, const foo& f) {  return out << f.j;}int main() {  const std::size_t num_elems = 30;  foo* foos = static_cast<foo*>(::operator new(sizeof(foo) * num_elems)); // allocate only  std::uninitialized_fill(foos, foos + num_elems, foo(40)); // construct elements only, uses placement new  std::copy(foos, foos + num_elems, std::ostream_iterator<foo>(std::cout, "\n"));	// print out  struct foo_destructor {     void operator()(const foo& f) const {	f.~foo();      }  };  std::for_each(foos, foos + num_elems, foo_destructor());	// destruct all elements only    ::operator delete(foos);   //	de-allocates memory only}

The c++ standard library comes with some generic algorithms that work with uninitialized memory, they are in the header memory.

I think its not worth taking complete control over memory management on modern C++ compilers as they should already be optimal for large allocations, its only small allocations you want to optimize.

The loki library has a small object allocator you can use. It is also worth using pooled allocators in some places aswell you do not need to take over memory management for that and libraries such boost already come with good pooled allocators even ones that can be used with the standard library containers.